We're Shipping Faster While Understanding Less
AI Writes Most of Your Code Now. The Hard Part Is Still Yours.
Building an agent is easy … getting good search results into it is harder.
Traditional search APIs rank URLs for humans to click, not agents. Agents need the right tokens in its context window, and full pages bury them in noise you pay for.
Parallel rebuilt search for agents: send your objective in plain English, and it returns the most relevant excerpts.
Less noise in context means better reasoning and a smaller bill. It’s faster, cheaper, and more accurate than any other web grounding solution available, and it’s free up to 5,000 searches each month.
I’m shipping more code than at any point in my career. And I understand a smaller share of it than ever before.
If you use AI coding agents every day, I’d bet the same is true for you.
That sounds like a confession. I don’t see it that way. I see a job description changing in real time, and I think the developers who notice first will come out ahead.
Let me explain.
We’re All Shipping More Than Ever
AI agents do the bulk of the typing now.
The biggest tech companies say a huge share of their new code is AI-generated - at some of them, most of it. Some startups launch with codebases the founders barely typed a line of.
This is good news. I want to be clear on that.
You can now build in an afternoon what used to take a sprint. Ideas that would’ve died in your backlog get prototyped before lunch. More software exists because of this, and a lot of it is software nobody would’ve had time to build before.
To be precise: not every single task of software got faster. Some days the agent drags you down a rabbit hole, and typing it yourself would’ve won.
The explosion is in what gets shipped, and shipped volume is what changes the job.
But all that volume is doing something in the background.
The “Understanding” Difference Is Real
There’s a name going around for it: comprehension debt.
It’s in between the code sitting in your repo and the code you could actually explain.
It grows every time you accept a diff you only skimmed.
The speed is lopsided too. An agent produces an endpoint in a minute; a careful human review of the same code takes twenty. Review turned into a bottleneck, making it easy to skip.
The source code was never the real asset. The real asset is the model in your head - how the pieces fit and why they’re shaped the way they are. When AI writes the code, that model never forms unless you build it on purpose.
I feel this in my own work. The ratio has shifted: more code flowing through my projects, a smaller fraction living in my head.
The wider industry shows the same tension.
That tension has to resolve somewhere. It resolves in you, the reviewer.
Code Was Never the Hard Part
But here’s the thing: typing code was always the cheap layer of this job.
Think about how you spent your time before AI showed up. I spent most of my time reading code, learning the system, and figuring out what to change. The typing came last, and it was the easy part.
Engineering was always the other stuff:
What to build in the first place
How the components talk to each other
Where the data lives and how it’s shaped
AI didn’t remove any of this work. It stripped away the typing and left the engineering exposed.
One Caveat
AI reviewing AI code is probably where this is heading.
The tools are already showing up, agents that comment on your pull requests, flag bugs, explain diffs. And there’s a real logic to it: if AI writes the code faster than humans can review it, the review has to speed up too.
But it hasn’t been mass adopted yet, and I think the reason is simple: review is the one place where “pretty good” isn’t good enough. An AI that writes code that’s 90% right is a productivity tool. An AI that reviews code and is 90% right is a false sense of security. The whole point of review is catching the 10%.
So for now, the review still lands on you. That may change, probably will.
But today, you’re the last line of defense.
The Job Moved Up a Level
Zoom out and this stops looking like a loss.
A program was never really its text. It’s the understanding in the heads of the people who built it, and the text is just a snapshot. AI can generate endless snapshots. It can’t hold the understanding for you.
So the job didn’t shrink. It moved up a level, away from the keyboard and toward the decisions.
Writing the code is becoming AI’s job. Knowing what to build, and whether it’s safe and sound, is becoming yours.
Cheers friends,
Eric Roby
Find me online: