“It works, don’t touch it” is now the most dangerous sentence in tech

An AI model judged too dangerous to release has exposed an uncomfortable truth: the legacy systems quietly running our banks, hospitals, and power grids are far more vulnerable than we let ourselves believe. The threat isn’t old code — it’s abandoned code. And the response isn’t a patch. It’s a fundamental rethink of how we build, defend, and value software.

For forty years, the smartest thing you could say about a critical system was four words: it works, don’t touch it.

That was wisdom. Stillness was a virtue. The system that ran untouched for a decade had earned its keep. Every night it read a number, did some math, wrote the number back, a million times without a mistake. You didn’t audit it. You didn’t rewrite it. You built a glossy app on top and left the engine alone, the way you’d leave a load-bearing wall alone.

I want to argue that something just quietly reversed that logic. The very stillness that earned our trust — unexamined, unchanged, unread — is now precisely what makes a system dangerous. The code didn’t move. The world around it did.

What changed

In April 2026, Anthropic announced a model it decided the public could not have.

It’s called Claude Mythos Preview, and the company chose not to release it. Instead, they handed it to a coalition of roughly fifty critical-infrastructure organisations — AWS, Google, Microsoft, Apple, Cisco, JPMorganChase, the Linux Foundation among them — under a program called Project Glasswing. The idea was to let the defenders patch before the rest of the world caught up.

Read that again. A technology company built something and then concluded the responsible move was to withhold it. That alone should make you sit forward.

What does Mythos do? It reads code and finds the ways code breaks. Pointed at OpenBSD — an operating system hardened by some of the best security minds alive for decades — it surfaced a flaw that had been hiding for twenty-seven years. Pointed at a ubiquitous video library, it found a bug in a single line that automated tools had run past five million times. And when asked not merely to find a weakness but to weaponise it, the model that came before it succeeded almost never. Mythos succeeded most of the time.

The reaction told you everything. Within weeks, the US Treasury Secretary and the Fed Chair pulled major bank CEOs into a room. India’s Finance Minister convened the RBI and the heads of the banks. The European Central Bank called an urgent meeting. Central bankers across the world held emergency sessions about a model they are not even allowed to use.

And the containment failed almost immediately. The model leaked — not through some cinematic hack, but through borrowed credentials from a contractor and a guessed web address. Even fifty handpicked partners couldn’t hold it for a day. Anthropic itself estimates that comparable capability, including in open form, becomes broadly available within roughly twelve to eighteen months.

So that’s the clock. Eighteen months to confront what we’ve avoided for thirty years.

It was never really about COBOL

The easy version of this story is about old banking mainframes. By widely-cited if aging industry estimates, COBOL still underpins something like 95 per cent of ATM transactions, and hundreds of billions of lines of it remain in production. Some single banks run three hundred million lines at their core, written in the 1980s, last understood by people who have since retired or died.

That story is true. But it’s too small.

Mythos doesn’t read COBOL. It reads code. It does not care whether the lines were written in a language older than the moon landing, or in a framework that felt modern in 2012. What it hunts is not age. It is abandonment — code that nobody owns, nobody reads, nobody fully understands anymore, still quietly wired to the network, still moving something that matters.

Also Read: Why the US tech rebound matters for SEA’s AI and venture ecosystem

And here is the trap most leaders will walk straight into: the belief that building something new makes them safe.

It doesn’t. Newness isn’t a state of safety. It’s the first day of a countdown. That twenty-seven-year-old flaw was, once, a fresh commit written by a careful engineer who believed it was correct. Every piece of legacy code was somebody’s clean, modern, well-intentioned new code. Age didn’t make it vulnerable. Time merely revealed what was always there, while nobody was looking again.

In one specific way, new software is more exposed, not less. The old mainframe was a windowless bunker — dangerous because nobody had the map, but also sealed, air-gapped, sitting in obscurity behind decades of forgetting. The thing we build today is a glass house. It lives on the public internet by default. It speaks through a hundred APIs. And it is assembled — not written, assembled — from a thousand prefab parts shipped in from open-source factories none of us inspected. The infamous Log4Shell crisis wasn’t old code failing. It was modern code importing a tiny utility nobody had read, inside nearly everything. We didn’t write that bug. We installed it.

Then comes the sharpest irony of this exact moment. The same AI revolution that produced Mythos is also flooding the world with machine-generated code faster than any human can read it. We are manufacturing tomorrow’s abandoned systems today, at industrial scale, and calling it productivity. The gap between lines written and lines understood has never been wider. That gap is the attack surface.

So the variable was never age. It was attention.

Where stillness is most sacred

Now widen the lens past banking to where “don’t touch it” is treated as scripture.

Utilities run operational technology often older than the banking code, because you do not casually reboot a power grid to install a patch. Hospitals run frozen embedded systems inside MRI machines and infusion pumps, certified once and never touched again. Logistics, water, energy, public records — the systems a country actually rests on — much of it held together by the quiet assumption that nobody was looking.

This isn’t hypothetical. We’ve already seen it at human speed. A piece of malware once erased a global shipping giant’s entire logistics backbone in hours; the company survived partly because a single server in Ghana happened to be offline. A worm walked into the national health service through unpatched machines and turned ambulances away.

Those attacks were carried out by people. Slow, tired, fallible people. Now imagine the same intent, equipped with something that never sleeps, never retires, and no longer needs a hunch.

The honest comparison, and where it breaks

The instinct is to call this Y2K again, and that instinct is half right.

Y2K is the right metaphor for the mobilisation. A vast inventory of legacy code, a global scramble, a deadline, and an enormous surge of demand for people who could go in and fix it. That surge is, quite literally, what built the modern Indian IT industry — Infosys, TCS, and Wipro booked the work, earned the trust of Western clients, and never looked back.

But Y2K is the wrong metaphor for the threat. Y2K was bounded, dated, and deterministic. Everyone knew the deadline, the failure, and the fix. You could declare victory at one minute past midnight and go home.

This has no midnight. It is open-ended and adversarial. There is no single patch, no finish line, no moment when you are done. The discovery engine keeps improving while you sleep. So if you take only one lesson from Y2K, don’t take “there will be a project.” Take “there will be a permanent capability — and someone will own it.”

Also Read: The sovereign AI moat: Why integrated risk is the only way to scale intelligence in 2026

There is no fix, there is a posture

This is the part nobody wants printed on a slide. There isn’t a fix — because we’ve been misnaming the problem the whole time. We thought we had a maintenance problem. We have a metabolism problem.

A building, once built, can stand untouched for a century. We quietly borrowed that mental model for software — construct it, certify it, occupy it, walk away. But software was never architecture. It’s closer to something alive. And living things that stop renewing don’t hold steady; they rot. We simply couldn’t see the rot because nothing was poking at the body. The system looked healthy because no one was testing whether it still was.

So if there’s no fix, what’s left? A change of posture. From building to tending. From done to alive.

That sounds soft until you make it concrete, and then it turns brutal. You can no longer answer a sleepless adversary with a quarterly patch committee. The attacker works in hours; a defender who works in months has lost the arithmetic before anyone arrives. The only thing that collapses that asymmetry is symmetry — attention as continuous as the attack. And it begins with the most unglamorous act of all: knowing what you own. You cannot defend what you cannot see, and most organisations genuinely do not have a complete list of what runs inside their own walls, who wrote it, or who still holds a key.

Here is the inversion that is the answer. For forty years, we optimised software for stability — its highest virtue was that you never had to touch it. The new world flips the virtue. The system that survives is not the one that never moves. It’s the one that can be moved safely every single day. Changeability becomes the security property. The organisation that can rewrite, redeploy, and re-examine a component on an ordinary Tuesday without fear is the one that outruns the threat — not because it’s invulnerable, but because it heals faster than it can be wounded.

Stop chasing invulnerability; it was always a fantasy. Chase resilience.

The roles ascend

A living system needs organs — and that is what our software roles are quietly becoming.

Start with a reframe. The engineer was never valuable because they could type. They were valuable because they understood — and code was simply the only interface we had for expressing that understanding to a machine. Now the machine can take intent more directly. So the typing falls away, and what’s left standing is the thing we were paying for all along: the judgment. The job was never the code. The code was the proxy.

So the builder ascends. The question shifts from did I write this correctly? to is this what we meant, and can I prove it does that? Quality stops being the people who find bugs after the fact and becomes the people who author the intent and the test of the intent — then validate that the generated thing honors it. We used to pay people to write the answer. Increasingly, we pay them to know whether the answer is true.

The same inversion hits security, and it’s the sharper one. The old model was the firefighter: sit in the station, wait for the alarm, run toward the smoke. But when an unsleeping engine surfaces weaknesses every week, incidents stop being events and become weather. You cannot staff for weather with a fire brigade. The role becomes the gardener — continuous, vigilant, tending both the known cracks and the ones still surfacing. And the scarce skill is no longer the patch. The machine can produce ten thousand findings; the irreplaceably human act is deciding which of them matters, what is worth defending, and how. Not coding the defense. Discerning it.

Be honest about the cost, though, because it’s the opposite of comfort. This is a higher bar, not a lower one. To author intent, you must actually know what you want — precisely enough to specify it, precisely enough to test against it. And most organisations have never had to. The slow act of writing code let them discover their intent by trial and error, hiding the fact that they often didn’t know what they meant. Take the slow part away, and you expose the gap. The hardest thing in the new world isn’t the machine. It’s learning to say clearly what we want.

The opening for India and the Philippines

Here is where I stop describing weather and start arguing.

Notice that every shift in this essay is the same movement at a different scale: value is leaving production and migrating to intent, judgment, and care. It’s true for the individual engineer. It’s true for the organisation. And it’s true for entire nations.

The countries that built their software industries on cost arbitrage are standing at a fork — because the same AI that creates this mountain of remediation work is also eroding the bodies-on-seats model that historically did the remediation. India’s IT industry is approaching three hundred billion dollars in revenue. The Philippines, my home base, crossed thirty-eight billion in IT-BPM exports and is climbing toward security, modernisation, and engineering rather than seats.

Also Read: When startups fail, should VCs go to jail?

The wrong response is to wait for the tickets to arrive and bill by the hour. The right response is to own the capability — to build the AI-augmented modernisation platforms, the secure-code practices, the disciplined incremental migration (the strangler approach that drains a legacy system one capability at a time rather than the big-bang rewrite that has wrecked more than one bank) — and to do it as intellectual property made here, not labour rented from here.

Y2K rewarded whoever showed up with hands. This one rewards whoever shows up with a system. For a region with deep engineering talent and a thirty-year track record of doing exactly this unglamorous, mission-critical work, that is not a threat to survive. It is the largest opening in a generation — if we choose to build the tools instead of waiting to be handed the tickets.

What this asks of you

If you run anything that matters — a bank, a utility, a hospital network, a government platform — the comfortable sentence has expired. It works, don’t touch it is no longer a caution. It is exposure.

A few questions worth sitting with before the clock runs out:

• What are you protecting with stillness that you should be protecting with attention?
• If a machine can now write the answer, what exactly were you being paid for — and are you ready to do that instead?
• Can your organisation say clearly what it wants, or has it only ever discovered its intent by accident, one line of code at a time?
• Are your defenders still waiting for the alarm, in a world where the smoke never stops?

The work was never the keystrokes. It was always the knowing. We just couldn’t see it because the keystrokes were in the way.

Magicians conceal. Builders reveal. The old systems kept their secrets because no one was asking. That era is ending — so turn on the lights, look hard at what you’ve been afraid to touch, and decide now whether you’ll be the one who builds the response or the one who rents it.

You have about eighteen months before someone else looks first.

The post “It works, don’t touch it” is now the most dangerous sentence in tech appeared first on e27.