How I work with AI coding agents: lessons from a year of solo projects

I build side projects alone. Except “alone” doesn’t mean much anymore — a large share of the code is written by AI coding agents. Things like producing several blog posts and a terms-of-service page in one session, or batch-fixing metadata across dozens of posts at once, are now genuinely routine.

After close to a year of working this way, here’s the workflow that stuck.

The workflow

Five steps, every time:

1. Define the problem — write down exactly what I want. This is half the work.
2. Delegate — the agent explores the codebase and writes an implementation plan.
3. Review and approve — I read the plan and check the direction. If this step goes wrong, everything after it goes wrong.
4. Implementation — the agent writes the code and runs tests.
5. Verification — build checks and actually running the thing. For UI work, I check in a real browser.

The key insight: a human must be present at steps 3 and 5. Almost everything else can be delegated.

Two agents, not one

I run a main coding agent and a secondary one. Different tools approach the same problem differently, and when one gets stuck, the other often finds a way through. Keeping a rules file (plain markdown) per project — domain knowledge, conventions, things to never do — keeps the output consistent no matter which tool I’m using.

Three traps I learned the hard way

Starving the agent of context sends it in the wrong direction. “Just figure it out” is the worst possible prompt. Give it the goal, what you’ve already verified, and the relevant file paths. Almost every time an agent produced something strange, the root cause was me being lazy with the explanation.

Generated code still needs review. Code that runs and code that’s good are different things. Agents sometimes invent unnecessary abstractions, or “helpfully” fix things outside the scope of the request. I always read the diff.

Context dies with the session. Today’s agent knows nothing about yesterday’s discussion. So I started writing decisions and project state into markdown docs — and that habit turned into something bigger: what began as notes for the agent became a knowledge base for me.

Is it actually worth it

Work at a scale I couldn’t have attempted alone is now possible — that much is clear. But claims like “10x productivity” are only half true. Code gets written several times faster, yes; the time I spend defining problems and reviewing results went up. The honest summary: the job changed from writing code to setting direction and verifying outcomes.

This blog was built with an agent too. I plan to write that story up separately.