Every established business in Northeast Indiana carries a version of the same quiet burden: a piece of aging software that nobody wants to touch. The custom order-entry app a former employee wrote in 2011. The ERP module holding your shop floor together with duct tape and tribal knowledge. The scheduling system your home-services crews depend on that breaks if you look at it wrong. For years, the honest answer to “should we modernize that?” was not worth the risk — too expensive, too fragile, too likely to take down the business for a week.
That math is inverting in 2026. At VB Transform 2026, Instacart CTO Anirban Kundu told the audience something that would have sounded reckless two years ago: his engineering organization has largely stopped worrying about technical debt. Not because they cleaned it all up, but because AI coding agents now regenerate so much of the codebase that dead and half-active code simply gets dropped and rebuilt. “We don't care about tech debt anymore,” Kundu said — an offhand line that describes a genuine shift in the economics of legacy software.
We think this is one of the most important — and most under-discussed — stories for owner-operated businesses in Fort Wayne and DeKalb County. For a decade, legacy software was a growth ceiling. AI Employees are turning it into a head start. Here's what actually changed, what it does and doesn't mean, and how to capture the upside without trading one kind of debt for another.
Key Takeaways
- The cost of touching legacy code is collapsing. AI coding agents can now read, document, test, and refactor old systems at a fraction of the old price — work that was previously “too expensive to justify.”
- Big companies are already banking the savings. Morgan Stanley's internal AI tool processed 9 million lines of legacy code and saved an estimated 280,000 developer hours; Instacart says it has stopped treating tech debt as a permanent liability.
- This is not a magic delete button. AI accelerates modernization; it does not remove the need for human judgment on compliance, latency-sensitive, and business-critical systems.
- AI also creates new kinds of debt. Prompt, retrieval, and evaluation debt are real — but they're a separate problem from the traditional legacy code AI is now good at paying down.
- Custom beats generic here. Touching proprietary, undocumented business code safely requires an AI Employee that understands your systems — not an off-the-shelf chatbot.
- Governance is non-negotiable. A refactor that leaks data or silently changes behavior is worse than the debt you started with.
What Did Instacart's CTO Actually Say About Tech Debt?
The headline is deliberately provocative, so it's worth being precise about the underlying claim. Kundu's point at VB Transform was not that technical debt vanished — it's that the relationship his teams have with it changed. According to VentureBeat's reporting, Instacart now generates or regenerates code on newer projects so frequently that in the vast majority of cases, engineers don't read the code line by line anymore; agents handle the boilerplate and the bulk generation. When code is cheap to rebuild, code that isn't actively used just gets dropped rather than carefully maintained forever.
Crucially, Kundu was honest about the exceptions. The remaining slice of work — legacy, compliance, and latency-sensitive systems — still demands careful human attention. Instacart's answer is a program it calls Atoms: breaking monolithic systems down into smaller, cleaner, more modular pieces, then rebuilding them in a modern architecture. That's the real story. Not “AI deleted our tech debt,” but “AI made it economical to finally break down the monoliths we'd been too scared to touch.”
VentureBeat's article is behind aggressive bot protection and we could not fetch it directly, so we corroborated the specifics — Kundu's name, the framing, the Atoms program, and the shift away from manually reading code — against independent trade coverage of the same talk before publishing. We'd encourage you to treat any single-executive anecdote as a signal, not a guarantee. What makes it credible is that the pattern shows up everywhere once you look.
Why Was Legacy Software Debt Untouchable Until Now?
To understand why 2026 feels different, you have to remember why legacy modernization was such a losing bet for so long. Technical debt isn't just messy code — it's the accumulated cost of every shortcut, every “we'll fix it later,” every developer who left without documenting their work. McKinsey has estimated that technical debt can amount to a meaningful share of a company's entire technology estate — a tax you pay every year in slower changes, more outages, and higher maintenance bills.
For a mid-market business, the modernization math was brutal on both sides of the ledger. The old system was a liability, but replacing it meant hiring scarce engineers to reverse-engineer undocumented code written by people who were long gone, rebuild it without breaking the business that ran on it, and pray the migration didn't corrupt a decade of data. The safest financial decision was almost always to do nothing and keep paying the maintenance tax. That's how a 2011 order-entry app survives to 2026: not because it's good, but because touching it was scarier than living with it.
The bottleneck was never ambition — it was the human cost of understanding old code before you could safely change it. Every modernization estimate had the same hidden line item: weeks of a senior engineer's time spent just reading, tracing, and re-deriving what the software already did, before a single improvement could be made. For a business without a large in-house development team, that discovery cost alone was often a deal-breaker. And understanding undocumented legacy code is exactly the kind of draining, high-volume, pattern-matching work that AI agents turn out to be unusually good at.
How Do AI Employees Actually Pay Down Legacy Code Debt?
This is where the abstract promise gets concrete. The single most valuable thing an AI Employee does with legacy software isn't writing new code — it's explaining the old code. Morgan Stanley built an internal tool called DevGen.AI on top of large language models specifically to read languages like COBOL and PL/I and translate them into plain-English specifications engineers can act on. As reported by Slashdot and other outlets, the tool processed roughly 9 million lines of legacy code and saved an estimated 280,000 hours of engineering time in its first months. Notice the design choice: it doesn't blindly auto-rewrite. It makes the old system legible so humans can decide what to rebuild.
That legibility is the foundation for the rest of the modernization pipeline. Once an AI Employee can document a system, it can also generate characterization tests to lock in current behavior, propose a modular refactor, and translate the logic into a modern stack. Thoughtworks has documented this “understand, then refactor” workflow as one of the highest-leverage uses of generative AI in engineering. And the productivity numbers on the routine work are real: GitHub's research on Copilot found developers completed routine coding tasks meaningfully faster with an AI assistant — the kind of grunt work that dominates a modernization project.
The reason an AI Employee — a persistent, custom agent that knows your systems — matters here, rather than a generic chatbot, is that proprietary business code has no public documentation for a model to lean on. As we argued in Why Generic AI Fails (And Custom AI Employees Don't), a general-purpose assistant can help with a snippet, but modernizing your undocumented order system requires an agent grounded in your codebase, your data model, and your business rules. The most advanced versions of this are agents that improve their own approach over time, a pattern we covered in AutoAgent and the Rise of Self-Optimizing AI Employees. This agentic approach is exactly the direction the largest advisory and engineering organizations are betting on for enterprise infrastructure, too — a signal that it's a mainstream trajectory, not a fringe experiment.
Here's how the two approaches to a legacy modernization project compare:
| Dimension | Traditional Modernization | AI Employee–Assisted Modernization |
|---|---|---|
| Understanding old code | Weeks of manual reverse-engineering | Hours to auto-document and summarize behavior |
| Test coverage | Written by hand, often skipped under deadline | Characterization tests generated from existing behavior |
| Cost to attempt | High enough that most projects never start | Low enough to pilot on one subsystem first |
| Primary human role | Deciphering and rewriting line by line | Reviewing, deciding, and validating agent output |
| Biggest risk | Migration breaks the business | Unreviewed AI changes alter behavior silently |
But Doesn't AI Create Its Own New Debt?
Yes — and we'd be lying to you if we pretended otherwise. This is the honest counterweight to the optimism, and it's important enough that we wrote a whole companion piece on it: The Hidden AI Debt Quietly Wrecking Your AI Employees covers the new categories of debt AI introduces — prompt debt, retrieval debt, and evaluation debt — the tangled, undocumented AI configurations that rot just like old code did.
There's a second, subtler risk worth naming. As Forbes' Technology Council has warned, you can trade “code only the departed developer understood” for “code only the AI understands” — machine-generated systems so large and fast-moving that no human on your team can fully reason about them. If AI regenerates your codebase weekly but nobody can explain why it made a given decision, you haven't eliminated risk; you've relocated it.
So the balanced take is this: on the legacy side of the ledger — traditional, human-written, undocumented code — the economics have genuinely tipped in your favor. On the AI side of the ledger, a new discipline is required to keep the new systems auditable. Both things are true at once. The businesses that win in 2026 will pay down old debt aggressively and refuse to let new debt pile up unmanaged — which is why we treat governance and human review as part of every modernization, not an afterthought. If your organization hasn't closed that loop yet, start with The AI Governance Gap: What Fort Wayne Owners Must Fix in 2026. And because AI-driven refactoring can quietly run up its own compute bill, pair modernization with cost discipline — the playbook in Fort Wayne: Cut AI Costs Without Cutting Capability applies directly.
What Does This Mean for Fort Wayne and Northeast Indiana Businesses?
The companies making headlines here are giants — Instacart, Morgan Stanley — but the opportunity is arguably larger for established Northeast Indiana operators, precisely because you've been sitting on frozen debt the longest. Fort Wayne is a manufacturing and professional-services town, and that means aging line-of-business software everywhere you look.
Think about the concrete cases. A DeKalb County manufacturer running a decade-old ERP customization that ties shop-floor scheduling to inventory — historically untouchable because the consultant who built it is gone. A professional-services or financial firm in Allen County with a custom client-intake app nobody dares modify during tax season. A home-services company whose dispatch and scheduling stack is brittle enough that “don't touch it” is an unwritten company policy. In every one of these cases, the blocker was the same: understanding the system well enough to change it safely cost more than living with the pain.
That's the exact cost that's collapsing. An AI Employee can spend a weekend documenting what that ERP customization actually does, generate tests that capture its current behavior, and hand your team — or ours — a clear, low-risk path to modernize it one module at a time. You don't have to bet the business on a big-bang rewrite. You pilot on one subsystem, prove the pattern, and expand. And because the discovery work is now cheap, you can finally answer questions that used to be unanswerable: which of these old systems is actually costing us the most, and which one is safest to modernize first? For a Midwest business that has watched modernization stay perpetually out of reach, that shift from “someday, maybe” to “this quarter, safely” is the real headline — and the operators who move first will spend the rest of the decade building on modern systems while their competitors keep paying the maintenance tax.
Turn Frozen Debt Into a Head Start
Legacy software you've been afraid to touch is no longer a permanent tax — but capturing the upside safely takes more than turning a generic AI tool loose on your codebase. It takes an AI Employee that understands your systems, characterization tests that protect current behavior, and governance that keeps every change reviewable.
That's exactly what we build. Cloud Radix deploys AI Employees for Fort Wayne and Northeast Indiana businesses that can document, test, and modernize legacy systems behind a secure AI gateway — with the oversight to make sure a refactor never leaks data or silently changes what your software does. If there's a piece of software your team has been avoiding for years, let's talk about turning it from a liability into an advantage.
Frequently Asked Questions
Q1.Can AI really modernize legacy business software safely?
AI is very good at the hardest part of modernization — understanding undocumented old code and translating it into plain-English specs and tests. But “safely” depends on human review. The proven pattern is to let an AI Employee document and test a system's current behavior first, then modernize one module at a time with a person validating each change, rather than auto-rewriting everything at once.
Q2.Did Instacart's CTO really say the company stopped worrying about tech debt?
At VB Transform 2026, Instacart CTO Anirban Kundu said his teams have largely stopped treating technical debt as a permanent liability, because AI agents regenerate so much code that inactive code simply gets dropped and rebuilt. He was clear that legacy, compliance, and latency-sensitive systems still require careful human attention — so it's a shift in economics, not a claim that debt disappeared.
Q3.How much can AI actually save on legacy code work?
Results vary by system, but the scale can be significant: Morgan Stanley reported that its internal DevGen.AI tool processed about 9 million lines of legacy code and saved an estimated 280,000 developer hours. The bigger win for most mid-market firms is that modernization projects that were never financially viable to start now are.
Q4.Doesn't using AI just create new kinds of technical debt?
It can. AI introduces prompt debt, retrieval debt, and evaluation debt, and it can produce machine-generated code that's hard for humans to fully understand. That's a real, separate problem — we cover it in depth in our companion post on hidden AI debt. The key is to pay down legacy debt while applying governance and human review so you don't quietly accumulate new debt in its place.
Q5.Why can't I just use a generic AI chatbot to fix my old code?
Proprietary business software has no public documentation for a general model to draw on, so a generic chatbot can help with isolated snippets but struggles with your specific systems, data model, and business rules. Modernizing undocumented code reliably requires a custom AI Employee grounded in your actual codebase and workflows.
Q6.Where should a Fort Wayne business start with AI-assisted modernization?
Start small and prove the pattern. Pick one aging, well-bounded subsystem — a scheduling module, a custom intake app — and have an AI Employee document its behavior and generate tests before changing anything. Once you've validated the low-risk workflow on one system, you can expand it across the rest of your legacy stack with confidence.
Sources & Further Reading
- VentureBeat: venturebeat.com/orchestration/instacarts-cto-says-ai-made-the-company-stop-worrying-about-tech-debt — Instacart's CTO says AI made the company stop worrying about tech debt.
- McKinsey & Company: mckinsey.com/capabilities/quantumblack/our-insights/ai-for-it-modernization-faster-cheaper-and-better — AI for IT modernization: Faster, cheaper, and better.
- Slashdot: developers.slashdot.org/story/25/06/04/1233253 — Morgan Stanley says its AI tool processed 9 million lines of legacy code and saved 280,000 developer hours.
- GitHub: github.blog/2022-09-07-research-quantifying-github-copilots-impact-on-developer-productivity-and-happiness — Research: quantifying GitHub Copilot's impact on developer productivity and happiness.
- Thoughtworks: thoughtworks.com/insights/blog/generative-ai/generative-ai-refactoring — Generative ref-AI-ctoring: Solving tech debt in the age of AI.
- Forbes Technology Council: forbes.com/councils/forbestechcouncil/2026/03/24/the-new-tech-debt-codebases-only-ai-understands — The New Tech Debt: Codebases Only AI Understands.
Turn Legacy Software Into an Advantage
If there's a system your team has been afraid to touch for years, let's scope a low-risk modernization — documented, tested, and governed by an AI Employee that understands your business.
