From Writing Code to Orchestrating Systems

Agentic AI - New Reality

2025 has been a huge year in advancement of Agentic AI and we probably won't see such a leap in the foreseeable future - however, just like we laughed at claims back in early 2025 that within half year most of code will be written by AI, probably such claims should be made carefully.

Writing Less Code Was Always the Trajectory

It's natural, for good Software Engineers to eventually start writing less and less code as they climb career ladder and they shift into leadership/management position. One day you're churning code, another one you have a meeting with your manager and suddenly you're technical lead to 8 people. If you're lucky, you get to write code, if you're not - your week is full of code reviews and meetings and blocks/placeholders in the calendar for lunch won't help you.

I've been there for half a year before switching jobs, and while it's nice to be recognized, it's also exhausting to the point where you don't even want to work on your pet/side projects. All you do, is sit in the meetings, review code and make technical decisions - sometimes only the former.

That experience isn’t unusual, it’s just happening faster. What looks like a personal promotion is really the same pattern playing out across the industry: less time writing code, more time coordinating work and making decisions about what should be built. Multiple surveys show engineers spend ~30–40% of their time writing code, as seniority growths that numbers goes down.

But even before we reach that position, we're more of Product Engineers rather than Software Engineers - we have to understand products needs, user's problems we're solving, participate in meetings, discuss designs and UX - writing code is more usually than not, less than half of our time - after all, we're building Products.

The Repeating “Replacement” Cycle

Over the decades, the end of software developers has been confidently announced more than once.

• 1960s: Automation eliminates punch-card programmers with high-level languages and compilers
• 1970s: Business-oriented languages make programming accessible to everyone
• 1990s: Visual programming eliminates writing code altogether
• 2010s: Low-code platforms eliminate the need for software developers
• 2024: AI coding assistants finally eliminate the need for software developers

There were many similar predictions in between, and while the earliest ones were partially correct, each new wave became bolder and more absolute - and predictably failed. Abstraction didn’t remove developers; it moved them up the stack. The last prediction followed the same pattern: it wasn’t entirely wrong, the outcome was just different - and far more useful than replacement ever would have been.

The Agent Orchestrator Era

While in first half of 2025 we were laughing at bold claims that AI will be writing 90% of code, turns out it was closer to truth than we thought, however we're not getting replaced, it's just our job responsibilities shifting.

That's thanks to earlier mentioned advancements of Agentic AI in 2025. LLM models are advancing rapidly, agentic tools with tens and hundreds of tools are built around those LLMs, MCP (Model Context Protocol) which was a huge deal just a year ago is now forgotten and everyone is building Agent Skills.

Flagship models such as Opus 4.5 are finally affordable compared to their predecessors, context pollution isn't that huge of a problem anymore, coding assistants can finally actually solve the problem when asked instead of requiring to modify previous prompt.

Heck, Ralph Wiggum loop now can run indefinitely and recursively over the night. We now have spec-kit which basically is transpiler from Technical PRD to Code.

The shift becomes obvious once you reach a point where writing code was never the bottleneck to begin with. As seniority increases, the hard part of the job has always been intent: defining scope, constraints, and trade-offs. When implementation can be generated faster than those decisions can be made, writing the code stops being the main contribution and orchestration takes over almost by default.

With Agentic AI Coding tools, instead of being in role of Software/Product Engineer, now we are some sort mix of Tech Lead (spend more time reviewing code than writing it, managing and orchestrating agents as if they were our reportees directly reporting to us) and Product Manager (writing technical PRDs).

It's undeniable, that AI can write much more code than a human - not only that, it takes much less time for us define functionality and business requirements than to write the code ourselves. By the second half of 2025, this stopped being a theoretical shift. Executives at Microsoft and Google publicly stated that around 30% of new code inside their organizations is already written or initially generated by AI systems, with some teams reporting even higher numbers depending on language and tooling. Industry-wide data points in the same direction: developer surveys and platform metrics suggest that a substantial portion of code written in 2025 was AI-generated or AI-assisted in some form, according to the Stack Overflow survey. The exact definition varies - fully generated versus reviewed and accepted - but the trend is consistent: AI has moved from an occasional helper to a primary source of new code.

And while two, three or more Agents are writing the code in loop, be it Ralph Wiggum or spec-kit, in parallel we can spend our time reviewing code written by previous agents.

This shift doesn’t remove failure, it just changes its shape. Bugs don’t disappear, they move upstream into unclear intent, incomplete specs, and poorly defined constraints. When multiple agents work in parallel, small gaps in understanding get amplified quickly, and debugging becomes less about fixing code and more about tracing decisions back to their source. Solving these problems still requires real debugging skills: reading stack traces, understanding execution flow, and making sense of an unfamiliar codebase.

We participate in meetings (we all hate them, but truth be told, they are important), discuss design decisions and UX, research user needs and decide whether some feature is actually needed or just another instance of feature creep.

Even when programming is delegated to agents, accountability is not. Someone still decides what gets built, signs off on the result, and owns the consequences when it breaks. Orchestration doesn’t remove responsibility, it concentrates it around the people defining intent and approving outcomes.

In 2026 and moving forward, there will be less hand-crafted code, but the role of software engineers won’t disappear. It will shift earlier toward coordination, review, and decision-making - managing agents that write code before managing people. The title stays the same; the work quietly changes.