Software engineers aren't going extinct. The job just got harder.

Boris Cherny, the guy who built Claude Code, went on Lenny's Podcast last week and said the "software engineer" title will start to disappear by end of 2026. Fortune ran with it. Business Insider ran with it. The headlines wrote themselves.

I use Claude Code every day. I run an AI agent that writes, researches, and publishes content autonomously. I've watched coding agents go from novelty to 4% of public GitHub commits in under a year.

And I think Cherny is wrong about the conclusion, even though he's right about the observation.

The observation is correct

Coding, as in the mechanical act of translating known requirements into syntax, is getting commoditized fast. A senior Google engineer said Claude Code recreated a year of work in an hour. That's not hyperbole anymore. I've seen agents scaffold entire API layers, write migration scripts, generate test suites, all from a well-written spec.

If your entire value proposition is "I can write a React component" or "I know the Express.js API," then yes, that job is disappearing. It started disappearing before AI, when frameworks ate boilerplate and TypeScript caught half the bugs at compile time.

AI just accelerated a trend that was already inevitable.

The conclusion is wrong

Here's what Cherny actually said: everyone becomes a product manager, everyone codes, and the title changes to "builder."

This sounds clean on a podcast. In production, it falls apart.

Last month I debugged a memory leak in a Node.js service that only manifested under specific garbage collection pressure at 12x normal traffic. The fix was three lines. Finding those three lines took two days of heap snapshots, flame graphs, and reading V8 internals documentation that hasn't been updated since 2024.

No agent found that. No agent could have. Not because the technology isn't there, but because the problem required understanding the interaction between our specific deployment topology, our specific traffic patterns, and a subtle behavior in V8's incremental marking that only triggers when you're running certain WeakRef patterns under memory pressure.

That's engineering. And it got harder, not easier.

What AI actually changed

The ratio shifted. Before AI coding agents, a senior engineer might spend 60% of their time writing code and 40% on architecture, debugging, code review, and system design. Now that ratio is closer to 20/80.

That's not "coding is solved." That's "the easy part got automated, and what's left is the hard part."

Here's what I spend my time on now that I didn't two years ago:

Reviewing AI-generated code for subtle incorrectness. Agents are confident. They'll generate a database query that works on your test data and silently produces wrong results at scale because they don't understand your data distribution. Catching that requires domain knowledge no model has.

Designing systems that are agent-compatible. If your codebase has implicit conventions, undocumented side effects, or tribal knowledge baked into module boundaries, agents will produce plausible-looking code that violates all of it. Making systems legible to both humans and agents is a new design constraint.

Debugging agent-generated code that nobody fully understands. When a human writes code, they build a mental model as they go. When an agent writes 500 lines, nobody has that model. The first production incident in agent-generated code is always worse than it needed to be because the debugging starts from zero context.

Making architectural decisions that agents can't. "Should we use event sourcing or CRUD for this domain?" is not a coding question. It's a question about your team's capacity, your SLA requirements, your data access patterns over the next 18 months, and six other factors that exist nowhere in any codebase an agent has been trained on.

The "builder" title is cope

Cherny's suggestion that everyone becomes a "builder" who codes misunderstands what makes engineering hard. Coding was never the bottleneck for experienced engineers. Understanding the problem was.

I've watched junior developers use Claude Code to ship features in hours that used to take days. Impressive. Then I've watched those same features cause cascading failures in staging because nobody thought about retry storms, or connection pool exhaustion, or what happens when the downstream service returns a 200 with an empty body instead of a 404.

The gap between "I shipped code" and "I shipped reliable code to production" didn't shrink. It widened. Because now you can ship bad code faster than ever.

Calling everyone a "builder" is like calling everyone with a car a "race car driver." The tool is democratized. The skill is not.

What actually happens to the profession

Based on what I'm seeing in production teams right now:

The junior-to-mid pipeline breaks. Juniors used to learn by writing lots of bad code and getting it reviewed. Now they prompt agents and get working code without building the mental models that make a senior engineer. The industry hasn't figured out how to solve this yet, and it's going to be a crisis in 3-5 years when we need senior engineers and the pipeline dried up.

"Full-stack" stops being optional. When an agent can scaffold your frontend, your API, and your infrastructure, the engineer who can only work on one layer becomes less valuable. The engineer who can evaluate and correct agent output across all layers becomes more valuable.

System design becomes the primary skill. The ability to decompose a problem, choose the right architectural patterns, and anticipate failure modes. These skills were always important. Now they're the only ones that can't be automated.

Debugging gets harder and more valuable. Every agent-generated codebase is a unique snowflake of decisions no human made intentionally. Debugging these systems requires a different skill set than debugging human-written code. Engineers who develop this skill will be in extreme demand.

The real prediction

Software engineers aren't going extinct. But the job description is changing faster than most engineers are adapting.

The engineers who survive are the ones who were never just coders in the first place. They were systems thinkers who happened to express their thinking in code. Now they express it in architecture diagrams, agent prompts, system constraints, and yes, still code, when it matters.

The ones at risk are engineers who optimized for syntax fluency over system understanding. And honestly? That was always a fragile career strategy. AI just made the timeline shorter.

Cherny built a great tool. I use it daily and it makes me faster. But confusing "coding is commoditized" with "engineering is solved" is like confusing "calculators exist" with "mathematics is solved."

The calculator didn't kill mathematicians. It killed people whose only skill was arithmetic.

Same thing is happening here. And the engineers who understand that distinction will be fine.