The Market Is Bifurcating

The market for software engineering talent is splitting in half. Not gradually. Not theoretically. Right now, in the data.

AI-fluent experts earn 44% more per hour than they did 18 months ago. Entry-level developer jobs dropped 21% in 8 months. Junior developer employment (ages 22-25) is down 20%. The middle — the "competent generalist who writes decent code" tier — is being compressed from both sides.

This isn't speculation. It's the labor market responding to a new reality: when AI can generate 70% of a codebase, the value of writing that 70% collapses. The value of knowing what to do with the other 30% explodes.

The compression from below

Claude Code hit $2.5B ARR in 8 months. Not because it's a toy — because it's genuinely good. A competent founder with Claude Code can build, in a weekend, what used to require a team of 3-4 developers over 6-8 weeks.

25% of the current YC batch has codebases that are 95% AI-generated. Garry Tan isn't embarrassed by this statistic. He's celebrating it. The YC thesis has always been that great founders move fast — AI just made "fast" orders of magnitude faster.

This compresses the bottom of the market. If Claude Code can produce the same output as a junior developer, the junior developer's position becomes precarious. Not because they're bad — because the tool is that good at the tasks they used to own.

The entry-level developer job didn't disappear. It got automated. The 21% drop isn't temporary. It's structural.

The expansion at the top

Here's the other side: AI-fluent experts — senior engineers who use AI as a multiplier, not a replacement — are earning 44% more per hour. Demand for production-grade AI engineering has never been higher.

Why? Because the same tools that made building easy made production harder.

When everyone can build a prototype, the bottleneck shifts. It's no longer "can we build this?" It's "can we make this work at scale, securely, reliably, in a regulated environment, with real users who do unpredictable things?"

That question requires experience that AI tools don't have. It requires someone who's seen systems break at 3am. Who knows that the demo that impressed the board will hemorrhage money in production. Who builds evaluation pipelines by instinct because they've been burned by hallucinations before.

The Addy Osmani line is precise: "The best engineers won't be the fastest coders, but those who know when to distrust AI."

The death of the middle

The middle tier — the developer who writes solid code, follows patterns, ships features — is being squeezed from both directions.

From below: AI generates their output faster and cheaper. A Claude Code session produces the same CRUD endpoint, the same React component, the same API integration. The speed advantage of "I know this pattern" evaporates when the tool knows every pattern.

From above: production-grade engineering requires depth they haven't developed. Security hardening. Evaluation pipelines. Domain architecture. Failure mode design. These aren't skills you pick up by building more CRUD apps — they come from years of debugging production systems at scale.

The middle isn't dying because those developers are bad. It's dying because the value distribution changed. The 70% that used to justify a $120K salary is now generated in minutes. The 30% that justifies $200K+ requires a decade of battle scars.

Karpathy's trajectory tells the story

Andrej Karpathy coined "vibe coding" — the practice of prompting AI to generate entire applications without deep understanding of the output. He popularized it. He celebrated it.

Then he abandoned the term. By early 2026, he was using "agentic engineering" instead. Not because vibe coding doesn't work — it does, for the 70%. Because production requires a different vocabulary, a different skillset, and a different level of rigor.

The journey from "vibe coding" to "agentic engineering" is the journey from prototype to production. It's the journey from the 70% to the 100%. And it's the journey the market is pricing in real-time.

What this means

If you're building: start with AI. Claude Code, Cursor, whatever gets you to a working prototype fastest. The 70% is a gift. Take it.

Then decide: is this a prototype or a product? If it's a product, the engineering starts now. Security. Evaluation. Domain architecture. Failure modes. The last 30% that takes 90% of the expertise.

If you're hiring: stop looking for fast coders. AI is faster. Look for engineers who know what breaks at scale, who build evaluation before features, who think adversarially about their own code. That's the scarce skill now.

If you're an engineer: the path forward isn't coding faster. It's understanding production deeper. The engineers earning 44% more aren't better prompters. They're better engineers who happen to use AI as a force multiplier.

The bifurcation is here. Pick a side.