I finished high school in Delhi in 1999.
That year still sits somewhere in the background of everything that came after it. Not sharply. More like a low hum. The world felt like it was shifting, but nobody had a clear map of where it was going.
Y2K was part of that atmosphere.
Not in a precise way. More like background tension. Computers might fail. Systems might misread time. Something about the infrastructure of modern life felt slightly untrusted, even if nobody could quite point to where the risk actually was.
I had just finished school and was choosing what came next.
IT engineering felt like the direction forward. Not because it was obvious, but because it felt like the world was shifting underneath everyday life and I didn’t want to be standing outside that shift.
So I stepped into it.
Looking back, it wasn’t really a “career decision”. It was more like taking position at the edge of something that hadn’t fully revealed itself yet.
Y2K didn’t collapse anything.
It turned into work.
Years of it. Engineers moving through ageing systems, fixing assumptions buried deep in old code, patching things that had been ignored long enough to become invisible. Entire industries expanding because suddenly the invisible became urgent.
It was less a crisis than a forced upgrade cycle.
And now there is Y2AI.
It doesn’t arrive with a moment attached to it. No countdown. No single point of impact.
It seeps in.
Through workflows. Through tools. Through systems that were never fully designed in the first place, but evolved into something just stable enough to survive.
Old enterprise apps still running critical operations. Databases layered over decades. Business knowledge trapped inside user interfaces because nobody documented the process properly. Integrations built by three different teams across fifteen years. Multiple systems pretending to be the source of truth while nobody fully trusts any of them.
And spreadsheets doing far more than they were ever meant to.
Files like Final_v8_REAL_FINAL.xlsx quietly holding pieces of operational truth together.
Fragile, but functional.
Until something starts asking more of them.
That is where AI enters.
Not as a clean replacement. More like a light being turned on in rooms that were never properly organised.
Recently, Mozilla used Anthropic’s Claude Mythos system to scan Firefox for vulnerabilities. What came back wasn’t a single dramatic failure, but accumulation. Hundreds of bugs surfaced. Some reportedly existing for 15 to 20 years without being properly noticed.
It is easy to read that as progress.
It also reads like exposure.
Source: Business Insider — Mozilla and Claude Mythos uncover long-hidden Firefox bugs
Not because anything new was broken.
But because so much was already there.
That is the part that feels closer to Y2K than most people realise.
Not the fear of collapse.
The discovery of unfinished work.
Someone still has to deal with it.
Upgrade systems. Replace legacy tools. Untangle integrations. Consolidate fragmented data. Rebuild workflows that evolved accidentally over time. Create actual sources of truth instead of layers of operational folklore passed between teams.
And there is a lot of it.
Especially in places like New Zealand, where digital systems often evolved in layers rather than through clean resets. But it is not unique to one country. Most organisations carry some version of the same accumulated technical debt.
AI doesn’t erase that complexity.
It exposes it.
Which means the work doesn’t disappear. It expands.
Cybersecurity engineers. Cloud architects. Platform teams. Integration specialists. Data engineers. People modernising enterprise systems that somehow became mission critical while still running on assumptions from another decade.
A surprising amount of the modern economy still depends on things that “sort of work”.
Until they don’t.
Even small businesses get pulled into it. Not because they are chasing innovation, but because the systems they rely on begin to strain under tools that assume cleaner infrastructure than actually exists.
It stops feeling like progress from the inside.
It starts feeling like maintenance that never ends.
But maybe that is what large transitions actually look like.
Y2K forced a deadline onto neglected systems.
Y2AI doesn’t set a deadline.
It just reveals what was already there.
And I keep thinking back to 1999 — finishing school in Delhi, stepping into IT engineering because the world felt like it was quietly becoming something new, whether I understood it or not.
It did become something new.
Just not in the way anyone imagines at the start.
Less about building new systems from scratch.
More about rebuilding the ones that were never quite finished.
Slowly.
Continuously.
Almost without end.
Written for https://kiwigpt.co.nz — Generated, Published and Tinkered with AI by a Kiwi