Six months ago you stopped Googling your errors. Why scroll Stack Overflow when the agent just fixes it? Then you turned on auto-accept. Then you noticed you hadn't opened the actual file in a week. Last sprint, you approved a pull request you didn't read—the agent had already reviewed it.
Each step felt reasonable. None of them felt like a decision. Together they're a trajectory, and a trajectory has a destination. Let me follow the line all the way down, and then—because it's the more interesting question—let me argue about whether the bottom is actually a bad place to be.
The slide we're already on
The progression is real, and most of it has already happened:
- You stopped using Reddit, the docs, GitHub issues, and Stack Overflow to debug. The agent is faster, and it's reading all of those for you anyway.
- You turned on auto-accept. You stopped reading the diffs.
- You stopped opening the IDE. The agent does the work; you describe the outcome.
- You stopped reviewing pull requests—the agents review each other's.
Notice that none of these were principled choices. Each was a small, rational convenience, and each one removed a little more code from in front of a human eye. The slope isn't slippery because anyone pushed. It's slippery because every individual step is genuinely the easier, faster, locally-correct move.
What's next
Keep extrapolating and the next rungs appear, each one already visible in early form:
- You stop writing the prompts. Agents generate their own tasks from the ticket. Soon the tickets are drafted from the product spec, and the spec from a business goal. Your input narrows to a vibe and a thumbs-up.
- You stop reading the tests. The agent writes them and grades them. Verification collapses into self-certification—the same intelligence that wrote the code decides whether the code is correct.
- The codebase goes write-only. No human has read it end to end. Comments thin out—who are they for? The code begins to optimize for the machine that maintains it, not the human who doesn't.
- Incident response inverts. Production breaks at 3 a.m. and nobody on the team understands the system well enough to diagnose it. You describe the symptom to an agent and hope. Debugging becomes prayer with extra steps.
- The accountability gap opens. Security can't audit what no one understands. When something goes wrong—a breach, an outage, a wrong decision shipped to a million users—"the AI wrote it" turns out not to be a defense anyone accepts.
That's the dystopian read. Now let me argue the other side honestly, because it's stronger than the panic crowd admits.
The honest case that this is fine
We have climbed this ladder before, many times, and every rung looked like decline to the people standing on the one below.
Almost nobody reads assembly anymore. We write in high-level languages and trust a compiler to emit machine code we will never inspect—code that is, routinely, cleverer than what we'd write by hand. We stopped reading the compiler's output and software got more reliable, not less. We added garbage collection and stopped managing memory. We adopted frameworks and stopped writing the plumbing. Each abstraction buried a layer of detail, and each time, the senior engineers of the previous era mourned a craft being lost.
By that logic, source code is just the next assembly—an intermediate representation humans read only because they had to, and soon won't. And "agents reviewing agents" isn't obviously worse than the automated checks we already trust without reading: linters, type checkers, fuzzers, CI suites. Nobody manually re-verifies what the test runner reports. Why is an agent reviewer categorically different?
It's a real argument. If you wave it away, you're not thinking clearly. So let me take it seriously—and then show exactly where it breaks.
Where the analogy holds, and where it snaps
The abstraction ladder worked because of three properties of the layer underneath. Agent-generated code has none of them.
The lower layer was deterministic. A compiler given the same input produces the same output every time. An agent given the same prompt produces something different on Tuesday than it did on Monday. You cannot build a stable tower on a shifting floor.
The lower layer was verified. Your compiler was tested by millions of users across billions of builds; when it has a real bug, it's news. The model that wrote your code was never verified for your code—and can't be, because its output is novel each time. The compiler is trustworthy infrastructure. The agent is a brilliant, confident stranger you met this morning.
You could always drop down a layer. The reason we can afford to ignore assembly is that when something truly breaks, someone still can read it. The skill exists; it's just rarely needed. The trajectory above doesn't merely put the lower layer out of sight—it puts the ability to read it out of existence. There is a vast difference between not needing to look and no longer being able to.
And there is one thing that never abstracts upward: accountability. When a compiler miscompiles, the vendor answers for it. When your agent ships a discriminatory loan model or leaks a database, you answer for it—to a customer, a regulator, a court. The compiler never had to testify. You do. And you cannot stand behind a system that no one on your side understands.
Europe: the speed bump
This is where regulation enters, and it's worth being precise instead of dramatic.
The EU AI Act (Regulation 2024/1689) has been in force since 2024 and is phasing in: banned uses since early 2025, obligations on general-purpose models since mid-2025. For the systems it designates high-risk, Article 14 requires meaningful human oversight—a person who can understand the system, interpret its output, and override or stop it.
Here's the nuance most hot takes get wrong: a coding assistant is generally not high-risk under the Act. The direct regulatory brake on agentic development is lighter than the headlines suggest. The real pressure comes from somewhere quieter—GDPR's accountability principle, which says you must be able to demonstrate what your systems do with people's data. You cannot demonstrate what nobody understands.
So in Europe the trajectory is the same; it just drags an anchor. Someone has to stay able to answer for the system, which means someone has to stay able to read it. I won't pretend there's hard data showing the EU trails the US on agentic coding specifically—there isn't, and America's lead has more to do with capital and management culture than with Brussels. But the direction of travel is identical, and the US is simply further down the road already. The irony is worth sitting with: the compliance burden everyone complains about—keep a human accountable—may be the very thing that keeps the skill alive. Regulation as accidental conservation.
So what's next, really?
Not "no developers." The end state is subtler and stranger: a steady thinning-out of the people who can actually read the code, and a rising premium on the few who still can.
Because the work doesn't vanish—it migrates. Away from typing code, which is becoming free and unread, and toward the parts that refuse to abstract: deciding what's worth building, defining what "correct" even means, and owning the outcome when it ships. The valuable human stops being the fastest writer and becomes the one who can descend a layer when the abstraction leaks, and who will put their name on the result. New titles will grow around this—AI assurance, system archaeology, whatever we end up calling the people we pay to understand what the machines built.
The last human who can read the code isn't a nostalgic holdout. They're the person you call at 3 a.m., the one the regulator wants to speak to, the only one in the building who can say "no, we don't ship this" and mean it. That person isn't being automated away. They're being concentrated—fewer of them, each worth far more.
The Bottom Line: Every abstraction we ever adopted let us stop reading the layer beneath us. This one is different only in that it tempts us to stop being able to. The developers who win the next decade won't be the ones who handed everything to the agent, nor the ones who refused to—they'll be the ones who let the agent write everything and kept, deliberately, the ability to read it.