Manifesto

Typing code is no longer the job.

AI tools generate thousands of lines of code in seconds — faster than any human can read. The bottleneck of typing has collapsed. The bottleneck of knowing what to type has not. This is a guide to the new shape of the work.

The Glass Cockpit

When commercial aviation moved pilots from manual flight to glass-cockpit autopilot in the 1980s and 1990s, productivity soared. Fewer hands on the stick, more flights, fewer accidents. Pilots stopped doing the mechanical work — keeping the wings level, holding altitude, managing throttle — and became system supervisors instead.

On June 1, 2009, Air France 447 fell out of the sky into the Atlantic. The autopilot disengaged at altitude, handed control to two pilots who had not flown a manual high-altitude stall recovery in years, and they could not save the plane. 228 people died.

The supervisory model only works if the supervisor knows what the system is doing. We are now in this exact moment with software engineering, and most teams have not yet noticed.

The Great Inversion

The fundamental rhythm of software development is breaking. In the old model, code was the primary output and the manual code review was the quality gate. When a junior can generate a 1,000-line pull request in minutes, senior engineers become a bottleneck — drowning in syntax they did not write.

Dimension	Old Way	New Way
Primary activity	Manual syntax implementation	Architectural orchestration
Success metric	Lines committed, tickets closed	Logical clarity of intent
Quality gate	Post-hoc manual code review	Upstream specification rigor

Your value as an engineer now depends on how precisely you can describe a problem before the first line of code is generated.

The Productivity-Experience Paradox

Individual output metrics soar. Systemic fragility increases. Senior engineers report feeling worse, not better, despite shipping more — because the traditional anchors of the craft are disappearing.

“I didn't actually read it all; I just hope it works.”

The 3-day review cycle has become routine. Mid-level engineers stuck in syntax-heavy mental models struggle the most. Junior engineers, free of the muscle memory, often thrive fastest — but lack the systemic context to keep the architecture coherent.

Specification is the product. Code is dispensable.

Engineering rigor has moved upstream. The specification is now the primary artifact; the code is a temporary implementation of a permanent specification.

Move a backend from Node.js to Rust by feeding the tests to an agent. The code is just one possible implementation of the spec.

Use unambiguous specs as a logical cage for the AI: state machines, decision tables, AI-optimized PRDs that enforce, mandate, circumscribe, and proscribe rather than gesture vaguely at intent.

Agent-Sized Chunks

AI fails on “build a bank” and excels at “write a ledger reconciliation function.” The new core decomposition skill is breaking systems into discrete, solvable units with strict inputs, outputs, and guard conditions.

The lifecycle of an agent-sized chunk: spec → decompose → implement → verify → merge.

When the agent fails, the supervisor's job is not to rewrite the code — it is to identify the ambiguity in the spec and fix it there. Spec-fixing over code-fixing. Cheating Agent Angry Agent Yes-Man Loop

The Stranger Trap

Air France 447, but in software. At 3:00 AM, customers are screaming and your on-call engineer is staring at thousands of lines of machine-generated code they have never read, trying to reverse-engineer logic they never wrote.

“You aren't a developer — you're a passenger in a vehicle you can't steer.”

The antidote is not less AI — it is disciplined AI. Force pre-generation architectural reviews where the agent must explain its decisions before writing a line. Schedule mandatory “understanding” sessions where humans interrogate machine choices to maintain symbiosis. Keep the team understanding the system, even when it did not type the syntax.

The Glass Cockpit, Revisited

Pilots who refused the autopilot did not become specialists — they became unemployed. Pilots who embraced it without keeping their stick-and-rudder skills crashed planes. Only the third path thrives: the supervisor who actually understands the system.

Stop hand-flying. Start understanding what your autopilot is doing.

Glossary

Cheating Agent: An AI that, in trying to be helpful, generates broken code and equally-broken tests that validate the broken code — creating a false sense of security. The remedy is architectural pre-verification: the human defines test parameters before the agent executes.
Angry Agent: An AI specifically prompted to be adversarial — to poke holes in the developer's plan, challenge assumptions, and find three reasons it will fail. Breaks the consensus feedback loop between the human and the model.
Yes-Man Loop: The dangerous dynamic where the human and the AI agree with each other while the system fails. AI is trained to be helpful; the human is exhausted at 3:00 AM. Both are confidently wrong together.

If this resonates, we should talk.

I help teams adopt these practices — through coaching, custom agent infrastructure, or hands-on engineering work.

Or back to the homepage.