Is coding dead? Workforce transformations rarely unfold as predicted.
The tech industry is buzzing with speculation about the end of software engineering. Headlines predict the obsolescence of coders while vendors pitch AI tools to replace them.
Anthropic's CEO Dario Amodei claimed in a recent interview that in 3 to 6 months, 90% of all code will be written by AI. He’s not alone: OpenAI’s Sam Altman has made similar predictions while Google's Sundar Pichai has said AI generates more than 25% of his code.
Predictably, reactions to Amodei were split: tech companies nodded their heads while many engineers heaped scorn on his talk and timeline.
Let’s unpack the hype. Having spent years in the trenches of software development and witnessing multiple technological shifts, my sense is that such workforce transformations rarely unfold as predicted.
In reality, they're messier, more nuanced and ultimately more interesting.
404: Engineers not found
First of all, software engineering isn't a monolithic profession but a sprawling constellation of specialized disciplines.
Despite common foundations from computer sciences, each domain requires distinct expertise and solves fundamentally different problems.
For example:
Front-end developers craft intuitive user experiences, balancing aesthetics with performance.
Back-end engineers architect systems that handle complex business logic and data flows.
Database specialists optimize information storage and retrieval patterns that can scale to millions of users.
Cloud engineers orchestrate distributed systems across global infrastructure. Security specialists protect systems from increasingly sophisticated threats.
Beyond these common roles lie even more specialized domains — graphics engineers pushing the boundaries of visual rendering, kernel developers working deep within operating systems,
AI engineers training complex models on massive datasets. Each specialty represents its own universe of knowledge, tools and challenges.
The senior engineer working on compiler optimizations has little in common with the senior designing real-time payment systems, despite sharing the label "software engineer."
Even among each domain themselves, specialties emerge depending on the targeted platform, scale of the system, financial constraints, etc.
But more importantly, software engineering, just like any other engineering discipline, is first and foremost, about people. In the overwhelming majority of cases, projects do not fail because code quality is too low, or because of technical issues.
Technical skills are required, but engineers also need to perform project management tasks, communicate and coordinate with other engineers and understand the needs and constraints of the other people that benefit from their creation.
(By the way, if you can tell me how long it is going to take you and how much it is going to cost, that would be nice, pretty please.)
This reality makes sweeping predictions about AI's impact inherently problematic.
Hierarchy of Engineering Complexity
Software tasks exist on a spectrum of complexity that corresponds roughly to career progression:
Junior engineers typically handle well-defined, bounded problems — implementing a specific feature according to detailed specifications, adding validation to a form, or writing unit tests for established functionality. These tasks require technical skills but operate within clearly defined constraints.
Mid-level engineers tackle more ambiguous challenges — designing subsystems, evaluating architectural trade-offs and solving problems where requirements evolve throughout the development process. These engineers must balance multiple considerations, from performance and security to maintainability and business needs.
Senior engineers address complex systemic challenges — scaling architectures to handle exponential growth, resolving intricate performance bottlenecks, navigating cross-team dependencies and making decisions with long-term implications for both technology and business strategy. These challenges demand not just technical skill but experience, judgment and deep contextual understanding.
This stratification matters profoundly when considering AI's capabilities. Current AI systems excel at tasks with clear patterns and abundant training data but struggle with novel problems requiring judgment and contextual awareness or tasks that are too uncommon.
Today's Reality: AI Impacts Workflows
In today's development landscape, AI tools have already transformed certain aspects of software creation.
GitHub Copilot suggests code completions that can save hours of routine implementation. ChatGPT can generate boilerplate for applications, create test scaffolding and help debug simple errors.
More recently, Claude Code allows developers to deliver fully fledged components or even entire applications. Lovable generates entire UIs from indications or wireframes.
These tools are probably the most useful at generating predictable code patterns — CRUD operations, API endpoints following RESTful conventions, standard authentication flows and routine test cases.
AI’s contribution diminishes, however, with performance optimization, security-critical components and niche decisions that require understanding business context and long-term implications or very specific implementations.
A recent study from researchers of MIT, Princeton and Microsoft highlights how difficult it is to quantify the gains of these tools.
With close to 5,000 developers studied, they didn't observe any significant gain for senior roles and some gains, with high uncertainty, for junior-level developers. The effect on the latter is however mostly consensual these days and we'll come back to this point later.
Unfortunately, studies remain elusive on the productivity benefits of these tools. Surveys from GitHub (the editor of Copilot) and McKinsey that circulated by the end of 2023, were mostly qualitative and focused on developer well-being (the "vibe," some might say).
The Challenges of AI Integration
Despite their promise, AI coding tools present significant challenges that are often overlooked in enthusiastic vendor pitches:
Quality Assurance Complexities
AI-generated code requires vigilant review. The models are refined to generate code that looks the most plausible possible and tend to follow general best practices. But it can for example miss critical context about a specific threat model.
This "plausible correctness" problem—where code appears functional but contains subtle flaws — represents one of the most significant challenges of AI integration.
This requires developers to maintain deep technical understanding even when delegating implementation to AI systems.
Knowledge Erosion Risks
Educational institutions report concerning trends as students increasingly rely on AI to complete programming assignments.
This trend creates the risk of a "knowledge gap generation" — developers who can use AI tools to produce code but lack the foundational understanding to innovate beyond what these tools can generate.
Organizations investing heavily in AI coding assistance need to simultaneously invest in preserving and transferring deep engineering knowledge.
Near-Term (2025-2028)
The next five years will likely bring both acceleration and refinement in how AI transforms software development:
The Changing Junior Dev Experience
The traditional path of junior development — writing simple features, learning through repetition, gradually taking on more complex tasks — is already evolving.
As AI tools automate routine coding tasks, junior developers will need to develop different skills earlier in their careers: System thinking, integration expertise and computer science fundamentals, will become more valuable than pure coding proficiency.
Understanding how components interact, identifying integration points and troubleshooting complex dependencies will remain challenging for AI systems due to their context limitations.
A more nuanced approach to AI collaboration will emerge, with successful juniors distinguished by their ability to validate AI-generated solutions rather than simply accepting them.
This represents a shift from "typing code" to "directing and validating code generation."
AI Specialists Within Dev Teams
New hybrid roles are already appearing that blend traditional engineering with AI expertise.
These "AI integration engineers" specialize in crafting effective prompts, validating AI-generated code for security and performance and creating guardrails that keep AI tools aligned with company standards and practices.
A Renaissance of Craftsmanship
Counterintuitively, as basic coding becomes more automated, we're seeing renewed interest in software craftsmanship — the art of creating exceptionally well-designed, maintainable and elegant code. Engineers who once spent hours on routine implementation can now focus on refining architectures, optimizing performance and creating more thoughtful abstractions.
Long-Term (2028-2030)
Looking further down the line, the transformation of software engineering will likely be more profound and systemic:
The Evolution of Languages and Tools
Current programming languages and tools were designed for human developers writing code manually. As AI code generation becomes more prevalent, we'll likely see new languages and frameworks optimized for human-AI collaboration rather than pure human authorship.
These might include higher-level declarative languages where humans specify intentions and constraints while AI handles implementation details.
Early examples already exist in specialized domains — tools like AutoML that allow developers to specify machine learning goals rather than algorithms and UI builders that generate code from design mockups.
LLMs themselves might drop human language altogether for certain parts of their generation and use a specific, optimized format to speed up the generative process.
The Transformation of Structure
As AI handles more implementation details, organizational structures will evolve to reflect new workflows. The traditional pyramid of many junior developers supporting fewer seniors will likely flatten as AI takes over more junior tasks.
Companies at the forefront of AI adoption are already experimenting with new team structures — smaller clusters of experienced developers working with AI tools rather than large hierarchical teams.
A VP of Engineering described their transformation: "We used to have teams of 12-15 people with a mix of junior and senior developers. Now we operate with teams of 5-7 more experienced engineers who accomplish the same work volume by leveraging AI effectively."
Preparing for AI-Augmention
For individuals and organizations navigating this transformation, several strategies can help ensure resilience and continued relevance:
For Individual Developers
Focus on developing "full-stack understanding" rather than just implementation skills.
The ability to move between business requirements, user needs, system architecture and implementation details will remain valuable even as coding becomes more automated. Cultivate the meta-skill of effective AI collaboration. This includes understanding at a minimum how these tools work to take full advantage of them.
Practicing them also allows us to validate AI-generated solutions and knowing when human expertise is required. The developers who thrive will probably be those who view AI as an amplifier of their capabilities rather than a replacement.
Invest in domains where human judgment and creativity remain essential — system design, security analysis, performance optimization and user experience.
These areas require contextual awareness and trade-off evaluations that current AI systems struggle with and will likely continue to in the future.
For Organizations
Create deliberate knowledge transfer mechanisms to ensure that automation doesn't lead to critical skill erosion.
This might include pair programming between junior and senior developers, architecture review sessions and deliberate documentation of design decisions and rationales.
Develop clear guidelines for AI tool usage that address security, intellectual property and quality assurance concerns.
Invest in long-term talent development despite short-term automation gains. The companies that thrive will be those that build human expertise alongside AI capabilities rather than viewing the latter as a replacement for the former.
Outlook: Evolution, Not Extinction
The narrative that AI will simply replace software engineers fundamentally misunderstands both the nature of software engineering and the capabilities of current AI systems.
What we're witnessing isn't the end of software engineering but its evolution into a discipline where human creativity, judgment and system thinking are amplified and augmented by increasingly capable AI tools.
The most successful engineers in this new paradigm won't be those who cling to traditional coding roles nor those who passively defer to AI systems.
They'll be the ones who develop a new kind of partnership with these tools — using them to handle routine implementation while focusing their human capabilities on the aspects of software creation that require judgment, creativity and contextual understanding.
For organizations, educational institutions and individual developers willing to embrace this transformation, the future offers not obsolescence but unprecedented opportunity — the chance to focus more on the human aspects of software creation that have always been the most rewarding and impactful parts of the discipline.
The software engineer of tomorrow won't write less code because they're less valuable, but because they're focusing their unique human capabilities on higher-level problems that truly create value in ways that AI alone cannot.
Agentic Foundry: AI For Real-World Results
Learn how agentic AI boosts productivity, speeds decisions and drives growth
— while always keeping you in the loop.