AI can already generate code, accelerate development and automate work that once consumed hours of an engineer’s time. But as these tools become embedded in software development, a much bigger question is emerging: what does this mean for the future of software engineers themselves?
That was the focus of a recent event we hosted with our software engineering Meetup community, Beyond the Code, bringing together industry experts to explore “Software Engineering: Extinction or Evolution?”
Our panel featured Abby Bangster (Syntasso), David Denton (http4k), Dom Maurice (Chuffed with AI), Jon Pither (JUXT), Jonathan Courtois (Sky) and Louis Thorne (SGI). Together, they examined how AI is changing software development in practice, from productivity and hiring to the future of junior engineers and the skills that will command a premium.
The conclusion was far more interesting than simply asking whether AI will replace developers.
Software engineering is changing, but the value of an engineer may be shifting away from simply producing code towards something harder to automate: judgement, architecture, problem-solving, product thinking and understanding the customer.
For software engineers considering what their careers could look like over the next five or ten years, those shifts matter.
AI is accelerating software development, but speed isn't everything
Software engineering has always been shaped by tools that allow developers to work faster. Frameworks, libraries and new technologies have continuously reduced the amount engineers need to build manually.
AI is another step in that evolution, albeit a significant one.
One of its biggest advantages is the speed at which engineers can now experiment. Ideas can be tested, deployed, observed and iterated upon significantly faster. But increased output isn't necessarily the best measure of success.
The more important question is whether that speed results in better software and better outcomes, not simply more code.
For developers, that distinction is crucial.
As generating implementation becomes easier, being the person who can evaluate whether something should be built, determine how it should work and recognise whether the output is actually good becomes increasingly valuable.
The engineer's role could move above the syntax
One of the more provocative possibilities is that software engineers increasingly manage AI agents rather than manually writing every line themselves.
Experiments with agent-generated code are already raising questions about how much ownership developers will have over the code within their systems. Yet even if implementation becomes increasingly automated, the panel argued that architecture, interfaces and domains still have to be understood and designed correctly.
In other words, syntax becoming easier doesn't make engineering thinking redundant.
Engineers still need to understand the systems they're responsible for, how individual components interact and how complex work should be broken into smaller, independently manageable pieces.
The architecture sits above the syntax.
That could become an increasingly useful way to think about software engineering careers in an AI-enabled world.
What does this mean for software engineers?
Don't just become better at prompting an AI coding tool.
Build an understanding of why the generated solution works, how it fits into the wider architecture and what trade-offs it introduces.
The engineers who can challenge AI-generated output rather than simply accept it will be much better positioned to own increasingly complex systems.
The hidden risk: skill atrophy
Speed also introduces a less comfortable question.
If AI can solve problems instantly that developers previously had to work through themselves, do engineers risk becoming faster while simultaneously losing some of their deeper technical understanding?
The panel highlighted exactly this concern. Understanding how technology works is likely to provide more long-term value than simply generating increasing volumes of code. Optimising exclusively for speed risks eroding some of the knowledge that has traditionally made someone a strong engineer.
It means developers may need to become more deliberate about how they use AI.
There is a significant difference between using AI to accelerate something you understand and depending on it to make a decision you don't understand.
Junior engineers face an apprenticeship problem
Perhaps the biggest long-term challenge isn't what happens to experienced software engineers.
It's how new engineers become experienced in the first place.
Senior engineers have traditionally developed judgement through years of writing code, solving problems, making mistakes and seeing the consequences of technical decisions.
If AI increasingly handles that foundational work, the traditional apprenticeship model becomes much harder to replicate.
Removing junior roles entirely therefore creates a potential contradiction.
Companies may need fewer people performing routine implementation today, but they will still require senior technical judgement tomorrow. If organisations remove the work through which junior developers traditionally build that judgement, they need another way of creating experienced engineers.
What might junior software engineering become?
The implication isn't necessarily that entry-level software engineering disappears. Instead, organisations may need to redesign it.
Learning could place greater emphasis on:
- understanding architecture and system design
- reviewing and challenging AI-generated code
- solving customer and product problems
- understanding technical trade-offs
- developing communication skills
- learning the underlying technology rather than simply generating an implementation
The purpose of a junior role may shift from learning how to produce code efficiently towards learning how to make good engineering decisions. This is a forward-looking inference from the panel's concerns around apprenticeship and judgement.
The skills companies value are getting broader
AI isn't only changing how engineers work. It could also change what companies look for when they hire them.
The panel's assessment was direct: expectations are getting higher, and technical execution alone is becoming less of a differentiator.
Increasingly, organisations want engineers who can discuss technical challenges with other engineers, translate them for product teams and understand the product and customer behind the technology. The traditional distance between technical ability, product knowledge and communication is shrinking.
That means being an excellent developer remains important, but it might not be enough on its own.
What will make a software engineer valuable in the age of AI?
If access to technical capability becomes easier, differentiation moves somewhere else.
The discussion highlighted four areas in particular:
1. Judgement
AI can propose an implementation. Engineers still need to determine whether it is the right implementation.
Knowing "what good looks like" becomes more valuable when producing something is increasingly cheap.
2. Product thinking
Understanding why you're building something is just as important as knowing how.
Engineers who understand user behaviour, customer problems, cost and impact are better positioned to make decisions that genuinely improve a product.
3. Communication
The ability to move between engineering and product conversations becomes increasingly important as technical roles broaden.
4. Customer and industry knowledge
Technical skills don't exist in isolation. Understanding the environment in which technology operates, and the customers who ultimately use it, allows engineers to anticipate problems rather than simply respond to requirements.
Combined, these skills point towards a different definition of a high-performing engineer: someone who isn't simply capable of building software, but understands what should be built, why it matters and whether the result is good.
Is AI going to replace software engineers?
Probably the wrong question.
Every major shift in software development has changed which skills engineers spend their time using. AI appears likely to do the same, only potentially faster.
The mechanics of producing code may become less important. Architecture, product understanding, communication, customer problems and the ability to break complicated systems into manageable components remain essential.
That creates both an opportunity and a challenge.
AI can remove friction from engineering and give developers more time to focus on meaningful problems. But engineers still need enough technical depth to understand, interrogate and take responsibility for what their tools produce.
The engineers who thrive won't necessarily be those who compete with AI to write code faster.
They'll be the ones who know what to build, why they're building it and what good looks like when it's finished.
Software engineering isn't facing extinction. It's facing a redefinition of value.
Want to join the conversation?
From AI and emerging technologies to career development and the realities of modern engineering, Beyond the Code (our Meetup community) is a chance to hear different perspectives, share experiences and connect with others across the software engineering community.
Want to be part of the next conversation? Join Beyond the Code to discover upcoming events and get involved.
