For the past few years, a familiar narrative has been circulating through the technology industry: artificial intelligence will soon replace software developers. Each new model release fuels another round of predictions that coding will become obsolete.
But this argument misunderstands what good developers actually do.
Programming was never primarily about writing code. In practice, it is often only a small fraction of a developer’s time.
The real value of a developer lies in understanding what should be built - and, just as importantly, what should not be built.
The Real Job of a Developer
A strong developer does three things exceptionally well:
- Understands the problem the business is actually trying to solve.
- Applies experience and best practices gathered over years of building systems.
- Reduces system entropy by decoupling components and maintaining architectural clarity.
Writing code is simply the visible by-product of these activities.
Good engineers spend far more time thinking about structure, constraints, and trade-offs than they do typing.
AI does not change this reality.
If anything, it amplifies it.
From 10× Developers to 100×
For decades the industry has talked about “10× developers” - individuals whose productivity far exceeds the average.
AI tools promise to make everyone faster. Code can now be generated almost instantly, boilerplate disappears, and entire components appear after a prompt.
But this raises the bar rather than lowering it.
If everyone can generate code easily, the differentiator becomes judgment.
Developers who were once considered 10× are now expected to become 100× - architects of systems and decisions rather than mere producers of code.
Yet the original notion of the 10× developer also included leadership and mentoring. The best engineers multiplied the effectiveness of the people around them.
In the race for 100× productivity, however, it is easy to spend more time pairing with Claude or other GPTs than with fellow developers.
The First Problem: The Organisational Bottleneck
AI dramatically improves the vertical part of development: producing code.
But code generation is only one stage of the software pipeline.
Organisations still need:
- product direction
- architectural alignment
- testing
- deployment pipelines
- operational monitoring
- cross-team coordination
Improving only the coding step does not automatically improve the entire system.
To truly benefit from AI, organisations must restructure their processes end-to-end.
This is not a small change. It resembles the transition to remote work during Covid-19, but may be more difficult.
It requires new workflows, new documentation habits, new coordination models, and new security practices.
The Second Problem: The Explosion of Artifacts
The more subtle challenge is that AI makes creation almost free.
When something is free, people create more of it.
Suddenly we have:
- not documentation, but comprehensive documentation
- not one architecture diagram, but hundreds of diagrams
- not one dashboard, but dozens of dashboards
- not one design proposal, but pages of LLM-generated analysis
And perhaps most dangerously:
- not a story with just a title - an honest signal that we still need to investigate - but hidden unknowns buried under layers of generated generalisations and hallucinations.
None of this necessarily increases ROI.
Instead, teams must now read and process enormous volumes of AI-generated material.
Code reviews become longer. Documentation grows thicker. Architectural discussions become noisier.
Ironically, developers become busier, not less.
Anyone who has experimented with vibe coding knows the pattern. At first everything feels fast and smooth. Code appears instantly, ideas flow, and progress seems effortless. Then a critical moment arrives: the prompts grow longer, the models consume more tokens, responses slow down, and the results begin to deteriorate.
The same dynamic can emerge at the organisational level in so-called “AI-native companies”. Remove too much human judgment and you also remove the person who can recognise when a system is becoming unnecessarily complex.
Large language models rarely challenge the premise of a request. They optimise for answering the prompt. If they lack certainty, they will often still produce a confident guess - a behaviour shaped by reinforcement learning, which rewards responses that appear helpful and decisive.
The Feature Creep Problem
Historically, one of the most valuable roles of a developer was saying no.
Good engineers constantly negotiate with the business:
- identifying what users actually need
- removing unnecessary complexity
- preventing tightly coupled systems
- stopping feature creep before it begins
AI changes the psychology of software development.
Because implementation suddenly appears easy, everything seems possible.
And when everything is possible, systems grow uncontrollably.
Features accumulate. Complexity increases. Coupling spreads across services.
No prompt can reliably stop this process.
Only humans can.
The Value of Imperfect Intelligence
Ironically, the strength of human developers is precisely that we are imperfect.
With limited attention and cognitive capacity, good engineers instinctively simplify.
They ask questions like:
- Do we really need this feature?
- Can we remove this dependency?
- What happens to the system in three years if we build this?
AI optimises for generating possibilities.
Humans optimise for reducing them.
That filtering function will remain essential.
Smaller Teams, Not No Teams
The clickbait prediction that “AI will replace developers” is unlikely to happen.
A more realistic outcome is smaller, more powerful teams.
This has happened before.
Software development has repeatedly evolved:
- Assembly → High-level languages
- Waterfall → Agile
- Monoliths → Distributed systems
Each transition changed how teams work.
AI is simply another shift.
But instead of eliminating developers, it changes their role.
Developers are moving further up the abstraction ladder - from writing code to designing systems.
In earlier generations of software tooling, discipline meant writing tests. In the age of AI-assisted development, it means controlling coupling and complexity.
The Conditions for the Next Generation of Teams
For AI-augmented development teams to reach their full potential, two things must happen.
1. Strong Human Architects
Teams will need talented individuals who can keep systems predictable even when using probabilistic tools like LLMs.
These developers must:
- manage complexity
- enforce architectural boundaries
- filter ideas before they reach production
In other words, they must guide the system through intentional constraint.
2. Organisations Must Centralise Knowledge
AI works best when knowledge is structured.
Organisations will increasingly move towards processes defined in files - ideally simple formats like Markdown.
Architecture decisions, workflows, product reasoning, and operational knowledge will need to live in clear, searchable systems.
In effect, companies will need organisational “knowledge operating systems”. Tools like Obsidian are more important than ever.
In the cloud shift, Terraform and infrastructure as code (IaC) emerged. Similarly, in the AI era, something like Company as Code will inevitably emerge.
The Return of Old Ideas
Interestingly, many older knowledge-management methods may become even more popular.
Systems such as:
- Zettelkasten
- Second Brain
- structured personal knowledge bases
may become central to how developers work with AI.
The development process itself may also evolve into a hybrid of Agile and Waterfall: iterative experimentation supported by strong documentation.
LLMs thrive on written context.
The more structured that context becomes, the more powerful the collaboration between humans and machines will be.
The Real Future of Development
AI will dramatically change software engineering.
But not in the way many expect.
The future developer is not someone whose job is only prompting models to generate code.
It is a systems thinker managing complexity in a world where creation is cheap but clarity is rare.
And as long as software systems remain complex - and businesses remain uncertain - developers will remain essential.
Possibly more than ever.