Dev-team-work in the Agentic Age

Why the expensive part was never the code, and what it really costs to modernize a legacy business system in 2026.

Three weeks ago I took on a web application migration that even the original vendor didn't want to touch. Today it's live in production, modernized, secured, and running on Canadian soil.

Priced the normal way, the engagement would've been a six-month job from a team and a six-figure invoice. I did it in three weeks, with an AI agent and a solid learn-build-test mindset.

Fear is the system nobody wants to touch

Nearly every established business has one: a tool built years ago, often by a vendor long gone, quietly running the day. It books the orders. Prints the invoices. Keeps the lights on. It works, but the risk profile keeps anyone from looking too closely at updating it.

In this case, the React framework was a few versions behind. The AWS server stack was weeks from losing security updates. The data sat in a third-party, US-hosted database — and with no backups, no tests, no health monitoring, and no documentation, the best way forward was guesswork.

Everything was working, but fragile. And leadership knew the "someday we'll deal with it" had arrived.

It's never one project, or an easy upgrade

This one was a bilingual ad-sales platform that had run a mid-sized Canadian organization for the better part of a decade. And here's what nobody tells you until you're in it: under the "just modernize it" ethos, the task meant doing all of these at once:

• Bring the front end forward three major framework versions.
• Force the runtime up to a supported, secure state on AWS and that deadline forced everything.
• Re-platform the database to an entirely different kind of database.
• Relocate the data off a US service onto Canadian-hosted AWS.
• Security-harden the platform across several independent red-team passes.
• Build a test suite from scratch, where there had been none, to prove everything still worked.

Each one is a real engagement a firm would quote you for. Priced the way the industry actually prices them, you're looking at a quarter-million to half-million-dollar effort, six months to a year, a team of people. In fact, the database move alone is commonly six figures.

I'll spare you the story, BUT... I did it in three weeks. AWS cancelled the security updates on June 30th, 2026. And now, 7+ days later, we're fully migrated, just waiting on the 30-day, end-of-month cron jobs to run in case any final bugs slipped through.

Patch or rebuild and it'll take months

Faced with an aging system, most teams reach for the same instinct: rewrite it clean. Start over. It feels responsible and ownable. And it's usually a catastrophe.

BUT... I didn't rewrite. That was the most important decision on the whole project. Instead, I grabbed my instance of Claude Code and asked the LLM agent a few questions:

• What does the feature-map look like?
• Can we derive the use-cases and technical use-cases from the code?
• What does a code review turn up — and can we write test scripts from what we find?

Instead of throwing the old system away, I moved it onto modern foundations without changing how it behaves. Same behavior. New everything underneath. All I did was ask questions — and insist every fix got documented.

That single call is the difference between a three-week success and an eighteen-month gamble. And the judgment didn't stop there. It showed up everywhere the stakes were high:

• When the old data has quirks, you preserve them, as exactly as you can. The migration is not a cleanup.
• How I drew the security line: critical fixes first, then hardening the rest and documenting the accepted risk.
• Build the test net first, and run it against both the current build and the new code. Every change would be checked against one question: does it still behave exactly as it did?

We didn't get to choose when to go live; AWS had already set the date. The cutover was a hard cut on July 1st. Old system archived, rollback frozen, zero data lost.

What, who, and how did the AI enable this?

Figuring out the design patterns in a legacy system is just asking questions. My career has taught me the most critical thing: learn the patterns in the system, and know that everything is just a remix of that thinking.

AND... that's exactly what a well-directed AI translates, fast and consistently.

We drafted the test net in hours instead of weeks. The LLM agent never got bored at the four-hundredth edge case or at my insistence on removing stale insights from the documentation. Claude carried the mechanical bulk so I could spend my attention on the handful of decisions that actually carried risk.

Some people wouldn't trust an LLM to code a simple feature. BUT... when you evolve the coherence through documentation, an LLM like Claude can do the work and evolve the code with you.

This isn't just my story. The whole industry is watching the same shift. Work that was financially out of reach eighteen months ago is now simply doable — with the right minds on the problem. Point the same tools at a system with nobody senior steering, and you get one of those disasters you hear about on social media.

My realization: agentic tools multiply whatever you bring to them. Bring nothing — or a lack of skill and the AI multiplies that too.

The work has FOREVER changed

The future of this work isn't AI instead of people. It's a human whose judgment gets positively amplified by AI. A small, senior, accountable team can now deliver what used to take a large one, in a fraction of the time.

Is it all synthetic output? All data with no insight? I'd put a higher value than most on the human activities around it, as long as the analysis and the business relationships stay human. As long as the accountability stays human, AND the hard calls stay human. In all cases, Agentic Development is the new leverage.

So if you've got one of those someday systems humming in the background, the one you're quietly dreading. Hear this!!!... it's more approachable than it was even a year ago. Not a rewrite. Not a year. Not half a million dollars. Weeks of careful work, the right hands on it, and you're out the other side on solid, sovereign ground.

That's dev-team-work in the agentic age. The team is just smaller now.

What's the system you've been avoiding? Ping me. Let's build.