The Next Layer Down

The argument going around right now is that AI has made coding a commodity. That the barrier to building software has dropped so low that developers, as a profession, are on borrowed time. Why hire a team when a founder with ChatGPT can ship an MVP over a weekend? Why pay six figures for someone to write code that a model can generate in seconds? The whole industry, the argument goes, is about to compress in a way that leaves most of us on the wrong side of it.

I'm eleven years deep in enterprise dev work while actively pushing AI-accelerated workflows with Claude Code, so I'm seeing both sides of this in real time. And I think the premise is half right. Coding as typing is largely solved. Scaffolding a CRUD app, wiring up an API, generating boilerplate, that's all commodity work now. A lot of mid-tier SaaS is vulnerable to the person who says "I'll just build exactly what I need in an afternoon." The moat of "this was hard to build" is evaporating. I've watched it happen.

But coding was never the hard part. The hard part was figuring out what to build, why, and whether it actually works once it hits production. The developers in trouble are the ones whose entire value was translating a spec into working code. That layer is compressing fast, and I'd be lying if I said it wasn't unsettling to watch.

I think of it as a stack. The bottom layer, writing syntax, remembering APIs, boilerplate, is gone. AI handles that. I don't miss it. The middle layer, architecture, system design, debugging gnarly production issues at two in the morning, is augmented but I still have to think. I lean on AI constantly, but it's a conversation, not a handoff.

The top layer, understanding the domain, making tradeoffs, knowing what not to build, navigating organizational politics. That took me eleven years to develop. Six months ago I would have told you no model is replacing it anytime soon. I'm less sure now.

Here's what's bothering me. AI coding went from maybe 40-60% effective to 90-95% in about six months. Not years. Months. The bottom layer didn't erode gradually, it just vanished. The middle layer is already shifting in ways I didn't expect this quickly. And there is nothing that says the top layer is somehow immune. We just assume it is because it's the layer we're standing on.

The "developer as orchestrator" framing is real, I'm living it. Chaining agents, designing sub-agent pipelines, using MCP tools to compose systems that would have taken a team and a quarter to ship. The skill isn't typing code anymore. It's taste, judgment, and systems thinking applied through AI tooling. Knowing when the model is confidently wrong. Knowing which corners you can't cut in production, no matter how fast the scaffolding went up.

But if I'm being honest, how long does that last? If the pattern holds, and so far it has, then "orchestrating AI agents" is just the next layer down waiting to get compressed. The judgment I'm proud of might be the next thing the model learns to approximate well enough. Not perfectly. But enough that the gap keeps shrinking.

We probably need fewer developers to produce the same output. The standard response is "when building gets cheaper, people build more." Historically true. But the speed of this shift is different. The question isn't whether demand scales with supply. It's whether it scales fast enough to absorb how quickly the skill floor is rising. And the developer who can ship what used to take a team of five, that framing only works if you're the one doing the shipping and not the one being replaced.

Here's where I think the opportunity is, and it's not where most people are looking.

Right now companies have teams of developers. They work, but slowly, and they're expensive. Layers of process, standups, sprints, handoffs, code reviews, politics. Half the time the bottleneck isn't the code, it's the coordination. And the output is generic software that kind of does the job but never quite fits.

The sweet spot now is BYOT. Build your own tools. Smaller, leaner teams, maybe a single developer, building software that fits a company's specific problems. Not off-the-shelf SaaS with 400 features you'll never touch. Not a bloated enterprise platform that takes six months to configure. Actual tools, built to measure, by someone who understands the domain and has the AI firepower to ship fast.

Whether that's an internal dev embedded in a business unit or a small external team offering bespoke solutions, the model is the same. One or two people who deeply understand the problem can now deliver what used to require a department. Less time in Jira, more time solving real problems.

But none of that happens if we keep clinging to the old playbook. This is the part that frustrates me most. The processes, the frameworks, the career ladders, the way teams are structured, all of it was designed for a world where writing software was slow and expensive. That world is gone and most of the industry is still operating like it isn't.

We have to throw away the rule book. Reevaluate every assumption we've got. Two-week sprints made sense when shipping was hard. Rigid role separation between frontend, backend, DevOps was a scaling strategy for large teams, not a law of nature. The idea that you need a 12-person team and a quarter of runway to build an internal tool is just inertia at this point. We need permission to experiment. Let a single developer own a problem end to end. Let a two-person team pitch replacing a six-figure SaaS contract with something custom-built in a week. Design the process around these new capabilities from scratch instead of bolting AI onto the old one.

Most of the industry won't do this. Most companies will keep their big teams and familiar processes because change is uncomfortable and nobody wants to be the one who bet wrong. That's fine. That's the gap the rest of us walk through.

I spent years getting good at things that are now trivial. Writing an elegant function from scratch, holding an entire system in my head, the satisfaction of clean code that just works. Some of that is fading. Not because the skills are worthless, but because the economics shifted underneath them. I've mostly made my peace with it. But I get why developers feel like the ground is moving. It is.

So where does this leave me? Right now, a strong position. I understand the full stack, I've built real systems at scale, I know the domain, and I'm fluent in the new tooling. The developers threatened today are the ones resisting the shift, not leading it. I've watched people in my own circles dismiss AI-assisted development as a gimmick while their juniors quietly start outpacing them.

But "right now" might not last. I know that too.

The developers who thrive through this are the ones who stop thinking of themselves as coders and start thinking of themselves as builders of solutions. What matters is whether you can look at a messy business problem and see the software that should exist. Everything else is getting easier by the month.

Eleven years in, and for the first time I can't see what the next five look like. That's terrifying. It might also be the most interesting it's ever been.