We removed 12,475 defects from a critical business application. Here's the diff.
Not suggestions — actual patches, reviewed and merged like any pull request.
Same codebase in, same patch out, every run — on your own machine.
On a single client's critical business application — the whole story is further down this page.
12,475
Defects fixed
-17
Sonar debt removed (%)
< 1
Hour per run
100,000
Manual work avoided (€)
This is what a fix looks like
No summary of what was « probably » changed. The patch is the deliverable, and you read it before it is merged.
Twenty-four rules, each one a transformation documented down to its limitations.
Exception handlers should preserve the original exception
Before
try {
/* ... */
} catch (Exception e) {
LOGGER.info("context");
}After
try {
/* ... */
} catch (Exception e) {
LOGGER.info("context", e);
}Local variables should not be declared and then immediately returned
Before
int r = compute();
return r;After
return compute();The Comutitres case
Passenger transport — core business application
The goal was to make a critical application supportable again, and to bring its total cost of ownership back under control.
The codebase carried thousands of defects of the kind nobody ever schedules. Each one is two to ten minutes of work. Together they are a project no one can justify funding, so they stay.
Indepth removed 12,475 of them, in runs of less than an hour each — 17% of the whole technical debt Sonar had identified on the application.
The project showed that automatic remediation holds up at the scale of an entire information system, and not only on a demonstration repository: massive deleveraging, over a short period, with the reliability required by a production application.
Indepth allowed us to reduce the technical debt of our information system very quickly...
Original : « Merci Indepth nous a permis de réduire la dette technique de notre SI très rapidement... »
Beyond the speed, the reliability and the savings Indepth generates, the way JAVAPERF Consulting adapts to the client's context, and their advice, let you build a pragmatic path for reducing technical debt.
Original : « Au delà de la rapidité, fiabilité et des économies générées par Indepth, l'adaptation au contexte du client et les conseils de JAVAPERF Consulting vous permettent de construire une trajectoire pragmatique de réduction de la dette technique. »
Isn't this what an LLM agent does?
Use your coding agent for the work that needs judgment: designing an API, untangling an abstraction, writing the test you had not thought of.
Use Indepth for the other twelve thousand changes. The mechanical ones, where you do not want creativity.
The same input gives the same patch
On every run, on every machine, in your CI. There is no temperature setting, and no reason to run it twice to see what you get.
It resolves your code, it does not guess it
Types, scopes and symbols come from a real parser and symbol solver working against your actual classpath — not from a probability distribution over tokens.
Priced per fix, not per token
One credit per fix. You know what the campaign costs before you start it, and the bill does not change because a file happened to be long.
It runs on your machine, and it keeps a record
Indepth analyses and rewrites your project locally — your codebase is never uploaded, and no model is trained on it. What does leave is the history of the changes themselves: each fix, before and after, sent to the Indepth server so your teams can review the whole campaign afterwards and learn from it.
Under the hood
We do not just use the parser. We maintain it.
Indepth does not match your source with regular expressions. It builds the abstract syntax tree a compiler would build, resolves every symbol against your real classpath, rewrites the tree, and prints it back while preserving your formatting.
That engine is JavaParser, the library behind a large part of the Java tooling ecosystem.
Our CTO is one of its maintainers and its third most active contributor of all time, with more than 1,400 commits since 2019.
So when Indepth meets a construct nobody had handled before, the fix does not wait for someone else's release. It goes into the parser.
1,400+ commits to JavaParser
Third most active contributor to the project, still committing today.
Full symbol resolution
A transformation is only applied when the types involved have actually been resolved. When they cannot be, Indepth leaves your code alone.
Your formatting survives
Only the lines that had to change, change. The review stays small enough to actually be done.
What does Indepth do?
Analyze
Indepth scans your codebase for bugs and issues and simply evaluates fixes for the changes you want to make to the code.
Transform
Automate technical debt fixes and quickly improve code quality.
Share
Share code changes and best development practices.
Why choose Indepth?
Cost-effective license for companies
With pay per use license you set your own budget. There are no overruns.
Active support
Indepth can support your own requirements after study by our lab.
Everything is accessible regardless of the license
All code transformation rules are available.
Make your code green
We can help you to improve the performance of your applications.
Simple and lightweight
Give a second life to your applications
We offer flexible, simple and effective software to very quickly eliminate a large number of issues in your applications.
You can share changes between teams to promote best development practices.
Quick Start
It couldn't be easier.
Download the Indepth client app, install and run it.
On first use, you simply need to register and configure a project.
Then choose the fix to apply and start the execution.
Run it on your own codebase
The free plan has every rule, no time limit and no user limit. Point it at your project and read the report before you spend a single credit.