Part 1 of 2 in the Pencils Down series. Part 2 is about the reviewer.
All my code is written by agents now. I only hand-write code when I need to tell an agent something precise. This isn’t a prediction about where the industry is going — DHH just gave it a name at Rails World 2026: 37signals has gone “pencils down” on hand-written code. Hand-writing is now the exceptional state, reserved for when the machine needs fixing. The normal path is to hand an agent an outcome and come back to review what it produced.
The funny part: none of this setup came from DHH. I know who he is — I even follow him on LinkedIn — but I’m not on top of his work, and I didn’t get this setup from him. I read the keynote recap after the fact and found my own setup described back at me — a two-model terminal, one fast model and one for judgment, and the diffs reviewed in Neovim and Lazygit. Same shape, same editor, same staging TUI. Two people reached it independently, from opposite directions. When that happens, it’s not influence. It’s convergence.
And the gap between “the agent says it’s done” and “it’s merged” is where every failure I’ve seen actually lives.
Pencils down doesn’t mean eyes closed. It means the pencil moved — from the writing hand to the reviewing one. And a review process you can’t describe is not a process. It’s a vibe.
The problem with a lone reviewer
Here’s the trap I fell into first: agent writes code, I skim the diff, I merge. Sometimes with an extra rung: agent writes code, agent reviews the code, I skim the diff, I merge. That’s not review, that’s ceremony. One tired human skimming one plausible-looking diff is the weakest possible gate, and it’s exactly as weak whether the code came from your own hands or from a model. Arguably weaker with agents, because agent output is confidently formatted — and agent review is confidently formatted too. It looks reviewed even when it isn’t.
So I stopped trusting any single reviewer. Including myself. Including the agent that wrote the code. Instead I built a pipeline where every artifact gets reviewed against a named bar, by a reviewer with no stake in the artifact, with a human decision point whenever the review finds something. The reviewers are a mix of persona subagents and a second-opinion model with its shell disabled. The principle is old. The labor is new.
What the machine actually looks like
Before any code exists, the spec gets cross-examined. My spec skill — one of the scripted workflows in my agent setup — spawns a product-owner reviewer that attacks the spec for missing requirements, unmeasurable success criteria, and scope that drifted. Blockers go back to me — not silently fixed, shown to me — until the spec survives review. I’ve killed more bad features at this stage than at any other. A feature that can’t survive a written spec was never going to survive contact with an agent.
Then the plan gets reviewed in parallel by three personas — a product owner, a software architect, and a senior engineer — each reading the plan against the spec and a written constitution of hard constraints for the repo. Each returns approved or a list of issues, and each issue gets an apply/skip/adjust decision from me. Three lenses, one decision-maker.
Then the task list gets audited for executability. File paths checked against the actual repo structure, dependency ordering verified, test coverage per module, and — because I stack PRs — each PR boundary checked to be independently mergeable. The cheapest time to catch “this plan can’t be executed” is before execution starts.
Implementation runs in fresh contexts with per-task review. Each task goes to a fresh implementer subagent — no accumulated session sludge — and each finished task goes to a separate reviewer subagent that checks it against the spec. Up to five fix rounds per task, a fresh implementer after the third, and a whole-branch reviewer before anything merges. There’s an iron law underneath it: no production code without a failing test first, and no completion claim without fresh verification evidence — run the command, read the output, then talk to me.
The diff can also get a second opinion from a different model. When a change is risky enough to deserve it — or when every reviewer above happens to come from the same model family — the whole branch, committed, staged, and working-tree changes, can go to a sandboxed reasoning pass from a different vendor’s model with all shell access disabled. It can’t fix anything, only find things, and it reports in a strict priority order: bugs first, then regressions, then security, then quality, then missing tests. Different model family, no ability to touch the code, narrow job. That’s the anti-homework-grading circuit — a dial I turn up when the change deserves it, not a gate everything passes through.
And the human gate is real, not decorative. Every commit and every PR gets a confirmation from me. Reviews from outside reviewers get triaged — actionable, no-op, defer, informational — and each suggestion gets verified against the actual code, and against the spec, the plan, and the task list, before it’s acted on, because reviewer comments are not always correct. If a fix loop spins too long, it stops and escalates to me instead of iterating forever.
Where the pencil actually is now
My review surface is the same one from that keynote recap: Neovim and Lazygit — which is still the funny part. A keybinding opens the “PR delta” — the diff between this branch and its merge base — in diffview, so reviewing a worktree means pressing one chord. Switching git worktrees auto-opens that same delta. Hunks, blame, and file history are keystrokes away, and PR review threads live in the editor too, so I can leave comments on a diff without leaving Neovim. Lazygit I keep intentionally plain — staging and committing, nothing else. The sophistication lives in the review path, not the commit path.
But the editor is the last mile, not the system. The system is: nothing reaches my editor until it has already survived a spec review, a three-lens plan review, a task audit, per-task implementation review, a whole-branch review, a TDD gate, and a human confirmation — plus a cross-model second opinion when the change deserves one. And nothing is called shipped until a post-merge pass compares the code against the original spec and a product-owner lens classifies every remaining gap as blocking, deferred, or out of scope.
Merge ≠ deployed. CI green ≠ proven. Built ≠ correct. And “the agent said it’s done” ≠ any of those things.
When code is cheap, the bottleneck moves to verification and judgment: is it right, and does it deserve to exist? That second question is the one the machine can’t answer. It can tell me whether the code is correct. Whether the feature deserved to be built at all is a judgment call, and it’s the one gate that never leaves my desk. Pencils down is only scary if you haven’t answered the follow-up question — who reviews, against what bar, and what happens when the review fails?
DHH’s keynote made pencils down respectable. Respectable isn’t the same as safe. The agent writing my code was never the risk. The risk is the gap between “done” and “proven” — and the pencil didn’t disappear. It moved, into that gap. Make sure it landed somewhere with teeth.