← Robert Kotcher

How I write and review code with AI

One thing has bothered me more than anything else since AI started writing most of my code. I used to read every line of code that shipped, but at Solo the code grew faster than I could read it, and eventually I couldn't keep every part of the system in my head. Once reading everything stopped being possible, I had to figure out what my job actually is. I landed on two things:

  1. Stay the authority. People still decide what the product should do and whether a change is good enough to ship.
  2. Stay responsible. I own every change that ships, so I need real evidence that it works, from checks I trust.

Both commands are built around those two jobs. They settle the spec with the right people first, then hand me each pull request with verified findings and proof that every acceptance criterion works. The diagram shows each command's phases and the shared library functions they use.

These are the two Claude Code commands I use to ship work at Solo. /solo_build takes a ticket I own from spec to pull request, and /solo_review gets any existing pull request ready for my review.

workflow phase phase that writes code (only /solo_build) calls the review engine a person acts (hover for who) evals to build first

The principles behind it

Agents have to prove their work

Anthropic's Best practices for Claude Code makes a point that shaped this whole setup: Claude does its best work when it has a way to check its own work, and an unchecked "done" tells you very little. The review engine is built on that idea. Three reviewers read the PR in fresh contexts, a separate agent tries to disprove every finding before anyone sees it, each acceptance criterion is proven by actually running the app or tests with the evidence attached, and AI acceptance is tied to the exact commit it checked.

Two entry points, one standard

The two flows differ only in who writes the code: /solo_build writes it from a ticket, and /solo_review takes a PR someone already wrote. Everything around that is the same: both settle the spec first, both judge the PR against it with the same engine, and both stop at In Review. Code gets held to the same bar whether a person or an agent wrote it.

Where people fit

People still decide what the product should do and whether the result is good enough; agents do the reading, running, and checking in between. So the agents only ask people product questions, in plain language, on the ticket where the Owner and Reporter already work. They never approve, merge, or move a ticket out of In Review: a person makes those calls, with the findings and proof in front of them.

Human effort up front, so less breaks later

Most of the human effort goes in before any code exists, when answering "what should happen here?" is cheap. That spec becomes the contract every criterion is proven against, so ambiguity turns into a question on the ticket rather than a bug in review or production. By the time a person opens the PR, the AI has already found the bugs it can and shown the evidence, so the human review can focus on judgment instead of hunting for mistakes.

Phase