Mistral stood in front of lawmakers recently and said the quiet part out loud. Their engineers got 10x more productive with AI. And their teams? Basically the same output as before. Let that sit for a second. One person triples, quadruples, 10x’s their personal throughput, and the org ships at roughly the same pace it did last year. That math should not work. A 10x boost on one input should move the needle on the output. It doesn’t. And once you understand why, you realize we’ve been building our teams completely wrong for the AI era.
So why doesn’t it work? I dug into this because it genuinely bothered me, and the answer is almost stupidly simple once you see it. The bottleneck moved. It didn’t disappear. It just slid down the assembly line and parked itself right on top of code review.
Here’s the brutal asymmetry nobody wants to say at the all-hands. You can generate 1,500 lines of code per minute with a good model. You can review maybe 500 lines per hour if you actually care about what you’re approving. Do that division. Generation got 100x faster. Review didn’t get faster at all. It got slower, because now the human reviewing isn’t reviewing their teammate’s careful work, they’re reviewing a firehose of machine output that looks confident and correct and is occasionally neither. The 10x engineer isn’t a 10x engineer. They’re a 10x generator feeding a 1x review pipeline. The factory floor is flooded with parts and there’s still one inspector squinting at every single one.
This is the part that should scare you more than the productivity numbers. We didn’t just fail to gain team output. We may have quietly poisoned the thing that made the job worth doing. Think about what an engineer actually loves. It’s not typing. It’s the puzzle. It’s the moment the architecture clicks and you solve a problem that was kicking your ass for two days. AI took the puzzle and handed it to a machine, and now your senior engineer sits in the passenger seat reading someone else’s driving. Except that someone else isn’t a person. It’s a model that doesn’t get tired, doesn’t explain its reasoning, and doesn’t care if you approve. You went from author to inspector. That’s a worse job. And we wonder why people are crashing out.
So the real question isn’t „how do we make individuals faster.“ We already did that. The question is: how does an organization actually capture that individual 10x when the team gate is review? And I think there are only a few honest answers.
Option one. You give up on teams entirely and you build everything around single contributors. Ten people doing parallel solo work, no shared review, no coordination tax. Option two, the spicier one. You accept that a ten person team is now one person with a fleet of agents, and you fire the other nine. The rise of the single-person business where that single person is just an AI orchestrator. I don’t think either of these is right. But I don’t think they’re crazy either. The truth lives somewhere in the messy middle.
I read a take recently that actually proposed a concrete shape for this, and it stuck with me. The idea was to shrink the pizza team. You know the rule, five to eight people, small enough to feed with one pizza. The proposal cut that to three. One architect. Two executors. And here’s the twist that makes it interesting: the two executors don’t write code anymore. They’re AI managers. They orchestrate the agents, they own the output end to end, they take full responsibility for what the machine produces and whether it’s actually good. The architect sets the guardrails. They design the system, they write the docs, they build the pipelines that verify quality is still holding. Three people. The work of ten.
And look, I think this is genuinely close to right for where we are today. Because look at what it does to the review problem. It doesn’t solve it. It relocates it. You stop pushing review out to a team of peers and you push it down into the individual who generated the change. The person who orchestrated the agent owns the correctness of the agent’s work. No more 10-comment war over a 10-line PR while a 1,000-line PR sails through because everyone’s too tired to read it. The review collapses into the contributor. And suddenly the 10x actually shows up at the org level, because the review gate isn’t a separate team standing in the way anymore.
But here’s the part nobody wants to hear. We just deleted one of the most valuable things software teams ever had, and we’re acting like it’s free.
Team review was never really about catching typos. The harshest reality a lot of you haven’t internalized is that review is where you catch the thing the author can’t see. The logical flaw. The change over here that quietly breaks something three modules away. And in a real codebase, not a greenfield demo, a legacy thing that grew like a tumor over eight years of business pivots, the only person who knows that touching the billing service breaks the export job is the human who’s been knee-deep in that swamp for three years. The AI doesn’t know that. The contributor who orchestrated the change doesn’t know that. Only the graybeard who got burned by it in 2021 knows that. Cut the review team and you cut the institutional memory that lives in their scar tissue.
So maybe the real prerequisite isn’t smaller teams. Maybe it’s killing the tech debt first. You can’t safely hand review off to the individual when one change ripples across six unrelated places, because nobody can hold that blast radius in their head, not even the model. The spaghetti is what makes review a team sport. Untangle the spaghetti and review stops needing a committee.
Or here’s the trade I actually believe in. You simplify what review even means. Stop reviewing the implementation. Review the interface. What goes in, what comes out, what’s the contract. You stop caring how the function does its job and you start caring obsessively about its boundaries. The discovery of logical flaws inside the box? You hand that off too, to AI and to the contributor who proposed the change. That’s their job now. You’re not abdicating quality, you’re moving the human attention to where humans are still irreplaceable. The seams. The contracts. The places where systems meet. That’s a good trade. That’s how the org actually banks the 10x instead of watching it evaporate at the review gate.
But, and I cannot say this loudly enough, none of this works without the guardrails. And this is where I think most teams are going to faceplant. You don’t get to delete team review and keep your 2019 deployment process. That’s not a productivity win, that’s a loaded gun.
If a human isn’t reading every line, then the line had better get caught somewhere else. Testing isn’t optional anymore, it’s the load-bearing wall. And the beautiful part is AI made testing nearly free. The engineer stops writing tests and starts defining test cases, the edge cases, the nasty inputs, the things that actually matter, and the model writes the implementation. The engineer reviews whether the coverage is honest. That’s a 10x you can actually trust because it’s verifiable.
And then deployment. We have to stop shipping the new version to the entire user base and praying. That era is over. Canary deployments. Cohort rollouts. Blue-green. A/B with feature gates. You roll out to 1% and you watch. You go incrementally because that’s how you discover the bug the missing review would have caught, except now you catch it in production with 99% of your users still safe instead of in a code comment that nobody wrote. And rollouts like that are worthless without eyes, so monitoring and alerting just went from „nice to have“ to „the thing standing between you and a very bad Tuesday.“ It has never mattered more than right now.
So here’s where I land. The 10x is real. The team gain is fake, for now, and it’s fake because we tried to bolt a firehose onto a 2015 process and acted surprised when the pipe burst. You don’t fix that by hiring faster reviewers or by firing nine people and crossing your fingers. You fix the lifecycle first. You harden testing, you harden deployment, you build monitoring that actually tells you when the machine lied. Then, and only then, do you get to cut the team, split it up, push responsibility down into individuals, and finally cash in the 10x that’s been sitting there mocking you.
The order matters. Process first, headcount second. Everyone’s trying to do it backwards because the headcount cut shows up on the spreadsheet faster. Don’t be that company. Peace, nerds.