Every engineering org has that one service nobody wants to touch: Java 8 on Spring Boot 2, a .NET Framework 4.8 app that only builds on a Windows box, a COBOL job that closes the books overnight. Everyone knows how to fix it. Nobody schedules it, because it always loses to feature work in planning.
That math changed this year on the pricing side. AWS now bills its agentic code transformer at $0.035 per agent minute, and its own numbers show a roughly 17,000-line Java version upgrade taking about 72 agent minutes, or $2.52. I wrote up the full comparison on DevToolLab, but the short version: when a migration is metered by the minute instead of quoted in engineer-weeks, running it on a low-priority internal service stops being a budget request and becomes a Tuesday afternoon task.
Two techniques, and they are not interchangeable
Everything in this space is either deterministic or agentic, and mixing up which one you need is the most common way these projects stall.
Deterministic engines parse code into a typed tree and apply a rule to it. OpenRewrite builds what it calls a Lossless Semantic Tree; ast-grep works off tree-sitter syntax trees. Same input, same output, every run, and nobody has to review 4,000 files for surprises because there aren't any. The catch is that a rule only covers what its author anticipated.
Agentic tools hand the job to a model with tool access: read the file, edit it, run the build, read the error, retry. They handle the long tail no recipe predicted, at the cost of nondeterminism and a diff that genuinely needs a human reader. The tools that win in 2026 run the free deterministic pass first, then send only the leftovers to an agent. Codemod (formerly jscodeshift's successor project) explicitly markets itself as compiler-aware steps plus AI steps for exactly this reason.
What's actually worth installing
OpenRewrite is the closest thing this category has to a standard - Apache 2.0, over 2,800 open recipes, and because its tree carries type information it can tell your Result class apart from a dependency's Result class, which plain regex never can. I ran its UpgradeToJava21 recipe against a Java 8 Maven project: 87 seconds cold, 18 seconds warm, and it printed "Estimate time saved: 15m." It touched only build config, not a single line of Java source - which is correct behavior, not a bug, but it surprises people expecting a magic wand.
ast-grep is what you reach for when you need a structural find-and-replace across a big tree in the next 30 seconds. Rust, MIT licensed, 20+ languages via tree-sitter. I learned the hard way that its $A pattern matches exactly one argument: running -p 'new Buffer($A)' silently skipped new Buffer(payload, 'utf8') and still printed a success message. Use $$$ARGS for variable-length argument lists, and always sanity-check the match count against a plain grep -c.
Codemod hosts the JS ecosystem's official upgrade scripts for React, Node, Express, Nuxt and more, written by the frameworks' own maintainers. Its jssg runtime (the ast-grep-powered successor to jscodeshift, shipped February 2026) means the same transform can now target any language ast-grep parses, not just JavaScript.
AWS Transform is the specialized-agent approach: a mainframe agent for COBOL on z/OS, a Windows agent for .NET Framework, a custom agent for everything else. Assessment and the mainframe/Windows/VMware agents are free; only the custom transformation agent bills, and only while it's actively reasoning or editing, not during builds or idle time.
GitHub Copilot app modernization is the lowest-friction option because it runs where your code already lives - VS Code or Visual Studio, no new vendor contract, included in your existing Copilot plan. It covers the real-world Java upgrade path (8 to 11 to 17 to 21, Spring Boot 2 to 3, javax to jakarta) and iterates on build errors until the project compiles.
vFunction solves the step before migration: deciding what to touch. It watches a live JVM or CLR at runtime plus static analysis to map the domains hiding inside a monolith, so an agent isn't rewriting a service based on a guess about the call graph.
The failure mode nobody warns you about
Silent partial matches. Both the $A and $$$ARGS runs in my ast-grep test exited with status zero and printed "Applied N changes." Nothing in the output tells you that N is wrong. This applies to every pattern-based tool in this category - always diff your match count against a plain grep for the same symbol before trusting a bulk rewrite. DevToolLab's full writeup has the exact commands and a step-by-step first migration you can run this afternoon, plus a comparison table across pricing and language coverage for all eight tools.
Test coverage is the other real constraint. Every tool here rewrites code faster than a weakly tested service can validate it - if you're at 20% coverage, the migration tooling was never the hard part.
How I'd pick
Java or Spring shop: start with OpenRewrite, it's free and the recipes for your exact upgrade path probably already exist. JS/TS: check Codemod's registry before hand-writing a transform. Mainframe: AWS Transform if you're headed to AWS, watsonx Code Assistant for Z if the code has to stay on IBM Z. Hundreds of repos: Moderne. Don't know what to migrate yet: vFunction or AWS Transform's free assessment agents.
If you're validating request bodies or POJOs as part of any of this, DevToolLab's JSON to Java Class Converter is a quick way to generate typed classes when you're replacing legacy data structures, and the NPM Package Info tool is worth a look before running a JS framework codemod blind.
Top comments (0)