Writing Code Was Never the Bottleneck

There's a certain kind of developer who treats code like poetry. Every abstraction carefully chosen, every function name debated, every design pattern weighed against alternatives. I've been that developer. Most of us have.

And then you ship it, and nobody cares. Not because the code is bad, but because the user never sees the code. They see the product. They experience the system. The code is just the substrate.

#The myth of the 10x engineer

For decades, our industry worshipped the idea that the primary bottleneck in building software was the act of writing it. We built hiring pipelines around it — whiteboard interviews, algorithm challenges, timed coding tests — as if the ability to invert a binary tree under pressure told us anything meaningful about whether someone could build a product that solves real problems.

The best engineering teams I've worked with weren't the ones with the cleverest code. They were the ones that understood what to build, communicated clearly about trade-offs, and shipped things that actually mattered. The code was a means, not the end.

#AI changes the cost, not the challenge

Now we have Claude, Copilot, and a rapidly growing ecosystem of tools that can produce functional code at staggering speed. The cost of generating code is collapsing toward zero. That is real. That is happening right now.

Relative cost of producing code over time — from expensive craft to near-zero commodity.

But here's the thing: the expensive parts of software were never about typing speed.

The expensive parts are figuring out what users actually need versus what they say they want. They're navigating the political landscape of an organization to get alignment on priorities. They're deciding what not to build. They're maintaining systems over years as requirements shift and teams change. They're reviewing changes carefully enough to catch the subtle bugs that only emerge in production at 3 AM on a Saturday.

AI doesn't solve any of that. Not yet, at least.

#A pattern we've seen before

Every major technology shift triggers the same conversation. When the web arrived, we had to rethink how teams were structured. CI/CD changed our relationship with releases. Mobile forced us to reconsider everything from design processes to deployment pipelines. Each time, the new technology made one thing dramatically easier — and in doing so, exposed all the other things that were actually hard.

AI-powered code generation is doing the same thing. By making code nearly free, it's shining a harsh light on everything else: the planning, the coordination, the understanding of domains, the empathy for users, the judgment calls that no model can make for you.

#The real disruption

The genuinely interesting question isn't "will AI replace developers?" It's "what does a team look like when code is abundant?"

When writing code was the bottleneck, we organized everything around it. Sprints, story points, velocity — all of these are fundamentally mechanisms for managing the scarcity of code production. What happens when that scarcity disappears?

Maybe we'll spend more time on research and prototyping. Maybe the ratio of thinking-to-typing shifts dramatically. Maybe code review becomes the new bottleneck — because reviewing AI-generated code that you didn't write yourself is genuinely exhausting in a way that writing it isn't.

I don't know the answers yet. Nobody does. But I find the questions exciting rather than threatening, because they're the same questions our industry has always faced: how do we organize humans to build things that matter?

The code was never the hard part. Now we just can't pretend otherwise.