A small open kit keeps a paper trail for code changes made by AI assistants

The gap Agent Kit targets

AI coding assistants can change many files in one go. Afterward, a reviewer often cannot say what was requested, who agreed to it, or which checks were really run. As dev.to reported, Agent Kit is one attempt to close that gap by keeping a reviewable record inside the project itself.

One caveat up front: the post was written by the person who maintains the kit. It says it describes the documented workflow using an illustrative example, and it is not a benchmark or proof that everything works across every supported tool. Read it as a well-explained proposal, not a test result.

Start small, then approve exactly that

The author's example is deliberately tiny: add Copy buttons to two onboarding prompts. A good plan spells out what each button copies, how success and failure show up, and how someone using only a keyboard can reach the controls. It also lists the checks needed to accept the result.

The sample scope has four parts: copy the full prompt without altering it, show success only after the copy truly worked, show an error the user can recover from if clipboard access fails, and support keyboard use and a narrow screen. The author stresses these are made-up criteria, not a feature that was built or tested.

The kit then follows a fixed sequence: Plan, Approve, Build, Verify, Hand off. Before any coding, a table called WHAT lists the intended work, its purpose, where it lives, its status, and the reason for anything left out. Once the owner approves it, the assistant can finish the whole scope without asking again for every file.

If the job grows in a material way, the plan has to be revised. In the example, touching authentication or redesigning the whole onboarding page would need its own decision. That makes the approval concrete enough to hold up against the final diff, which is the list of lines that changed.

Doing the work is not the same as proving it

At handoff, the same work items are used to report what actually happened. The kit treats a finished edit as one fact and a passing check as another. Whether a person accepts the result, and whether it gets published, are two further decisions.

For the Copy-button case, useful evidence would be an exact match between the prompt text and what ended up on the clipboard, a keyboard test, a look at the narrow layout, and a test of what happens when the browser refuses clipboard access. A picture of the screen can confirm how the buttons look on a small display, yet it says nothing about what landed on the clipboard.

If a check was skipped, the report is meant to say so and note what remains uncertain. The author also warns that a neatly structured report only makes evidence easy to inspect. It does not verify anything by itself.

Memory for the next session

AI chats are often forgotten or unavailable later. The kit therefore keeps four things apart: lasting instructions, stable background about the project, the outcomes you are aiming for, and a single summary of where things stand now. More detailed task records hold decisions and evidence when they are worth keeping. A fresh session can read those files instead of depending on an earlier conversation.

The records need upkeep, though. Sign-off given last week does not cover today's job, and a test that passed earlier tells you nothing about the code as it stands now.

What is in the box, and its limits

Agent Kit includes 17 technical skills, which are bundles of focused guidance, plus optional roles for exploring, building and reviewing. The idea is to load only what the task needs. Tables show how much each skill contributes, but the author says those percentages are subjective estimates, not measured time savings. Using a multi-agent team is optional.

The kit ships setup for four coding assistants: Codex, Claude Code, Gemini CLI, plus Cursor. Grok on the web or in its app gets only a manual reference. The author notes that limits on client-specific testing are documented in the repository, and admits he has not personally used Claude Code, so he makes no claim about how it behaves there.

He is also candid that written instructions only steer the AI. Real protections such as server-side permission checks, isolated environments, automated tests and a person reading the change must come from elsewhere. The template is MIT-licensed, a permissive open-source license, and lives at github.com/khiemnd777/agent-kit.

How to borrow the idea

The author suggests trying it in a throwaway project: ask for one bounded change, read the plan, then compare the final diff and checks with what was approved. If you add it to an established codebase, keep your existing business rules, technology and permissions.

The underlying habit works without the kit. Ask for a written plan before any code, keep each change small, and require a short report that separates what was edited from what was tested. The author also asks for feedback on which records help in a fresh session and which just add busywork.