Technical debt management at scale gives developers their time back
Contents
- Automated refactoring changes code across every repository at once.
- Moderne runs technical debt work across the whole organization.
- Can technical debt be fixed automatically without manual review?
- Coding agents can take on debt work through Moderne.
- Teams that automate debt work get years of developer time back.
- Recipe telemetry shows how much developer time comes back.
- How do you measure the productivity gained from removing technical debt?
- A maintained codebase keeps developers building.
Technical debt management at scale means fixing debt automatically across every repository, instead of one ticket at a time. OpenRewrite recipes encode a fix once, such as a framework migration or a vulnerable dependency. Moderne runs that fix across an organization’s code and opens the pull requests, so developers and their agents spend their time on product work.
Developers make the same trade every week, and coding agents haven’t made it go away. Do they point the agent at the security vulnerability or have it work on a feature? Do they start the framework migration without knowing how far it reaches and trust an agent to work out the upgrade path separately in every repository?
Between mandates from platform and security teams and the daily alerts from code scanners, a team could spend all its time paying down debt and never finish. With agents writing more code, there’s more of it to keep current. When SAP surveyed 3,754 of its developers, technical debt was the second most-cited productivity blocker, after poor or missing documentation (SAP’s refactoring program).
Paying down debt doesn’t have to cost an hour of feature work for each hour it takes. Most of it can be automated with agents driving deterministic recipes instead of editing every file by hand.
Automated refactoring changes code across every repository at once.
Automated refactoring writes a change once and applies it wherever the code needs it. The traditional way is one repository at a time. A developer clones it, opens it in the IDE, makes the change, and pushes it back. A coding agent working alone follows a similar loop, reading files and editing text in each repository and working out the fix from scratch every time. Neither approach scales to a large codebase.
Once code ships, other teams depend on it. Updating a dependency version, replacing one API call with another, or adding an argument can touch dozens of places in one repository and hundreds across others, some of which nobody on the team knows about.
Many of these changes follow patterns you can write down. Moving from JUnit 4 to JUnit 5, for example, means replacing the expected exception on the @Test annotation with an assertThrows call. That change can be written once and applied to working code everywhere.
@Test and into an assertThrows call, formatted to match the existing code.Two things make this work at scale. The Lossless Semantic Tree (LST) is a full-fidelity model of the code that keeps type attribution and formatting. OpenRewrite recipes are programs that search and transform it. Each recipe run produces code changes you can commit, along with data about the codebase for impact analysis.
Once a refactoring is written as a recipe, it can run on any codebase that needs it, from a single edit to a whole framework migration. OpenRewrite is the open source framework behind them, and developers and agents use it to search, fix, and analyze code.
Recipes can combine other recipes into a larger one, which is how framework migrations and large vulnerability fixes are built. A Spring Boot migration recipe includes the migrations from earlier versions and their dependency changes, so teams can start from whatever version they’re on (see the Spring Boot 4 migration guide). The OWASP Top Ten recipe groups fixes for the most common vulnerability categories so they can run across a codebase in one pass. Teams can also write recipes for their own libraries and frameworks.
Moderne runs technical debt work across the whole organization.
Moderne builds and stores an LST for every repository, so recipes run against all of an organization’s code at once instead of one repository at a time. Platform teams and developers use it to see the state of their code, analyze the impact of a change, run the change across repositories, and track the rollout.
DevCenter is the dashboard for that work. Teams can follow a migration campaign, see where security exposure sits, and open the code visualizations that show where to start.
Can technical debt be fixed automatically without manual review?
Not entirely, and it shouldn’t be. Recipes are deterministic, so the same input always produces the same change, and you can review a run’s results across every repository before committing anything. Teams still review the pull requests, but they’re reviewing one tested recipe applied consistently instead of hundreds of hand edits.
Coding agents can take on debt work through Moderne.
Coding agents such as Claude Code or Copilot can work through the small refactors on a debt roadmap by using Moderne. The agent picks the recipe that fits the task and runs it, and the recipe makes the same edit in every repository. A leading global bank works this way, with agents planning and coordinating changes and recipes making the edits.
Agents also need to know where the debt is. Moderne Prethink writes code quality metrics into each repository, including complexity scores and a ranking of untested high-risk methods, so an agent can see what to fix first.
Teams that automate debt work get years of developer time back.
- A leading global bank estimates it saved 70 developer-years: 30 each on Java and Spring upgrades, and 10 on OWASP Top 10 remediation, by running OpenRewrite recipes on Moderne across 50,000 repositories.
- Squarespace upgraded more than 200 backend services from Spring Boot 2.x to 3.3 in under a year with Moderne. Its previous Spring Boot upgrade took four years.
- Choice Hotels moved more than 500 services from Java 8 to Java 25 in one migration with Moderne. Fixing Log4j once took six weeks of all-hands engineering, and the team now opens 200 remediation pull requests in an hour.
Recipe telemetry shows how much developer time comes back.
Each recipe carries an estimate of the developer time it saves per change, and Moderne totals it for every run. The Moderne CLI’s telemetry adds which recipes teams commit and who commits them, and you can feed it into your own BI tools. Morgan Stanley measures debt work by the developer capacity it recovers (see how Morgan Stanley is tackling tech debt at scale).
Watch 10 Lessons for Enterprise Code Modernization with OpenRewrite & Moderne:
How do you measure the productivity gained from removing technical debt?
Track the estimated developer time each recipe run saves, and check it against what actually gets committed. Because the Moderne CLI’s telemetry records both recipe runs and commits, you can also measure the time from a recipe’s first run to its first commit in each repository, which shows how quickly teams adopt a fix.
A maintained codebase keeps developers building.
Code that isn’t maintained collects vulnerabilities and costs more to change every year. Plus, it locks teams out of newer frameworks and tools. Treating debt as continuous, automated work keeps the codebase ready for what comes next.
Watch Speed Is Easy, Trust Is Hard: AI’s Real Impact on Developer Productivity:
To see recipes run on open source code, try the Moderne Platform. To try the same recipes with a coding agent, start the self-paced evaluation, or book a demo to see Moderne on your own repositories.
Originally published
