The $1.52 Trillion Eraser

Computer use agents won't rewrite your legacy systems. They'll make it stop mattering that nobody can.

EXECUTIVE SUMMARY

Every enterprise is carrying technical debt: the brittle integrations, the undocumented workarounds, the twenty-year-old system that still runs the quarter because nobody dares touch it. The standard remedies — rewrite it, replatform it, wrap it in APIs — are slow, expensive, and fail more often than anyone admits. This week I want to make the case that computer use agents, the AI systems that see a screen and click and type the way a person does, are the first genuinely new remedy in decades. They don't pay the debt down. They make the interest stop accruing.

// Technical debt now equals 20 to 40 percent of the value of the entire technology estate, according to CIOs surveyed by McKinsey, and the Consortium for Information & Software Quality pegs the accumulated principal on US software technical debt at roughly $1.52 trillion.

// The interest payments are your people: developers spend about 42 percent of their working week on maintenance, bad code, and debt service per Stripe's Developer Coefficient study, while McKinsey finds 10 to 20 percent of the budget earmarked for new products gets quietly diverted to servicing debt.

// The tooling to change this just went mainstream: computer use agents leapt from 42.2 percent to 61.4 percent on the OSWorld benchmark in four months, Claude for Chrome now ships on every paid Claude plan, and ChatGPT agent runs on its own virtual computer with a browser, a terminal, and API access.

// The cautionary tale is already on the books: roughly half of traditional RPA projects fail, per Deloitte and EY findings, largely because script-based bots shatter every time a UI changes — brittle automation that became technical debt of its own.

The strategic posture: stop treating technical debt as an engineering problem waiting on a rewrite. Treat it as a debt you can now refinance — and start with one copy-paste-between-systems workflow this quarter.

// The Deep Dive

Nobody plans technical debt. It accrues — knowingly or not — one reasonable decision at a time. The right fix takes three weeks and the deadline is Friday, so you do the band-aid: the hardcoded tax rate, the nightly export somebody re-keys into the other system, the quick patch that handles the one weird customer instead of the fix that would make weird customers impossible. And in the moment, that's not negligence. That's a trade. You borrowed three weeks, and the loan came with interest.

The trouble is that band-aids don't get removed; they get built on. The workaround works, so it ships, and shipping makes it permanent. Six months later a new integration has to route around the hardcoded rate. A year later the re-keyed spreadsheet grows a macro, the macro grows an owner, and the owner becomes the only person who can run month-end close. No single decision was wrong. But stack enough of them and you cross a line you never notice at the time: the system stops being a system with some patches on it and becomes patches holding the shape of a system. Eventually you have so many band-aids that nobody dares pull one off, because nobody remembers what's underneath.

I've spent thirty years watching this from every seat. Early in my career it was the mission-critical system held together by a script written by someone who'd long since left the company — everybody knew it was bad, everybody agreed it should be fixed, and nobody ever fixed it. When I ran the Node.js Foundation, I watched enterprises adopt a brand-new runtime and immediately bolt it onto mainframes with integration layers that were fragile the day they shipped. And when I co-founded TriggerMesh, our entire serverless integration business existed because enterprises are, functionally, warehouses of systems that don't talk to each other — connected by glue code someone wrote, someone forgot, and someone now fears. Technical debt isn't an edge case in enterprise IT. It's the medium enterprise IT is made of.

Which is why computer use agents — AI that operates software with eyes and a cursor, the way a person does — matter for a reason that has nothing to do with booking flights or filling out forms. They're the first tool I've seen that attacks the debt without demanding the one thing decades have proven you'll never do: rewrite the system.

Put real numbers on it, because "technical debt" usually gets discussed as a vibe. McKinsey's CIO surveys put tech debt at 20 to 40 percent of the value of everything IT owns, with 10 to 20 percent of the budget meant for new products quietly leaking into servicing old decisions. Across the whole economy, the Consortium for Information & Software Quality pegs the accumulated principal on US software at roughly $1.52 trillion. And the interest is paid by your most expensive people: Stripe's Developer Coefficient study found developers spend about 42 percent of their week on maintenance, bad code, and debt.

Technical debt is the only debt where the interest compounds and the collateral is your ability to change. Every quarter it sits, the systems get older, the people who understood them get closer to retirement, and the workarounds grow workarounds of their own. McKinsey found that companies that actively manage the debt free up engineers to spend as much as 50 percent more of their time on work that moves the business. That's not a productivity tweak. That's a second engineering team you already pay for.

Because the honest options have all been terrible. Option one is the big rewrite, which every engineer wants and every scarred executive fears, because rewrites run long, run over, and sometimes take the company's institutional knowledge down with them. Option two is the API wrapper — modernize by exposing clean interfaces over the legacy core. Lovely when it works. But the systems carrying the most debt are precisely the ones that were never designed to expose anything: the green-screen claims system, the ERP customized beyond recognition in 2009, the vendor portal whose "integration strategy" is a login page. The only stable interface those systems have ever had is the screen, and the only client that could consume it was a human being.

So, option three: we tried to script the human. That was robotic process automation — RPA — and it recorded your clicks and replayed them, which worked right up until anything changed. A button moves, a field renames, and the bot dies; Deloitte and EY findings put the failure rate of RPA projects at roughly half. And that's the epitaph: RPA was one more band-aid. It didn't learn anything — it just connected the old system to the new one and replayed the same clicks until something moved. The automation meant to relieve technical debt became technical debt.

Which left most enterprises where they actually are today: quietly paying the interest. Marge in accounts payable knows the eleven-step sequence to force a stuck invoice through. The month-end close involves someone retyping figures from one system into another because the integration project got descoped in 2017. Nobody chose this. It's just what unpaid debt looks like at street level.

A computer use agent doesn't replay recorded clicks at fixed coordinates. It looks at the screen, understands what it's seeing, and pursues a goal — the way you would if I sat you in front of unfamiliar software and said "go find the overdue invoices." When the button moves, the agent finds the button, because it was never looking for pixel 400,300 in the first place. It was looking for "Submit." That single difference is what separates this from the RPA era: the brittleness that killed script-based automation was a failure of perception, and perception is precisely what these models now have.

And there's a second difference that matters even more for the debt itself: an agent learns while it's putting on the band-aid. RPA could only repeat what you recorded — it connected the old to the new and understood neither. An agent doing the work builds a working model of the process as a side effect. It can tell you where the duct tape is, which steps exist only to route around an integration nobody built, and what a cleaner path would look like. Run an agent through your ugliest workflow for a month and you don't just get the workflow done — you get a map of the debt underneath it, drawn by the one worker who never gets bored of the eleven-step fix. The band-aid starts writing the treatment plan.

And the capability is improving at a pace I haven't seen since the browser wars. On OSWorld — a benchmark that tests agents on real tasks in real software — Claude jumped from 42.2 percent to 61.4 percent in four months. The tooling has left the lab, too: Claude for Chrome now ships on every paid Claude plan, and you can demonstrate a task once and have the agent repeat it. ChatGPT agent comes with its own virtual computer. This isn't a research demo anymore. It's a feature of software your teams already pay for.

Map that onto the debt:

The swivel-chair workflow. Month-end close requires pulling numbers from the ERP, reconciling in a spreadsheet, and keying results into a reporting tool — three systems, zero integrations, one exhausted analyst. An agent runs the same workflow through the same UIs. The integration you never built stops being a gap, because the agent is the integration.

The system with no API. The claims platform from 2003 was never getting a REST interface; the vendor is gone. But it has screens, and the agent reads screens. Every legacy system already has an API — it's called the display. We just couldn't afford to call it until now.

The undocumented workaround. Marge's eleven-step invoice fix lives in Marge's head. Show it to an agent once, and two things happen: the task gets done without Marge, and — if you're disciplined — the procedure finally gets written down, because the agent's run log is the documentation. That's the sneaky-big win: computer use agents can convert tribal knowledge into explicit process as a byproduct of doing the work. That's debt reduction, not just debt service.

The migration you keep deferring. Legacy modernization is always urgent-but-never-done because the interest payments — human hours, delayed features, the one person who understands it nearing retirement — force the timeline. Put agents on the interfaces and the interest rate drops toward zero. The debt doesn't vanish. But debt that costs nothing to carry stops dictating your roadmap: you retire the old system on your schedule, for your reasons, instead of doing emergency surgery because the last person who understood it just gave notice.

Everything so far is about carrying the debt more cheaply. But the same wave of AI is also dropping the price of paying it down. Agentic coding tools — Claude Code, Codex, and their cousins — can read the legacy codebase nobody understands, explain what it does in plain English, write the tests it never had, and refactor it a piece at a time. The scariest part of every rewrite was never the new code; it was that nobody fully knew what the old code did. That's now a question you can ask.

Just as important: the pool of people who can do the fixing gets bigger. The analyst who runs the workflow — the person who actually knows the business rules — can now describe the fix in plain English and get working software, with an engineer reviewing instead of building from scratch. And quality goes up for the same reason: the expensive parts of good software — tests, documentation, consistent cleanup — become the cheap parts, because the agent doesn't get bored writing them. You don't need to make everyone a coder. You need the people who understand the work to be able to shape the software, and that line just moved.

That thread deserves more than two paragraphs, so it's next week's Deep Dive: vibecoding, but with a different slant than the demos you've seen. Not "anyone can ship an app in an afternoon" — how to use AI to build software that's not only modern, but maintainable by the people who understand the business, not just the software.

Three real problems.

First, 61.4 percent is a stunning trajectory and a lousy success rate. You do not point a six-out-of-ten agent at payroll and go to lunch. Today's honest pattern is human-supervised for anything consequential, autonomous only for the low-stakes and reversible.

Second, security. An agent that can operate any screen with your credentials is a new attack surface, and prompt injection — malicious instructions hidden in the very pages the agent reads — is the reason Anthropic spent a year piloting Claude for Chrome with a small cohort before opening it to all paid users. Treat an agent's logins the way you'd treat a new hire's: limited access, watched, easy to shut off.

Third — and this is the critique I take most seriously — refinancing debt can entrench it. If the agent runs the AS/400 forever, do you ever retire the AS/400? Maybe not, and maybe that becomes its own pathology: a company where nothing is ever modernized because everything is agent-wrapped. The answer is the same as with any refinancing: the discipline lives in governance, not the instrument. Wrapping a system should come with a review date, or you've traded a debt you could see for one you can't.

Misstep 1: Treating agents like RPA 2.0 — The first instinct of every automation team is to script the agent: exact steps, exact screens, exact order. Do that and you've rebuilt the brittleness you were escaping, at a higher price. Give agents goals and guardrails, not choreography.

Misstep 2: Starting with the highest-stakes process — Yeah, the wire-transfer approval queue is your most painful workflow. It is also how you end up as the case study nobody wants to be. Start where errors are cheap and reversible — report pulls, data reconciliation, vendor portal downloads — and earn the track record that justifies moving up.

Misstep 3: Skipping the documentation dividend — If agents do the work but nobody captures how, you've automated your tribal knowledge instead of writing it down. Make a written procedure a required output of every agent deployment — the agent's run log is most of the way there, and the document outlives the tool.

Misstep 4: Letting the wrap become the strategy — An agent-wrapped legacy system with no retirement plan is technical debt with better makeup. Every wrapped system needs an owner, a review date, and an explicit decision — retire, replace, or knowingly keep — or you'll wake up in 2030 with a portfolio of zombie systems kept alive by agents nobody remembers configuring.

// Key Takeaways

Inventory your technical debt like a CFO, not a CTO. You can't refinance what you haven't priced, and McKinsey's numbers say it's bigger than your gut estimate. List the systems, the workarounds around them, and the human hours each eats per month — that hour count is your interest rate.

Pilot one copy-paste workflow this quarter. Pick a low-stakes, high-frequency process that crosses systems, and put an agent on it with a human checking the output. The tooling is already on the plans you pay for.

Make documentation a mandatory byproduct. No agent deployment counts as done until it produces a written procedure a human can follow. You're not just automating the task — you're recovering knowledge that currently lives in people's heads.

Put a review date on every wrapped system. Any system an agent operates gets an annual retire-replace-or-keep decision on the calendar, so the eraser never becomes the excuse.

The homework fits on one page. What debt service costs you today — the 42 percent of developer time, the workaround hours. The three ugliest retype-it-between-systems workflows in the company. And a pilot small enough to approve this month, funded from the interest rather than new money, measuring one thing: hours of human busywork eliminated per month.

For thirty years, the deal with legacy systems was binary — rewrite them or keep paying. Computer use agents just introduced a third option, and it's the first one that doesn't require you to be brave: stop paying, without rewriting a line. The debt's still on the books. It just finally stopped charging interest. And in my experience, that's the moment you actually get to decide your own roadmap again.