Most AI debates pretend you must either let agents write everything or refuse tools entirely. Antonin Carette’s essay “AI stance is not binary”, published September 30, 2026, rejects that frame. He asks a different question: which legs of the race should humans run, and which should machines run?
The piece resurfaced on Hacker News on November 8, 2026. The thread had no substantive comments at fetch time, but the essay is a useful workflow explainer for teams drowning in binary takes.
TL;DR — three stances in one table
| Stance | Carette’s metaphor | Risk |
|---|---|---|
| Full delegation | Coach from the sofa; stop running | Lose craft intuition; fat-fingered instructions |
| Parallel mirroring | Run the same race beside ten robots | Burnout; expensive duplicate work |
| Relay collaboration | Different legs, baton handoffs | Harder to design; needs clear verification |
The sofa coach: when the human stops practicing
Carette’s first failure mode is pure supervision. The human stops typing, only shouts corrections, and slowly loses the felt sense of the codebase. Instructions get longer; the robot misinterprets nuance; the human’s ability to spot wrong architecture fades.
That maps directly to what explainx.ai has called the verification tax. When generators make keystrokes cheap, judgment work moves to review. If reviewers never touch hard problems, they lose the calibration to catch subtle bugs—exactly what Kristian Polso argued when he listed maintainability and accountability as professional dealbreakers.
Sofa-coaching also shows up in incident postmortems about “human slop”: AI surfaces decade-old vulnerabilities because nobody maintained mental models of legacy modules—see human slop and legacy code.
Running beside ten robots: parallel mirroring
The second stance sounds responsible—stay in the loop—but Carette warns it does not scale. If you run the same course as the agent, supervising every line while still doing the work, you pay both costs. Ten parallel agents mean ten parallel reviews.
That is the pattern behind some AI-first engineering headlines. Bloomberg reporting on Epic Games telling developers to go AI-first is not identical to Carette’s ten-robot image, but the throughput obsession rhymes: more generated surface area without redesigning who owns design and proof.
Proton AG’s Bart Butler manifesto makes a related point from another angle: if code is cheap, review queues become the bottleneck unless you change team shape.
An issue card linked to a patch, illustrating scoped agent legs with human verification
The relay race: change the sport
Carette’s third path redefines the task. Humans keep:
- Problem framing and trade-offs
- Architecture and threat modeling
- Hardest debugging when reality disagrees with the plan
- Final review and release accountability
Agents take well-scoped legs:
- Exploring API alternatives
- Drafting repetitive code and tests
- Searching docs while the human works elsewhere
- Implementing components with crisp acceptance criteria
This is not “use AI sometimes.” It is workflow design. Carette explicitly rejects internet debates that sell obsolescence or purity.
Hashimoto’s gradual path
Carette highlights Michael Hashimoto’s write-up on reproducing his own work with agents—learning where they save time, where they waste it, and building verification into the habit. That is the empirical middle Carette wants instead of manifestos.
Teams can copy the method without copying tools:
- Replay a recent feature you shipped solo.
- Time agent-assisted vs. manual legs separately.
- Log rework after merge.
- Promote only legs with net positive rework cost.
DHH and the “wrong sport” jab
Carette cites reporting that David Heinemeier Hansson told Rails World that 37signals treats AI agents as the default code path, with hand-written code exceptional. Carette’s critique is not personal—it is metric-based: if you optimize characters per second, you pick a sprint when engineering is a relay where handoff quality matters.
We do not have primary video transcripts in this post; treat vendor-stage quotes as reported, not verified policy manuals. The useful builder read is: default-to-agent orgs still need proof-driven review or they drown in diff noise.
How relay maps to 2026 agent stacks
Modern agents blur lines because they plan, not only autocomplete. Carette’s relay still works if you define batons:
| Leg type | Example baton | Verification |
|---|---|---|
| Research | “List three auth patterns with citations” | Human picks one |
| Scaffold | “Generate CRUD + tests for schema v3” | Human reads schema + threat model |
| Refactor | “Extract service module; no behavior change” | CI + mutation tests |
| Exploit hunt | Do not delegate without sandbox | Human-led security review |
Sean Goedecke’s argument complements Carette: models stumble on symbolic design traps. Put agents on legs with executable oracles (tests, types, proofs), not ambiguous architecture.
When agents touch production systems, gate tool use—teams working on autonomous agents often adopt guardrails such as AgentBeam so delegated legs cannot execute dangerous actions without policy checks.
What Carette does not solve
The essay admits nobody he knows handles collaboration “correctly.” It does not prescribe stack choices, model vendors, or metrics. It also is not news—it is philosophy with September 2026 authorship.
Hacker News had zero comments when we checked; there is no developer benchmark thread to quote. Value is framing, not leaked numbers.
Relay legs that work in production codebases
Carette does not name ticket templates, but teams can translate the metaphor into concrete legs:
| Leg | Human keeps | Agent may draft | Definition of done |
|---|---|---|---|
| API migration | Schema ownership, rollback plan | Codemods for call sites | CI green + canary metrics flat |
| Test gap fill | Risk ranking of modules | Unit tests for pure functions | Mutation score ≥ team baseline |
| Docs drift | Architectural truth | Sync public README to types | Tech writer or EM sign-off |
| Incident patch | Root-cause narrative | Hotfix branch from runbook | Postmortem action item closed |
Each row is a baton: the agent never owns the rollback decision; the human never retypes boilerplate tests unless the agent’s draft fails property checks.
This is how Microsoft’s PDD Kit narrative reframes review—humans bless intent, not every token. Relay design makes that blessing cheap enough to ship.
Anti-patterns Carette warns about in the wild
Resume-driven “100% AI commits.” Vanity metrics encourage sofa coaching with extra steps. Track defect escape rate instead.
Ten-agent hackathons without owners. Parallel mirroring feels fast for a demo, then leaves human slop in shared modules.
Binary purity tests in hiring. Refusing all assistance and refusing all judgment both filter out engineers who could run a relay.
Skipping design because “the model will figure it out.” Sean Goedecke’s piece is the technical echo of Carette’s “wrong sport” line—agents excel at local patches, not global invariants.
Where vendor roadmaps push you back to binary
Model vendors market autonomous engineers and background coders—the same cultural pressure Meta’s canceled Project OT coverage described when leadership tried to shrink pods around agents.
Carette’s essay is a counter-manifesto for individuals, not a guarantee your employer adopts relays. Staff engineers can still:
- Negotiate definition-of-done that requires human-owned design docs.
- Insist on pairing sessions for security modules even when agents draft.
- Publish team playbooks that name which directories are agent-writable.
Relay metrics worth logging weekly
- Rework minutes per merged agent PR — compare to human-only baseline from last quarter.
- Escapes to production tagged
agent-assistedversus not. - Time-to-first-review — parallel mirroring shows up as long open PRs with tiny commits.
- Contributor skill drift — are senior engineers still landing hard bugs, or only commenting?
Our verification tax surveys give industry anchors for items 1 and 3. Carette gives the cultural vocabulary to defend those metrics in staff meetings.
A relay checklist for your team
- Draw the race. List last sprint tasks; mark judgment intensity 1–5.
- Cut parallel mirroring. If you and an agent both edit the same module live, stop—split legs.
- Ban sofa mode on critical paths. Security, billing, and data deletion stay human-primary.
- Measure rework, not vanity throughput—use our verification tax article for survey anchors.
- Revisit monthly. Agent capabilities shift; legs that were unsafe in Q2 may be scoped in Q4.
Related reading
- The AI verification tax at work
- Kristian Polso on LLM dealbreakers in professional coding
- Epic’s reported AI-first engineering push
- Microsoft PDD Kit and reviewing intent, not every line
- Why LLMs stumble on system design
- Meta Project OT and right-sized engineering teams
Reading list beyond Carette
If you want primary voices he cites, start with Carette’s own page—then chase Hashimoto’s adoption article linked there, and treat Rails World reporting on DHH as one data point, not destiny. Revisit the essay quarterly; your relay map should change as models improve. On explainx.ai, pair this essay with 0rwx permission levels for a concrete RBAC layer on relay legs, and with should developers stop reviewing AI code? for the review debate Carette assumes but does not solve.
Bottom line: Carette’s essay is a usable metaphor—relay, not boycott, not surrender. The builders who win are not the loudest pro- or anti-AI camp; they redesign the sport so agents run legs you can verify, while humans keep the baton on judgment.