Keep the Mechanism. Lose the AI Vampire.

Start with the respect. Yegge has been at the front of agentic coding, not commenting after the tools became safe to endorse. He treats agents as workers inside an operating system rather than autocomplete with a better press release. He has explored queues, roles, durable state, parallel execution, handoffs, and the coordination failures that appear only after one prompt stops looking like a workflow. That is real work.

He also speaks his truth, including the cost, obsession, failure, and weirdness. His AI Vampire warning gets something important exactly right: when implementation accelerates, human attention becomes the scarce input. He admits he is an unrepresentative outlier, warns employers not to turn leverage into extraction, and argues for a shorter workday. We agree. A factory should return human time, not replace typing with permanent supervision.

Gunner agrees with the central mechanism too: the model is not the factory. Controls, state, routing, verification, and recovery make delivery repeatable. That is why the recent prophecy deserves resistance. Useful machinery keeps getting wrapped in metaphysics. A personal operating extreme becomes everybody's future. A state store becomes identity. Keep the engineering. Lose the séance.

He may have gone full AI Vampire from spending too much time with agents. That is satire, to be painfully clear, not a diagnosis. But the essays increasingly ask us to accept the emotional frame before the operating argument has closed. We're starting to wonder if Steve's wife is actually an agent. Again: joke. The substantive problem is that proximity to a system is being offered as evidence that the system has the inner life the metaphor assigns to it.

He always reminded us, physically, of Andy Serkis. Maybe he's turned into Gollum. That is also a deliberately ridiculous joke. The precious object here is not a ring. It is a totalizing story in which token accounts become destiny, external files become selves, and one builder's consuming practice becomes an evolutionary stage the rest of us will enter.

We do not need to mock the experiments to reject that leap. Agents can be operationally persistent without being persons. A process can reload goals, history, constraints, and pending work from durable storage and continue usefully. Call that continuity if you want. But the engineering claim is enough: external state improves recovery and coordination. Anthropomorphizing it as memory and identity adds heat without adding a control you can test.

The tension between Gas Town and Wheelhouse exposes the problem. One argument points toward reusable primitives for dispatch, work tracking, context recovery, and multi-agent coordination. Good. Reusable machinery is how an operating model compounds. The other celebrates dense personal configuration, named roles, local rituals, and a system shaped around one operator's habits. Also potentially useful. But that is not the same claim.

If the kernel travels only after every shop recreates the author's worldview, the reusable part is smaller than advertised. A factory needs a narrow kernel with explicit interfaces and replaceable policy. The rules, context, permissions, tests, and release semantics should be bespoke. The governance kernel should not be.

This is not a semantic objection. It decides what organizations can govern. Reusable routing, state transitions, permissions, evidence formats, and failure recovery can be tested mechanically. Personas and mythology cannot. The first group belongs in the factory. The second may help one operator think, but it should remain optional decoration rather than architecture disguised as fate.

Another contradiction sits at the exit. Human code review is described as too expensive for agent-scale output. We agree: forcing a person to inspect every generated line moves the bottleneck and preserves a ritual after its economics collapse. Review should become enforced standards, independent tests, risk-based escalation, and human judgment at consequential boundaries.

But then every exit supposedly deserves a human-requested, human-read handoff. That recreates the queue in prose. If a person must request and consume a summary before each unit can leave, the system did not remove mandatory review. It changed the artifact from a diff to a narrative, often written by the same machinery whose work is in question. Handoffs should be durable and inspectable, yes. Human attention should be pulled by risk, ambiguity, failure, or decision rights—not sprayed across every successful exit as ceremonial reading.

The attack on continuous integration and delivery has the same overreach. Pipelines can become serial choke points when agent throughput rises. That does not make integration, versioned change, or deployment control obsolete. The proposed world still leans on Git and Beads. The bottleneck is not durable state or gates. It is badly designed serialization. Partition work, parallelize proof, and reserve global gates for global consequences.

Yegge's extreme personal token-account economics are fascinating evidence about one frontier operator. They are not a universal forecast. Most businesses do not win by maximizing tokens consumed. They win by turning a decided outcome into reliable software at an acceptable cost, then proving it survives contact with customers.

The unit that matters is not tokens. It is accepted work with consequences attached. More agents can increase attempts while lowering the share that survives verification. More context can preserve old mistakes. More handoffs can create an expensive literature department. The factory must measure what reaches production, what comes back, why it failed, and whether the same failure becomes impossible next time. Token spend is an input bill, not a theory of history.

Our position is less romantic and more aggressive. Agent-run factories will replace repeatable software work. Human judgment moves to destinations, standards, risk, and acceptance. Organizations that encode those judgments into enforceable machinery will outproduce those that keep people in every loop. None of that requires agents to be souls, token whales to be prophets, or one personal environment to become everybody's home.

Take the mechanisms: durable external state, explicit work queues, parallel agents, narrow handoffs, recoverable execution, and proof outside the builder's chosen conditions. Reject the prophecy and the metaphysics. The future of software does not need a vampire story. It needs factories whose claims still hold after the smoke clears.