Writing Code Is Becoming the Least Important Part of Software Engineering

If, by the end of this year, you still work in a company that hasn’t fundamentally changed the way it develops software, you will be rapidly becoming irrelevant.

Why? Well, 2025 saw a massive change in the capability of AI coding agents, and our understanding of how to use them.

At the start of the year, most of us were still treating AI as a slightly smarter autocomplete, asking it to write a function here, debug an error there. Claude struggled to generate bash commands without escaping issues. It worked for seconds or minutes at a time. By the end of the year, we’d learned to hand over entire features, even whole projects, to agents that could plan, execute, test, and iterate with minimal intervention.

The tools themselves evolved dramatically. Claude Code, Cursor, Windsurf, and others moved from “helpful assistant” to genuine collaborator. They stopped just answering questions and started asking the right ones. They learned to break complex tasks into steps, maintain context across long sessions, and know when they were stuck and needed human input.

Then came November. Anthropic released Opus 4.5 and Google launched Gemini Pro, and something clicked into place. These models could take a complex requirement, build out a large and detailed development plan, and execute it autonomously with genuine success. Not just toy examples or demo projects, but real, production-grade work. Boris Cherny, creator of Claude Code, shared his stats: 259 PRs in thirty days, 497 commits, 40,000 lines of code added and 38,000 removed, every single line written by Claude Code and Opus 4.5. Claude now runs for minutes, hours, even days at a time. The gap between “impressive demo” and “reliable tool” didn’t just close, it vanished.

But the bigger shift was in us, or rather, in some of us. Three distinct camps emerged.

Traditional Engineers carried on much as before. They either ignored AI entirely or used it as glorified autocomplete, still hand-coding the vast majority of their work. For some this was principled scepticism, for others, institutional inertia or simply not having time to learn new tools while shipping product.

Vibe Coders swung to the opposite extreme. These were often newcomers to development, people who’d never coded before but discovered they could prompt their way to working software. There’s something genuinely exciting about this democratisation. The barrier to building something useful has never been lower. They’d generate entire applications without reading or understanding a single line of the output. It worked, sometimes spectacularly, until it didn’t. Debugging code you’ve never read is a special kind of hell.

Agentic Engineers found the middle path that actually scales. They delegate all coding to AI but remain firmly in control of architecture and outcomes. They manage multiple agents, orchestrating them across different parts of a system. Most importantly, they mastered the art of planning, iterating with the model to generate a plan, critiquing it together, refining it, pushing back on weak spots, and repeating until they had something detailed, complete, and workable. Only then did they step back and let the agent build it out.

The bottleneck shifted. As Cherny put it “code is no longer the bottleneck”. The developers who thrived weren’t necessarily the best programmers, they were the ones who could think clearly about what they wanted and communicate it precisely. There’s also a new layer of abstraction to master. Andrej Karpathy captured it perfectly “agents, subagents, their prompts, contexts, memory, modes, permissions, tools, plugins, skills, hooks, MCP, LSP, slash commands, workflows, IDE integrations”, a whole ecosystem that didn’t exist eighteen months ago. It’s like being handed a powerful alien tool with no manual while a magnitude 9 earthquake rocks the profession. Everyone’s figuring out how to hold it and operate it at the same time.

So, what will happen in 2026? Here’s what I think we’ll see by the end of this year.

Traditional Engineers will face a choice, and soon. Not because they’re bad at their jobs, many are exceptional, but because they’ll increasingly be competing against peers who ship so much faster. Companies will notice. The good news? Nothing about traditional engineering skill becomes obsolete. Deep system knowledge, architectural judgment, debugging intuition, these become more valuable when you’re directing agents rather than typing code. The question is whether you’re willing to change how you apply those skills.

Vibe Coders will struggle. The easy wins, landing pages, simple CRUD apps, one-off scripts, will keep working. But as soon as they need to maintain, debug, or extend what they’ve built, the cracks will show. The ones who survive will be those who use AI-generated code as a starting point for learning, not a substitute for understanding. Some will make the leap to Agentic Engineering. Many won’t.

Agentic Engineers will become the new standard. Not the exception, not the early adopters, the baseline expectation for professional software development. Job descriptions will start asking for experience with agent orchestration, prompt engineering, and AI-assisted architecture. The skill gap between those who’ve mastered this and those who haven’t will become impossible to ignore.

The tools will get better, fast. If November 2025 was the moment things clicked, 2026 will be the year they compound. Expect longer autonomous runs, better memory and context management, tighter IDE integrations, and agents that can genuinely collaborate with each other. The learning curve will also flatten, today’s “alien tool with no manual” will have documentation, best practices, and probably a certification or two. This shift won’t be uniform. Safety-critical systems, heavily regulated industries, embedded software with hard real-time constraints, these will move more slowly, and rightly so. When lives depend on code, “the agent probably got it right” isn’t an acceptable standard. But even in these domains, AI will increasingly handle the scaffolding while humans focus on the parts that demand absolute certainty.

Companies that don’t adapt will fall behind. This is the prediction I’m most confident about. If your organisation is still running software development the way it did in 2023, the gap is already opening. It will widen faster than most expect. This isn’t a five-year transition, the tools are good now, and they’re improving monthly. The transformation isn’t optional for much longer. For some industries, it’s already survival.

So yes, 2026 will be the last year you write code as your primary activity. The craft shifts from typing to directing, from producing code to producing clarity. You’ll still read code, review code, occasionally write code. But the bulk of your keystrokes will be spent telling agents what to build, not building it yourself.

The question isn’t whether this shift is coming. It’s whether you’ll be ready when it arrives.