5 min readJust now

–

Press enter or click to view image in full size

The meeting was already over.

One of those virtual one-on-ones that end politely, with the usual “all good?” and “yep, thanks,” the kind where nothing seismic is supposed to happen. I was already half gone, mentally closing tabs, when he added — casually, almost as an afterthought:

“Oh, by the way, I pushed a new version of the portal.”

That sentence should not have mattered. It should have slid past me like hundreds of others before it.

Instead, it stuck.

I manage engineering teams. That’s the only title that matters here. I’ve spent years absorbing the reflexes that come with it: how to ship safely, how to scale, how to protect users from ourselves. I’ve been trained — sometimes gently, sometimes brutally — to flinch at the right things.

And what he described next hit every single nerve ending at once.

He walked me through it, calmly. No bravado. No attempt to impress.

There was a spreadsheet. A shared one.

Product managers updated it manually with content changes. Service descriptions. Copy. Structure. The kind of thing that, in my world, tends to spawn tickets, schemas, migrations, and meetings.

That spreadsheet fed into an AI. The AI regenerated the app. A new version. From scratch.

He added, almost apologetically, that the generation always broke in a few places.

“But it’s fine,” he said. “It’s always the same places. I know where to fix it now.”

I remember nodding. I remember smiling.

Inside, something recoiled so hard it almost snapped.

If you’ve spent any time around “serious” software, you know the feeling.

The instinctive tightening in the chest when someone says spreadsheet. The muscle memory that associates it with shadow IT, broken formulas, and late-night incident calls. The quiet horror of imagining production systems duct-taped together by copy-paste and hope.

In my head, a whole museum of professional trauma lit up at once.

I remembered being schooled — really schooled — for not bumping a version number correctly. A release blocked because I missed an edge case that “should have been obvious.” Hours lost to debugging a delivery pipeline on a night when a launch could not be delayed. Pull request comments that might as well have said: throw this away, this is not how we do things here.

It was tough. But I learned.

I learned why rigor mattered. I learned why process existed. I learned how fragile things become when they scale, and how merciless production can be.

I passed those reflexes on. Mentored others into the same cautious posture. Taught them to feel the same flinch.

And now here was this thing.

Because the problem wasn’t that it was bad.

That would have been easy.

It wasn’t “good for a non-technical guy.” It wasn’t a prototype you apologize for.

It was better than average.

The portal looked clean. Clear. Useful. People used it. Liked it. Leadership loved it. It had been demoed upstairs and received the universal corporate signal of approval: impressed nodding.

And it had been built with:

• No budget
• No team
• No time
• No formal help

Best effort. In the purest sense.

Under the rules I grew up with, this thing should not exist.

Under those rules, we would still be discussing scope.

That’s when it hit me.

Not with fireworks. Not with futurist fanfare.

With the quiet, nauseating clarity of realizing the map no longer matches the terrain.

This guy hadn’t just shipped an internal tool.

He had built a delivery pipeline.

An ugly one. A heretical one. A pipeline that would make seasoned engineers wince on instinct alone.

And yet — it worked.

More than that: it worked enough. Enough to create value. Enough to justify its existence. Enough to survive contact with real users.

You can hate it. You can list everything wrong with it. You can predict, accurately, all the ways it might fail.

But you can’t deny that something fundamental has shifted when this becomes possible.

Here’s the part that’s uncomfortable to admit:

If it breaks in production tomorrow, that’s still a win.

Because now it exists. Now it’s visible. Now it’s valuable enough to escalate.

Worst case? It collapses under its own weight and we finally get the budget to rebuild it properly.

Under the old rules, there would have been nothing to rebuild.

This was a miracle born of unorthodoxy.

That’s when the grief showed up.

Real grief. For a craft I’ve loved my entire career.

Software creation used to be gated by technical mastery. By knowing how computers actually work. By understanding compilation, memory, networks, failure modes. The best practices we hold sacred were forged to optimize delivery when writing code was the bottleneck.

They are not suddenly wrong.

They are suddenly misframed.

Because the bottleneck has moved.

Where? I don’t know yet.

What I do know is this: I cannot go back to the old way. And I cannot fully accept the new one as-is.

I cannot sign off on systems regenerated from a spreadsheet. But I also cannot pretend the spreadsheet didn’t just ship faster than half the org.

That tension — that impossible position — is where I realized we’ve entered a new age.

We are no longer coding. We are creating software.

And creation has escaped the technical elite.

You no longer need to understand how a computer runs to make something useful. You need judgment. Common sense. Taste. The ability to notice what breaks — and why.

The old guard optimized for scarcity. The new reality is abundance.

And none of our instincts are calibrated for that yet.

There was another feeling underneath the awe and the grief.

Unease.

The quiet question nobody wants to say out loud in a managerial role:

If this is possible now… what happens to us?

Are we all about to be replaced? Or are we about to be repurposed?

I don’t buy the doomsday version. I also don’t buy the hype.

What I feel — strongly — is that the opportunity surface has exploded. There are more useful things waiting to be created than ever before. And the people who will make them are the ones who can let go of outdated constraints without abandoning responsibility.

That middle ground doesn’t exist yet.

So I’m going looking for it.

I don’t have conclusions yet. Only a growing certainty that the rules I learned to trust no longer fully apply — and that clinging to them out of habit is not the same thing as being rigorous.

I’m not writing this to defend the old ways or to celebrate the new ones. I’m writing it because I don’t think we can afford to look away while the act of creation itself is being rewritten.

What I do know is that something fundamental has changed — and pretending otherwise feels more dangerous than admitting we’re lost.

Next time, we hit the road properly.