🚀 3.2.1. The winner produces the least ::: Atomic Scaling

Today, AI can generate code faster and more consistently than any human alive. For the first time, we're producing code faster than humans can reasonably read, understand, validate, and review it. That feels almost god-like.

Most teams interpret this as permission — or even an obligation — to produce more code. It's the opposite. When code becomes abundant, judgment becomes scarce. The winning AI-native engineering teams won't be the ones generating the most code. They'll be the ones shipping the least unnecessary code, verifying every change in minutes, and confidently owning their systems 24/7.

THREE IDEAS

I. Velocity shifted from weeks to days. So did the bottleneck.
​
​A single developer with an agent now opens 5–6+ pull requests a day — some in Silicon Valley brag 15. Work that used to be one. That's a 5–15× increase in perceived output. Review capacity, meanwhile, is flat. Faros AI's telemetry across 22,000 developers shows median time-in-review up 441%, with 31% of PRs now merging with no review at all.

Implementation speed has skyrocketed, the pipeline is choking, and the human "Looks Good To Me" (LGTM) has become the single biggest liability in the deployment cycle.

The standard reaction is to scale review to match the flood. Wrong question. The flood is the symptom. An abundance of code isn't an achievement — it's usually a sign nobody decided clearly enough what was worth building. Don't industrialize the cleanup. Turn off the tap.

II. Pachinko coding: agentic coding is a slot machine.
​
​There's a feeling that happens right after you hit Enter on a prompt, like in a casino. Every prompt is a pull of the slot-machine lever. The tokens stream, the cursor blinks, and for a few seconds you're suspended in pure anticipation — maybe this is the one-shot.

That anticipation is the drug; the output is secondary. Sometimes it nails the feature. Sometimes it takes ten tries. Sometimes it ships something subtly broken that passes the tests.

Random input can't produce reliable output. The data backs the metaphor: CodeRabbit's analysis of 470 PRs found AI-co-authored code carries ~1.7× more issues — logic and correctness errors up 75%, critical issues up ~40%. AI raises throughput and instability at the same time. Faster bugs are still bugs. Speed was never the constraint. It never is.

III. From Dev to Dev Ops to Judgement.
​
​The popular take is that the hero shifts from Dev to DevOps — the one who catches the AI's mess downstream. That's handing the trophy to the cleanup crew for a mess a better decision would have prevented.

Two real moves instead. First, make your deterministic safety nets the crown jewels: compilers, strict type checkers, linters, contract tests, CI/CD. Machines verifying machines — no tired human eyeballs required.

Second, and this is the cultural one: measure what you killed. The teams that win with AI aren't the ones with the most throughput. They're small cells of excellent people who own a thing end to end and have the taste to throw most of it away. Fewer. Better. Owned.

As the suckless philosophy puts it: "Ingenious ideas are simple. Ingenious software is simple. Simplicity is the heart of the Unix philosophy. The more code lines you have removed, the more progress you have made. As the number of lines of code in your software shrinks, the more skilled you have become and the less your software sucks."

TWO QUOTES:

I.

“The Pull Request is dead: code production is no longer our bottleneck." — Burak Dede, Engineering Lead at Wayfair (great post here)

II.

“Removed code is debugged code." — Jeff Sickel in the spirit of the suckless philosophy​
​

ONE ACTION FOR YOU:

This week, don't ask: "How much more — or faster — can we code?" Ask: "How can we better own our system's output in a moving environment, 24/7?"

Play to Win!

Ludovic Bodin

3x Entrepreneur, 2x Unicorn Investor, 1x IPO
Founder of BOBIC Generational Wealth
Author of Atomic Scaling