High Performance Tools Demand High Performance Drivers

Audio Narration

0:00

/752.3265306122449

1×

In early 2024 the best AI powered coding agent was like a 1960s Citroen 2CV with a  loose steering wheel. After some magic incantations, judicious use of the mysterious dashboard choke and a swift double de-clutch this motorised shopping trolley  might just head off optimistically towards your destination, only to unexpectedly and uncontrollably veer off into the nearest ditch.      Since the November 2025 release of Claude Opus 4.5 and last weeks further improvement with Claude 4.6 we now have something more like a 1970s Porsche 911 Turbo. That iconic car has been written into the annals of high performance motoring with good cause  as The Widow Maker. An expert driver in a 911 Turbo was the king of the road, but a 911 Turbo was just as likely as a 2CV to put a novice in the ditch, but in a much more terminal sort of way. No ABS, no traction control and no air bags.

Although agentic coding is unlikely to crystallise your life insurance, this analogy nicely highlights why software engineering experts are becoming productivity demi-gods, while simultaneously over-ambitious vibe coding novices are burying themselves in a torrent of toxic AI slop.

Garbage In, Garbage Out, an ancient computing aphorism, came decades before large language models, before “AI assistants,” before the comforting illusion that a system understands what we mean simply because it sounds fluent when it replies. The phrase was never an insult to computers. It was a warning to humans: machines are excellent at preserving and amplifying mistakes.

That property has not changed.
What has changed is the scale of what machines can produce and the illusory confidence with which they produce it.

The seductive lure of vibe coding

With the arrival of genuinely powerful coding models, we have entered the age of vibe coding. Code summoned not from detailed specifications, but from tone, intention, and conversational nudges.

“Build me a thing that does roughly this.”
“Make it secure.”
“Handle edge cases.”
“You know what I mean.”

And disturbingly often, something appears to work. To be clear, vibe coding can be phenomenally empowering when used appropriately, even by novices with no programming knowledge. The latest models can reliably vibe code straightforward but beautiful websites. They can also turn a simple prompt into a working app for administering a  local sports league , or controlling your home heating appliances. It is honestly marvellous, the possibilities are endless,  and anyone with a laptop and an internet connection can give it a go.

But for recent and upcoming computing graduates, this moment is especially dangerous. Vibe coding creates the illusion that you can walk straight into the kitchen and declare yourself a master chef, skipping the years as a kitchen porter, vegetable peeler, or sous-chef. Yet those years are where you learn the trade: washing grit from the vegetables, cutting away bruised fruit, and throwing out what should never reach the plate. Microwaves and liquidisers never handed Michelin stars to novices; they simply let great chefs do more with fewer helpers. Software engineering is no different. Cleaning inputs, discarding bad assumptions, and refusing to deploy garbage is not beneath the craft—it is the craft. And there is no shortcutting the hard yards - 10,000 hours and all that.

The scars you don’t have yet

Most graduates have not spent time in the muddy, corrosive waters of failed software projects. They do not yet carry the scars left by:

• Requirements that were “obvious” until they weren’t
• Security exposures waiting to be discovered by maliciously  creative  hackers
• Systems that passed tests but failed reality
• Post-mortems that carefully avoided the real cause

Those scars matter. They teach you where ambiguity hides, how assumptions rot, and why vague language is the most expensive material in software.

Vibe coding does the opposite. It rewards imprecision, defers responsibility, and quietly removes the friction that once forced engineers to think hard before code existed.

The catastrophic Moltbook security exposure is a perfect example of what happens when specification, review, and testing are treated as optional extras rather than load-bearing structures. The system appeared functional. It even appeared elegant. But beneath the surface, basic guarantees were missing, threat models were incomplete, and review processes were either inadequate or absent.

This was not a failure of cleverness.
It was a failure of discipline.

The Structure of Serious software development

For all the hype, real, complex  software development still has a stubbornly traditional shape:

1. Requirements discovery
   What problem are we actually solving? For whom? Under what constraints?
2. Functional specification
   What must the system do, precisely—and just as importantly, what must it not do?
3. Coding
   The mechanical act of translating intent into executable form.
4. Testing
   Exhaustive evidence that the system behaves as specified and fails safely when it does not.
5. Documentation
   A map for future humans who will inherit today’s decisions.

In 2026, AI is astonishingly good at coding.
It is increasingly competent at parts of testing and documentation.

It is still deeply unreliable at requirements discovery and specification, unless it is supervised by someone who already knows how these stages fail in practice.

Software engineers, not prompt engineers

The most valuable computing roles in the near future will not be people who can coax the prettiest code from a model. They will be people who know how to keep garbage out of the system—and how to detect it when it slips through.

On the way in:

• spot ambiguity, missing constraints, and false certainty in human requirements.
• turn conversational intent into crisp, testable specification.

Explicitly specify non-functional requirements such as performance, latency, availability and observability  

On the way out:

• mandate testing frameworks and methodologies
• review detailed test scripts for completeness and rigour including the testing of non-functional requirements    
• review test outputs and judge shipment readiness.

These roles are best filled by seasoned software engineers , in the traditional sense of software engineering – i.e. the engineering of complex software solutions to complex system requirements. These software engineers have repeatedly seen how small ambiguities  or inadequate testing become expensive failures. They have learned, the hard way, what bad software smells like before it fails in the field.

In the past week I have seen two utterly astonishingly productive pieces of agentic AI powered coding of complex software, using the same tool as novice vibe coders, but definitely not vibe coding in the sense of abdicated responsibility. Both of these were produced by world class software     engineers using Claude Code ‘properly’. One of them spent 8 hours producing a novel video compression module delivering current state of the art compression, sidestepping the complete minefield of compression patents  laid down over the past 40 years. Video compression is a well documented and precise problem but it is fiendishly complex code. The second example was accurate and flexible, blindingly fast searching of over 3 million emails all performed on the user’s own computer. No recourse to the cloud, and no frustration because you know the email’s there, it’s just that your (un)favourite email service just won’t surface the bloody thing. Again this is a distinctly non-trivial problem (gmail and Outlook have singularly failed to solve it in the past 20 years), but a truly hardcore software engineer with a large stash of Claude Code credits and a few hours of focused specification/management      can achieve a remarkable outcome. If you happen to have over 3 million globally toxic emails in need of deep mining, it might be worth contacting the very best software engineer you know.

These world class software engineers are today’s Porsche 911 Turbo drivers who will rule the road – they will not  die in a ditch.

Where this is heading

A division of labour, with AI just doing the coding bit  will not remain static. We are likely heading toward development processes in which models run not for minutes but for days or weeks, executing long-horizon plans and periodically pausing to call various “get me a human” tools when ambiguity, legality, risk, or novelty exceeds their thresholds. Crucially, that human will not always be the engineer who started the process. It may be a domain expert, a finance controller, a lawyer, an operations lead, or a customer—whoever can collapse uncertainty fastest at that moment.

In parallel, models will increasingly participate in requirements discovery and functional specification through sustained, model-driven dialogue with internal and external stakeholders. Not because the models suddenly “understand the business,” but because asking structured questions at scale is something machines are becoming very good at. The human role shifts again: from providing pre-packaged comprehensive specifications to providing intelligent answers and to recognising when the question itself is wrong.

What this means for graduates

This is not a story about fewer jobs. It is a story about steeper gradients.

Computing graduates who learn only to vibe with models will find themselves competing with those very models, which won’t end well . Graduates who learn to specify unambiguously, test mercilessly, and document for people they will never meet will be far more valuable.

The new royalty will not be lone coders. They will be master craftsmen: people who manage disciplined armies of coding agents, who provide clear and detailed specifications, who define the rules of testing and documentation, and who answer the hard questions that good AI systems are increasingly learning to ask.

The future belongs to those who have failed often enough to recognise garbage early, and to those who can teach machines to  check their own homework before throwing a pile of garbage over the wall. These experts will not contribute to an outpouring of toxic slop. They will instead be the highly paid tailors of made to measure, while you wait, software for every occasion.

If you’re a novice, feel free to vibe code with the latest models, but if you ever feel the backend drifting, or the path is becoming steep and slippery, find yourself a driver who’s  been here before, who knows the road and who has the skills to channel the power of today’s coding beasts.