The World Has Changed: Keep Up

The future of software engineering isn’t about writing code. It’s about making sure the machines write it right.

Looking back 18 months ago I would write every line of code by hand. AI had a limited, almost novelty role in the development process: useful for auto-completing a function signature here, suggesting a variable name there. It was a tool in the background, not a colleague.

Today, the world has changed.

I now have five to ten AI agents running at any given time, each working on distinct tasks across our platform. They write code, they refactor, they test. My role has shifted fundamentally. I spend my time researching and refining the agentic process we follow: establishing guardrails, improving prompt strategies, curating context, and constantly raising the bar on the quality of code these agents produce. A significant part of that research is simply keeping up. Model providers are shipping new releases at a relentless pace, and each release brings changes in capability, reasoning, and behaviour. You cannot just drop a new model into your workflow and hope for the best. Every update needs to be evaluated, understood, and tested against your existing processes before it earns a place in the pipeline. The goal is not to replace engineering judgement, but to encode it. Every safeguard I put in place ensures these agents follow our best practices, our architectural patterns, and our standards, rather than just producing something that compiles.

This is not vibe coding. This is agentic AI in production.

The Economics of Code Have Changed Forever

There is a fundamental economic shift underpinning all of this, and it deserves to be stated plainly: the cost of writing code has collapsed. A task that once required a team of five engineers working for a sprint can now be accomplished by a single engineer orchestrating a handful of AI agents in a fraction of the time. The marginal cost of producing a line of code is approaching zero.

This changes the equation entirely. Historically, the only way to ship more software was to hire more engineers. Headcount was the bottleneck, and scaling meant recruiting. That model is over. Organisations can now produce significantly more output without proportionally increasing the size of their engineering teams. The leverage that AI agents provide means a small, highly skilled team can outpace a large, conventional one.

This is not a theoretical projection. It is happening now, and the companies that recognise it are already pulling ahead. But it comes with an important nuance: while writing code is cheaper than ever, the consequences of poorly written code have not changed at all. Security vulnerabilities still cost millions. Architectural missteps still take months to unwind. Downtime still erodes trust. The cost of production has fallen, but the cost of failure remains stubbornly high.

This is precisely why the role of the engineer is not disappearing. It is being distilled. Cheap code without engineering oversight is just cheap risk.

The Engineer as the Human in the Loop

The role of the software engineer is being redefined. We are becoming the architects, the reviewers, the ones who understand why a system is built the way it is, not just how to type it into existence. The value of an engineer increasingly lies in their ability to reason about systems at a higher level: security implications, network topology, failure modes, scalability constraints, and architectural trade-offs.

Writing lines of code is becoming the smallest part of the job. Understanding what those lines should be, and catching when an agent gets it wrong, is becoming the entire job.

The Skills Gap No One Is Talking About

This shift exposes an uncomfortable truth about how we train software engineers. The skills that matter most in an agentic world (architecture, security, networking, systems thinking, and operational awareness) are precisely the skills most junior engineers lack. These topics are either absent from university curricula or buried in electives that students skip in favour of more immediately gratifying coursework.

A graduate who can write a REACT component but cannot reason about IAM policies, network segmentation, or data residency requirements is going to struggle in this new landscape. Not because they lack talent, but because their education didn’t prepare them for the role the industry now demands.

This does not bode well for the hiring of junior engineers in the near future, unless the companies doing the hiring are willing to invest the time and resources to upskill them. And that investment is significant.

A Word on Vibe Coding

Let’s talk about vibe coding for a moment. It has its place, and that place is with managers and non-engineers who want to explore an idea, prototype a concept, or understand what’s possible. Let them have a play. It’s a fantastic way to democratise access to software creation and build intuition about what technology can do.

Just don’t productionise what they build.

Vibe coding produces artefacts that look functional on the surface but lack the rigour, security considerations, error handling, and architectural coherence that production systems demand. There is a chasm between “it works on my machine” and “it works reliably at scale, securely, for thousands of users.” That chasm is where real engineering lives.

Never Trust a Single Model

So if vibe coding is the cautionary tale, what does rigorous AI-assisted engineering actually look like? It starts with a simple principle: if you are running your entire agentic workflow through a single AI model, you are doing it wrong.

One of the most important lessons I have learned in this process is that no single model is best at everything, and blind loyalty to one provider is a recipe for mediocrity. At any given time, I am working across multiple models, playing them off each other. One model generates the implementation; another reviews it. One drafts the architecture; another stress-tests the reasoning. When they disagree, that’s where the interesting conversations happen, and that’s where the real quality improvements emerge.

Different models have different strengths. Some excel at systems-level reasoning, others at nuanced code generation, others at catching edge cases in review. Treating them as interchangeable commodities misses the point entirely. The skill is in knowing which model to deploy for which task, how to structure your prompts differently for each, and how to synthesise their outputs into something better than any one of them would produce alone.

This is the new form of engineering judgement. You are no longer just reviewing code; you are orchestrating an ensemble of AI collaborators, each with their own biases and blind spots. The engineer who can do this well will produce work that is categorically better than the engineer who just asks one model and ships whatever comes back.

A Call to Action

We need a fundamental shift, in both education and company culture, to ensure we maintain and grow the software engineering industry through this transformation. Universities need to rethink what foundational means. Companies need to invest in mentorship, training, and patience with junior hires who arrive with the right curiosity but the wrong toolkit.

We are trying to do our part. We are embracing agentic AI not as a shortcut, but as a force multiplier: one that demands more engineering discipline, not less. We are building the processes, the guardrails, and the culture to make this work responsibly.

Are you doing yours?