allanlotta — ~/blog/building-software-with-claude-code
~/blog/building-software-with-claude-code

Building software with Claude Code

Aug 03, 2026 · 2 min

I stopped writing most code by hand about a year ago. I did not stop engineering. The work moved from typing to specifying, reviewing and building the system that does the typing.

This is the setup I use for client work today.

The pipeline

requirement
   ↓
planning        agent reads the repo, proposes a plan
   ↓
implementation  agent writes code in a worktree
   ↓
testing         agent writes and runs tests
   ↓
QA              a second agent exercises the change
   ↓
delivery        pull request with a written summary

Each stage is a separate run with its own context and its own definition of done. That separation matters. A single long session drifts. Short, scoped runs with explicit handoffs stay sharp.

What the human does

I write the requirement. I review the plan before implementation starts. I review the pull request at the end.

Everything between those points runs without me. If the agent is blocked, it stops and says so instead of guessing.

What makes it work

  • A good repository. Clear structure, real tests, a CLAUDE.md that says how things are done. The agent is only as good as the codebase lets it be.
  • Verification the agent can run. Tests, type checks, linters, a dev server it can drive. If the agent cannot check its own work, it will be confidently wrong.
  • Small scope per run. One feature, one bug, one refactor. Big tasks get split before they start.
  • Written handoffs. Every stage writes a short note for the next one. Those notes become the pull request description.

What I measure

Time from requirement to reviewed pull request. Percentage of pull requests merged without changes. Number of times I had to intervene mid-run.

The last number is the one I work hardest to bring down.

EOF
← backnext →