I haven't written code by hand in over a year
For a bit more than a year, every line of code I ship has been written by an AI agent. The agent is Claude Code. I still do engineering, but my part of it is different now: I write specifications, I read diffs and review findings, I check behavior, and I decide what ships. I don’t type the implementation.
This is not an experiment on a side project. It is how I work on three very different things:
- Client work through Toptal. A production SaaS platform where I am the only backend developer on a small team. Other people depend on what I merge.
- Pressa. My own product: document infrastructure for AI agents. You ask your AI for an invoice or a contract and get a typeset PDF back. I started it on April 2, 2026, alone.
- Choose.place. Geography games and travel guides, also solo, started in December 2025.
Here is what that looks like in numbers, measured on November 18, 2026:
| Project | Started | Commits | Tests |
|---|---|---|---|
| Client project | 2025 | 2,530 by me in 2026 | about 15,600 (whole team) |
| Pressa | April 2026 | 366 | 2,512 RSpec examples |
| Choose.place | December 2025 | 1,372 | 7,797 RSpec examples |
Commit counts don’t measure value, and I’m not presenting them as productivity. They show that this is a daily practice with real users on the other end, not a weekend demo.
The loop
The tools differ a little between projects. The loop does not.
- I write the spec. What the change must do, what it must not do, and acceptance criteria that can be turned into tests. This is where most of my time goes now, and it should. A vague spec produces confident, wrong code.
- Tests come first. They have to fail before the implementation exists. A test that passes on an empty implementation proves nothing.
- The agent implements until the tests pass and the full suite is green.
- A fresh agent reviews the diff. Not the agent that wrote the code: the author defends its own solution. The reviewer sees only the changed lines. If it finds a problem, the fix goes back to the implementer, and then a new reviewer looks again. This repeats until a reviewer answers “No issues found.”
- Verification against the running system. A Rails console check, a real browser driven by Playwright, a request against staging. Tests prove what the tests check and nothing more.
- I decide what ships. On my own products an agent may run the push once I’ve said yes. On the client project, production goes through the team. Messages to people, whether a client, a teammate or a user, are mine every time.
The review loop is the part people skip, and it’s the part that pays. On Pressa, an independent reviewer caught a bug before it shipped: a malformed User-Agent header would make a database insert fail inside a rescue block that swallowed the error. The caller would still get the PDF, and the request would never count against the monthly quota. The tests didn’t cover that header. A reader who didn’t write the code noticed that a bad header would be swallowed by that rescue without a trace.
Client work: other people depend on it
On the client project the difference is that a teammate will build on what I merge, and a mobile developer will call the API I describe. That changes two things.
First, tickets. When an agent picks up a ticket, it starts from zero and sees only that text. So after I write a ticket, I check it against the code before I mark it ready: every name exists exactly as written, every SQL snippet returns the set the text describes, every “done when” can be written as a test. The first time I did this on three tickets I thought were solid, the check found a wrong test file name in all three of them.
Second, the agent doesn’t have to wait for me. A small computer at home checks the issue tracker every hour, picks up tickets I’ve labeled as ready, and takes each one through implementation, independent review, verification, an automated Codex review and full test runs before and after review, all the way to a merge on staging. Since mid-August it has merged 171 tickets. Production is a separate step that goes through the team’s review. I wrote about how it works, and what broke in it, in A ticket goes in, a reviewed merge comes out.
Pressa: a product built by agents, for agents
Pressa is the clearest case, because there is no one else on it. One Claude session acts as the orchestrator. It doesn’t write the code for larger changes; it starts an implementer agent with the spec and the constraints, then starts a second, independent agent whose prompt says, in effect: don’t believe the implementer, verify everything yourself. That reviewer reruns the tests, reruns the linter, checks that every file path the implementer mentioned actually exists, and returns PASS, FAIL or PASS with concerns. Only then does the orchestrator update the docs, commit and deploy.
Two failures shaped the checks around it.
In April, two pull requests passed 1,033 of 1,033 tests locally and failed in CI. Locally the test environment loaded code lazily; in CI it loaded everything up front, and Rails was strict about two problems that lazy loading never touched. Since then, any change that touches autoloading runs the suite exactly the way CI does before it is pushed.
Later, a release of the Pressa MCP package went out with a binary that wasn’t executable. Installing it fresh worked. Updating an existing installation didn’t, and in the Claude desktop app it failed with “Permission denied”. Now the package is installed and started from the tarball before it is published, and again from npm after it is published. If the first run fails, nothing is published. If the second fails, the registry listing is not updated.
Neither rule is clever. Both exist because a green report was wrong.
Choose.place: a solo SaaS
Choose.place is the larger of my own codebases: games on vector maps, a daily challenge, subscriptions and billing, transactional email, error monitoring, CI/CD and hosting, all built and run by me with agents. The 7,797 tests are the reason I can change it quickly without being afraid of it.
Agents help with the content as well, with research, writing, fact-checking and review. The rule there is strict: no fact comes from a model’s memory. If a claim can’t be confirmed from a source checked in that session, it gets softened or cut. A list of banned phrases lives in one file that both the checking scripts and CI read, and nothing goes live until I approve it.
What went wrong
The failures are more useful than the wins, so here are a few:
- Backups that didn’t exist. Pressa’s nightly backup job reported success every night. The production image had no
pg_dump, the output was piped through gzip, and gzip’s exit code was zero. The job wrote 20-byte files and logged “Created backup (0.0 MB)”. An audit in September found it. - An agent on the wrong model. For a week, the agent on my home server implemented, reviewed and verified 16 tickets on a smaller model than I intended, because the command-line call never passed a model flag. The tickets were merged and the tests were green. Nothing in the output said so.
- This website. I built it with an agent last December. The favicon and the image LinkedIn shows when someone shares the link were six bytes of garbage for eleven months. I never opened the page the way a visitor would.
Every one of these is a verification failure, not a code-writing failure. The agent wrote what it was asked to write. Nobody checked the thing that mattered. I wrote more about the checks I run now in The agent says it’s done. Here’s how I check.
So, is it faster?
Yes. My honest estimate is about three times the output compared to writing the code myself, with more tests and more edge cases covered than I used to write. Not ten times. Three is still a lot.
The time didn’t disappear. I spend it on specs, on reading diffs and review findings, on checking behavior in a browser or on staging, and on deciding. That last part is now the bottleneck, which is how it should be.
If you’re starting with agents on a real codebase, my advice is short:
- Start with the review loop, not with generation. A fresh reviewer that sees only the diff catches what the author can’t.
- Write the rules down where the agent reads them, with the reason next to each rule. I wrote about that in Writing for an agent that starts from zero.
- Check the environment, not only the output. Which model ran, which rules it loaded, which tests it actually ran.
- Keep the irreversible decisions for yourself. An agent can run the deploy command. Whether to deploy, and what to tell people, is a human call.
The agent writes the code. Whether the code is right is still my job.