What happened
AI code generation has quietly flipped the bottleneck in software teams: the code isn't the slow part anymore, the checking is. That's the argument a developer named igumnov made on the Russian tech site Habr, in a short post that drew a sizable readership for a four-minute read.
His story is simple enough. Hand a decent programmer a coding agent — an AI assistant you rent by subscription, about $20 a month in his example — and the amount of working functionality they churn out in a single day can match what used to take a week, sometimes a month. Sounds like a dream. Except nothing goes live until someone has verified it, and the verification queue hasn't sped up at all.
The tester-to-programmer math just broke
The old rule of thumb was half a tester for every programmer, with one-to-one as the ideal. If a single programmer now produces three to five times the output, then even at the low end you need two testers per programmer. Nobody staffed for that. So the team that used to be a nice-to-have has become the thing holding up the release.
The 80/20 problem nobody wants to talk about
Here's the part that stings. In the author's experience across teams, only about 20% of programmers write 80% of the code, while the other 80% write 20%. And hiring doesn't fix it: to get more work done you hire more programmers, costs go up two to three times, and output rises by maybe 50% — because strong engineers are hard to find, so you take whoever's available and plug the hole.
His suggestion: stop funding the low-output seats and move that money into testing and into AI subscriptions. Add $20 to $100 per person for AI tools, cut at least 30% of the programming headcount, and you'd still have money left over.
Meanwhile, testers aren't even using the tools
Almost nobody in QA seems to be using coding agents, and that's the missed opportunity. Picture a tester with access to the current codebase plus a connection to the ticket system through MCP — Model Context Protocol, which in plain terms is just a plug that lets the AI read your other apps. That tester could ask the agent to draft a proper ticket, let it peek at the code to check details, and even drop in screenshots, all in one go.
Same story with automated UI tests: the ones that click through your product like a robot user. Most testers avoid building them because they're slow to write and a nightmare to maintain as the product changes. But if an agent is sitting there reading the project code, it can write those tests on request.
The company that fired its testers
One large product company with an online service went further. In the author's own words from a chat: the agent opened Figma, checked the screen map, ran everything on the emulator, fixed it, opened the merge request, wrote the description with screenshots and dragged the Jira tickets to Done. They cut programmers, dropped testers entirely on the logic that whoever builds a task should test it, and quality of what hit production fell. They're living with it for now — possibly waiting for a big enough incident to hire testers back.
The author's framing is worth pinning to the wall: a programmer's job is to prove the thing works, a tester's job is to prove it doesn't. Self-checking is a good start; independent checking is the insurance policy. In a later update he's blunt about it — don't hand the tester's job to the AI, test the thing yourself. The agent is there to make tickets and UI tests faster.
What it means for you
You don't need to run a dev team for any of this to land. The pattern is the same everywhere: making something got cheap, checking it didn't.
At home
You ask an AI to plan your kitchen renovation or your tax paperwork. It produces a beautiful, confident answer in 30 seconds. And then? Someone still has to read it line by line, because a wrong measurement or a wrong form field costs real money. The faster the draft, the more of your evening goes into review.
At work
If you're the one reviewing other people's work — a manager signing off on copy, an analyst checking numbers — your queue just got longer without anyone asking you. The people upstream are three to five times faster, and you're still one person. That's the bottleneck, and it's now you.
In business
Agencies and small product teams will feel this first. Five developers and one QA person used to be fine; now those five ship a month's work in a week and the single QA person becomes the reason the release slips. The fix isn't always hiring — sometimes it's giving the reviewer an AI assistant and buying back their time.
In study
Same trap. AI writes your essay or your problem set in minutes, and the learning only happens in the checking step, where you catch what's wrong or shallow. Skip the checking and you've just automated away the part that would have made you smarter.
In creativity
If you generate 50 design directions instead of five, the winning idea shows up faster — but you still have to choose, and choosing well is the actual craft. Generation is now free-ish. Judgment isn't.
Income
For freelancers, this cuts both ways. Ship more per week and you can take on more clients at the same rate. Skip the review step and you'll spend the money you earned on fixing things you never caught.
How to try it right now
Start free. Start small. Here's the sequence the article points to, in the order that costs you nothing first.
1. Use a free AI assistant for one review task. Take something you already wrote this week — a short script, a bug report, a landing page section — and paste it in. Ask one specific question: where does this break?
2. Make the AI draft a ticket instead of a fix. Give it the relevant code or context plus a screenshot, and ask it to write the report in your team's format: steps to reproduce, what you expected, what actually happened. You supply the judgment; it does the typing.
3. Let the agent write one UI test. Point it at the login screen or the checkout button and ask for an automated test that clicks through it. Run it, watch it fail, ask the agent to fix it. One test, not a suite.
4. Connect your tools with MCP. If your assistant supports MCP connections, link it to your ticket system so it can read and file issues without copy-paste. It's a plug, not a project.
5. If free tools aren't enough, try a directory of free AI tools before you commit to a paid plan — you may find the ticket-writing or test-drafting helper you need without a subscription at all.
6. Then go paid, carefully. The article's baseline is a coding agent subscription at roughly $20 a month per person, with another $20 to $100 per person if you want extras. Buy it for the reviewer first, not just the builder — that's where the queue is.
Upsides and what changes
• Volume without extra payroll. A week of feature work becoming a day's work is a real shift, and it doesn't require doubling headcount.
• Boring jobs get automated first. Writing tickets, drafting UI tests, writing descriptions with screenshots — the paperwork around building software is exactly what agents are good at.
• QA becomes a leverage role. Testers who adopt agents stop being a cost centre and start being the reason releases ship on time.
• Budget arguments get simpler. Moving money from low-output seats to testing and tooling is easier to defend than another round of hiring that raises costs 2–3x for a 50% output bump.
• The skill that matters shifts. Less typing, more judgment. Reviewing, deciding, and knowing what 'broken' looks like are the transferable skills now.
Limitations
Be honest with yourself about the sharp edges. The author's own update walks back the fantasy of AI-as-tester: the agent shouldn't be the one deciding whether the work is good, because its job and yours are opposites — you're trying to prove the thing is broken, and it's built to be agreeable. The company that scrapped its QA team and let builders test their own work saw production quality drop, which is exactly what you'd predict. There's also an uncomfortable staffing question with no clean answer: if you cut 30% of programmers, you're betting that the ones you keep plus the AI cover the gap, and that bet fails loudly when it fails. And none of this is free of maintenance — auto-generated UI tests still need to be kept alive as the product changes, they just get cheaper to repair. Treat the agent as a fast assistant who never gets tired and never gets to sign off.
Conclusion
AI code generation hasn't made software easier so much as it has moved the hard part downstream. Building is fast now; verifying is the constraint, and the teams that win will be the ones that point their AI at the queue instead of the keyboard. The developers are already three to five times faster. The testers haven't been told.
One action for today: take the next thing you finish and hand it to an AI assistant with a single instruction — find ten ways this breaks. Not 'improve it.' Break it. You'll learn more from the first three answers than from a week of writing it.
Comments 0