If you want AI to take a small feature off your plate, give it responsibility for bringing that feature back ready for you to verify.
Otherwise, you can spend the whole session coordinating the implementation. You prompt some code into existence, run the tests, paste an error back, check the next attempt, and ask it to fix something an automated review could have caught. AI is writing the code, but you’re still babysitting the work.
I’d aim for two main human touch points: define the goal at the beginning, then come back to verify the behavior and judge the implementation. Have the agent handle the routine work between those points.
Each touch point might involve some conversation. The goal is to keep your involvement focused on decisions that require your judgment.
This works best for a small, bounded change. A massive feature needs a different approach, which I cover separately.
Define the goal and the required proof
Before launching the work, clarify what success means.
Have the AI work through the requirement with you. It should identify ambiguity, ask about relevant edge cases, and surface constraints you might have missed. You want to catch those questions before they become assumptions buried in an implementation.
For example, “add filtering to this page” leaves a lot open. Should filters survive a refresh? What happens when there are no results? Does filtering apply to the entire dataset or just the loaded page?
You don’t necessarily need a massive implementation plan. You need enough clarity that the agent can tell whether it has finished the feature.
That includes deciding what proof it should produce. If the requirement changes user-visible behavior, the agent should exercise that behavior. If it fixes a bug, it should demonstrate the failure and provide regression coverage. The evidence needs to follow the requirement.
Once that target is clear, let it execute.
Have AI finish the routine work
The agent should implement the feature, add appropriate tests, run verification, and address failures. Have it obtain independent AI review and fix the findings before returning the work to you.
It can open a draft PR and present the evidence there. The handoff should explain what was implemented, how the requirements were checked, and any unresolved issues.
This is what I mean by bringing the feature back in a verification state. You should be able to evaluate the result without first discovering that the agent never ran the application or left a known test failure for you to sort out.
I’d turn this into a repeatable workflow or skill. Set the expectation once: implementation, verification, review, repair, then handoff. You shouldn’t have to prompt each step separately every time.
If it encounters a decision that needs your judgment, it should bring that to you. Routine failures should stay inside its execution loop.
Verify the behavior and simplify the implementation
Now come back into the loop.
First, verify that the feature does what you intended. Automated checks can pass against an incorrect interpretation of the requirement. You still need to look at the result and decide whether it solves the problem.
Then inspect the shape of the implementation. How much scrutiny it needs depends on the code, but I’d at least look at the architecture and the size of the change.
If it looks a little crazy, intervene.
Sometimes the existing architecture already supports the requirement, and the AI has introduced unnecessary machinery. Ask it to find the simpler change. Sometimes the underlying code needs a refactor so the feature becomes straightforward. You can also give it a simplification pass: remove unnecessary abstractions, reduce the number of concepts, and reuse what’s already there.
Have it verify the revised implementation again.
Once you’re satisfied with the behavior and design, have AI prepare the reviewable slices and shepherd them through CI and feedback. That connects to the review-throughput practice from the previous article.
For a small feature, defining the goal and judging the result are useful places to spend your attention. Give the agent responsibility for doing enough work between them that you can step away.