An evolving perspective. This article is a living opinion, updated as AI capabilities transform software development. First published February 2023. Each update captures the latest thinking while preserving the arc of how this question has evolved.
The question of whether AI will replace developers has followed me for years. I first wrote about this in 2023 when ChatGPT became the industry’s hot topic. Two years later, I explored the concept of commanding AI programmers. Now in 2026, autonomous AI coding agents are writing production code, running tests, and shipping features with minimal human intervention.
The question hasn’t changed. But my answer has deepened considerably and there are new risks that our industry needs to confront honestly.
2023: AI as an Assistant
When ChatGPT blew up, the developer community collectively wondered: is this the beginning of the end?
The reality was far more nuanced. Tools like ChatGPT and GitHub Copilot were genuinely useful, replacing the endless StackOverflow trawl with instant, contextual answers and offering tab-completable code suggestions right in the IDE. But they were assistive tools.
AI in 2023 struggled with context and nuance. It would confidently generate incorrect code, wrapping it in convincing explanation that could mislead developers. You still needed to be experienced to spot the mistakes, explain why the output was wrong, and guide the AI toward a correct answer.
The tools couldn’t generate an entire solution from arbitrary input. They produced snippets, not systems.
The takeaway at the time: embrace AI for the mundane, but don’t expect it to replace the creativity and problem-solving that developers bring. A fusion of worlds, not a replacement.
2025: AI as a Programmer
By 2025, the landscape had shifted dramatically. I wrote about commanding AI programmers, a fundamentally different approach where AI wasn’t just assisting, it started producing solutions.
Tools like ChatGPT’s Canvas with reasoning models enabled developers to describe what they wanted and have AI generate complete, functional code. I personally converted an entire Python library (pdf2image) to C# in an hour using this technique, something that might have taken days of manual effort.
This reframed software creation as more of a management task. Defining the vision, constraints, and desired outcomes rather than hand-coding each element. The developer’s role shifted from writing code to reviewing, guiding, and iterating on AI output using their domain expertise.
The key insight: developers didn’t need deep expertise in every language or domain anymore. They could command AI to build in unfamiliar territory, then apply their engineering judgment to verify and refine the output.
2026: AI as an Autonomous Agent
The latest evolution is the most significant. AI coding agents like GitHub Copilot in agent mode and Claude Code navigate codebases, plan multi-step implementations, run tests, debug failures, and iterate toward working solutions autonomously.
In practice, this is extraordinary. Teams are assigning work items directly to AI agents. Multi-file refactors that would take a developer half a day happen in minutes. At Microsoft, 7 part-time engineers delivered a preview in 10 weeks with 110,000+ lines of code, 98% AI-generated. The human work shifted from authoring code to directing it.
But here’s what makes the real difference: context. I’ve been exploring how to teach AI agents to work effectively on your codebase using structured context files like AGENTS.md and SKILL.md. These files act as behavioral contracts, telling the agent what your project is, what rules apply, and how specific types of work should be done.
The result? AI agents that produce code your team would have written, following your conventions, patterns, and quality standards. Without that structured context, you get generic code that compiles but doesn’t belong. With it, you get a reliable collaborator.
What this means for developers: The work is shifting from writing code to defining the systems, constraints, and context that enable AI to write code well. Developers are becoming architects of intent.
The Risk Nobody is Talking About
There’s a dimension to this that most “will AI replace developers?” conversations ignore entirely, and it’s the one that concerns me most.
Mark Russinovich (Azure CTO) and Scott Hanselman published a paper in Communications of the ACM in April 2026 that frames it perfectly: agentic AI creates a seniority-biased technological change. It dramatically boosts experienced engineers, those with architecture intuition, systems judgment, and domain knowledge. While on the other hand, it drags down early-in-career developers who lack the experience to steer, verify, and integrate AI output.
The data backs this up. After GPT-4’s release, employment of 22–25-year-olds in highly AI-exposed jobs fell by approximately 13%, even as demand for senior roles grew. The economic incentive is clear but dangerous: hire seniors, automate juniors.
Scott Hanselman said this perfectly in a recent talk I attended, and it resonated with my deeply. If organizations stop investing in junior developers, the senior pipeline dries up. The judgment, architectural intuition, and “systems taste” that make senior engineers effective at directing AI, these are skills built through years of hands-on experience. There are no shortcuts.
This is what Russinovich and Hanselman call the narrowing pyramid, the base of the engineering organization shrinks, fewer engineers gain foundational experience, and eventually code quality erodes because there aren’t enough people who understand why things should be built a certain way, only people who can ask AI to build them.
So, Will AI Replace Developers?
After years of watching this space evolve at breakneck speed, here’s my honest assessment:
AI will not replace developers. But it is fundamentally reshaping what developers do, and who gets the opportunity to become one.
The developer role is evolving through distinct phases:
| Era | Developer Role | AI Role |
|---|---|---|
| Pre-2020s | Write all code | None / basic autocomplete |
| 2021 – 2023 | Write code, use AI for suggestions | Assistive for snippets, Q&A |
| 2025 | Define requirements, review AI output | Programmer that produces complete solutions |
| 2026+ | Define architecture, context, quality | Agent that autonomously implements features |
What remains uniquely human is the creative and strategic layer: understanding business problems, designing solutions, making judgment calls about trade-offs, and defining the context and constraints that make AI effective. The more AI can do, the more valuable these human skills become.
The developers who thrive won’t be the ones who can type code the fastest. They’ll be the ones who can:
- Architect systems that are clear enough for both humans and AI to work within
- Define quality standards through structured context, tests, and conventions
- Make judgment calls on trade-offs, user experience, and business value
- Mentor the next generation because AI can’t teach systems thinking, and we can’t afford to lose the pipeline
- Express their creativity through new kinds of software that weren’t possible when every line had to be hand-coded
Common Mistakes Developers Are Making With AI
Watching developers adopt AI coding tools over the past three years, I’ve caught wind of a few issues (as many of us will have too):
Abandoning foundational learning. If you’re early in your career, don’t let AI do everything for you. The judgment you’ll need in five years to direct AI effectively comes from struggling with code today. Use AI as a learning accelerator, not a learning bypass.
Ignoring structured context. The difference between generic AI output and code your team would have written comes down to structured context in AGENTS.md files, coding standards, architectural constraints. Skipping this means every AI interaction starts from zero.
Treating AI as a replacement for code review. AI can write code. It cannot yet reliably judge whether code is the right code for the business context on its own. Human-in-the-loop remains essential for intent, architecture, and strategic alignment.
Not investing in prompting and context skills. “It didn’t give me good code” usually means “I didn’t give it good context.” Learning to communicate effectively with AI with clear intent, constraints, and examples is now a core engineering skill.
Looking Forward
Every time I revisit this question, the answer gets more nuanced but the core truth stays the same: AI amplifies developers, it doesn’t replace them. The ceiling of what a single developer can build keeps rising. The floor of expertise needed to build meaningful software keeps lowering. Both of these are good things.
If you’re a developer today, lean into the evolution. Learn to work with AI agents, structure your projects for AI collaboration, and focus on the skills that matter more as AI handles more of the implementation work. Explore problem decomposition, system design, quality judgment, and creative vision.
And if you’re leading a team, ask yourself: are you growing engineers, or just consuming them?
The future isn’t developers versus AI. It’s developers with AI, building things neither could build alone, but only if we invest in the humans as deliberately as we invest in the tools.
This article was first published in February 2023 and has been updated to reflect the rapid evolution of AI in software development. Previous versions explored commanding AI programmers (2025) and teaching AI agents to work on your codebase (2026). This update incorporates insights from PRAISE: Redefining the Software Engineering Profession for AI by Russinovich and Hanselman.
Discover more from James Croft
Subscribe to get the latest posts sent to your email.
