28 February 2026 · 4 min read
How I work with AI coding tools
How I use coding agents while keeping control of the implementation and review.
IContext
Generated code can pass its tests and still fit poorly into a project. It may duplicate an existing utility, bypass a service layer, or introduce a different pattern for the same task.
I use coding agents to explore, plan, and implement changes. I still need to understand how each change fits into the application.
The workflow below keeps that context in the task and leaves review with me.
IIMy Setup
The stack is deliberately simple:
- Claude Code CLI: exploring the relevant files, planning changes, and implementing tasks in the terminal.
- Neovim: reading code and making direct edits.
- Lazygit: inspecting changes and managing commits.
This setup keeps editing, code review, and Git close together. A clear task and a well-understood codebase matter more to me than the number of tools.
IIIThe Workflow
I use five steps to keep implementation aligned with the project.
1. Explore
First, I trace the relevant data flow and read the existing implementation. I look for service boundaries, validation rules, and reusable utilities before asking for a change.
2. Plan together
I use the agent to compare implementation options and identify tradeoffs. I check its suggestions against the codebase and decide which approach to use.
3. Verify the plan
Before implementation, I identify the files that need to change and the behavior to verify. I work through empty results, failed requests, and interrupted user actions. If a part remains unclear, I investigate it first.
4. Execute
The agent implements the agreed change. I keep the task small enough to inspect the result and revisit the plan when new information changes the approach.
5. Review and commit
I read the diff, run the relevant checks, and resolve anything that does not fit the project. I review the change before it enters Git history.
IVA form implementation
One task involved a form with many fields, nested data, conditional validation, and separate creation and editing flows.
The approach
I mapped the form structure, validation rules, and error states before implementation. This made the differences between creating and editing a record explicit.
I wrote tests for the important scenarios first, including missing nested fields and switching between creation and editing. These checks defined the expected behavior.
The agent then implemented the form against those checks. Failed tests gave us specific behavior to investigate. I still reviewed the implementation and checked the user flow.
The work reinforced the value of explicit requirements and focused tests. They made errors easier to locate and gave the review a clear starting point.
VWhen AI Falls Short
I also use agents to investigate failures. Their suggestions are useful starting points, but I check the evidence before applying a fix.
A suggested null check may hide a problem introduced earlier in the data flow. I trace where the invalid value came from and reproduce the failure before deciding what to change.
Debugging still requires a verified explanation of the failure.
VIResponsibility
Coding agents can help with implementation, but I remain responsible for the design, tests, and result.
I judge the workflow by the changes I can explain and maintain after the session ends.
The useful question is whether I understand and can verify the code I am shipping.
VIIUpdate: May 2026
By May, I had made the workflow more focused.
- Keep tasks focused. I scope each task to a specific behavior and give the agent the context it needs. This makes the output easier to review.
- Match the model to the task. I use a fast model for small edits and a more capable model when the investigation needs it.
- Document project conventions. I use
CLAUDE.mdfiles to record existing patterns and constraints. This reduces repeated corrections.
Smaller tasks and clearer project instructions reduced the time I spent correcting output. I continued to review each change before it entered the codebase.