Web Directions Year round learning for product, design and engineering professionals

Legacy Software + Agentic Discovery

Legacy codebases are nightmares in the truest sense. Thousands of lines of code written by people who've left. Business logic embedded in places it has no right to be. Dependencies no one fully understands. Documentation that's either nonexistent or spectacularly out of date. When you need to change something, you're genuinely afraid—because you don't know what else might break.

This is the situation most organizations are actually in. Not greenfield projects with clean architecture and fresh APIs. Real codebases. Old systems that somehow still power critical operations. Systems that need to be maintained, debugged, occasionally improved. Systems where understanding what's actually happening is the first and biggest challenge.

This is where AI agents can do something genuinely useful that humans struggle with: autonomous discovery. Point an agent at a legacy codebase with a specific goal—understand how customer payments are processed, map the dependencies in this service, figure out what this module actually does—and watch it work systematically through the code. Not to execute commands or make changes, but to understand and document.

The agent can read code across the entire system, identify patterns, trace how data flows, find the places where business logic lives. It can ask clarifying questions when it hits ambiguity. It can generate documentation that's actually tied to the code, rather than the hand-wavy descriptions that get outdated the moment anything changes.

What's powerful about this is the speed and breadth. A human engineer diving into an unfamiliar codebase spends weeks understanding it. They hit dead ends. They miss connections. They document some things and forget others. An agent can systematically work through the entire system, cross-referencing, finding patterns, generating comprehensive maps of dependencies and logic.

The output—documentation that reflects the actual code, not someone's memory of it—becomes invaluable. It's the foundation for modernization. It's the knowledge transfer when people leave. It's the artifact that makes future changes less terrifying.

There's a secondary benefit here. When someone tries to modernize or refactor legacy code, their biggest fear is breaking something they don't understand. Comprehensive documentation of what the system actually does reduces that fear dramatically. You can understand the requirements before you change the implementation.

This also transforms the economics of technical debt. Currently, legacy code feels like a burden—something that needs to be maintained, minimized, eventually replaced. With automated discovery tools, legacy code becomes a known quantity. You can work with it more confidently. You can extract value from it longer. You can modernize incrementally rather than requiring a complete rewrite.

The constraints are real though. An agent is only as good as the code it's reading. If the code is genuinely incomprehensible, no agent will fix that. If there's no way to understand what's supposed to happen, generating documentation of what actually happens only gets you halfway there. And agents can hallucinate, misinterpret, miss important context.

But for the common case—codebases that work but aren't well understood—agentic discovery is a genuine breakthrough. It means the knowledge locked in your codebase can be extracted, documented, and made available to your team. It means legacy systems become less like mysterious black boxes and more like documented systems that humans can navigate and modify.

Chris Rickard is exploring how this plays out in practice at AI Engineer Melbourne 2026 on June 3-4, showing how agents can transform how organizations work with and understand their existing systems.