Welcome to your journey into automated code refactoring at scale! In this course, you'll discover how OpenRewrite and Moderne can help you make large-scale code changes safer, faster, and more reliable. Whether you're new to automated refactoring or looking to deepen your expertise, you're in the right place to learn how to streamline your team's development workflow and unlock the power of modern code transformation.

This course is organized into several key modules to guide your learning journey. We'll start with an overview and CLI setup, move into composing and customizing recipes, then explore data tables and visualizations, and finally, learn how to track progress and manage changes with DevCenter.

Each module builds on the last, giving you a clear path from foundational concepts to advanced applications. By the end, you'll have a comprehensive understanding of how to leverage OpenRewrite and Moderne for your team's needs.

Expand each goal to see what you'll accomplish in this course and how it will help you in your day-to-day work.

Most modernization efforts move one repository at a time. A few get migrated, but the rest of the organization stays on the old stack, accumulating technical debt and supporting multiple versions at once.

Moderne's approach runs horizontally instead. The same recipe runs across every repo at once, which is how organizations get 80% of the way there across their whole codebase instead of stalling at only a few apps.

Understanding how code can be represented is crucial for effective automated refactoring. Below, we compare three approaches, text-based search, Abstract Syntax Trees (ASTs), and Lossless Semantic Trees (LSTs); highlighting their strengths and limitations.

LSTs also cover more than your application code.

Build files, configuration, and other non-code files are parsed too, so a single effort can span dependencies, build plugins, CI configuration, and code in one pass. Because an LST is a rich, queryable model of your codebase, it is as useful for analyzing what you have as it is for changing it.

Recipes and LSTs

Recipes are at the heart of OpenRewrite's automation capabilities. A recipe is a deterministic program that defines what to find in your code and how to change it.

Recipes leverage the LST to make targeted, context-aware modifications, ensuring that changes are both accurate and stylistically consistent.

For example, a recipe can automatically update test annotations and restructure code to use new APIs, all while preserving the original formatting and intent.

This approach enables organizations to perform complex migrations and upgrades with confidence and minimal manual effort.

Automating code changes across multiple repositories can be a daunting, time-consuming task when done manually. The Moderne CLI lets you perform safe, repeatable, large-scale code transformations, reducing risk and freeing up developer time. In this lesson, you'll set up the Moderne CLI, connect it to the Moderne Platform, and run recipes across your codebase, gaining hands-on experience with automated refactoring at scale.

When you run a recipe using the Moderne CLI, the tool analyzes your codebase and applies the specified transformations according to the recipe’s logic. The CLI generates a diff for each change, allowing you to review exactly what will be modified before committing. You can choose to apply the changes directly, review them in detail, or roll them back if needed, giving you full control over the transformation process.

Explore each tab to learn about different ways to run recipes with the Moderne CLI and Platform. Each scenario highlights a unique workflow, its benefits, and practical tips for success.

Modern codebases are constantly evolving, and organizations often need to migrate frameworks, update APIs, or enforce new coding standards across many projects. Being able to compose and customize code transformations is essential for meeting these real-world needs.

In this lesson, you'll learn how to use the Moderne recipe builder to create and tailor declarative recipes, giving your team the power and flexibility to automate migrations and refactorings at scale.

Declarative recipes aggregate and configure existing recipes, letting you fill in parameters and snap them together like building blocks. Their primary limitation is that they can't describe anything new. So whenever you need something the existing recipe catalogue doesn't account for, you hit a wall.

Understanding your codebase at scale is essential for making safe, informed decisions about migrations, upgrades, and modernization.

OpenRewrite and Moderne provide powerful analytical tools (search markers, data tables, and visualizations), that help teams not only find and annotate code patterns, but also extract structured insights and communicate findings effectively across the organization. In this lesson, you'll discover how these features work together to turn raw code into actionable intelligence.

OpenRewrite and Moderne provide a comprehensive set of analytical tools designed to help you understand your codebase at scale. Search markers let you annotate code with structured, semantic information during recipe execution, all without changing the original source code.

Data tables then collect and organize these annotations and other metadata into structured, tabular formats, making it simple to analyze patterns, track metrics, and generate reports.

Visualizations convert this structured data into interactive charts and graphs, allowing you to clearly communicate findings and monitor progress over time.

By combining these tools, teams can move beyond manual code review and basic text search, enabling data-driven decision-making for migrations, upgrades, and modernization projects.

DevCenter is the mission-control dashboard of the Moderne Platform, designed to give organizations a unified, high-level view of their code migration and upgrade progress. It brings together key metrics from across all repositories, making it easy to see where you stand, what’s left to do, and where attention is needed.

Under the hood, DevCenter is built from recipes itself; the same deterministic recipes you run across your code also generate its dashboards and data tables. You can run DevCenter directly from the SaaS Moderne Platform, or generate it from the Moderne CLI.

With DevCenter, teams can quickly surface actionable insights, communicate status to any audience, and make informed decisions about next steps.

Our most successful customers treat each of these pieces as one continuous loop rather than separate tools. They customize an off the shelf recipe for their organization, connect it to DevCenter so the dashboard reflects that customized recipe, and watch progress unfold over time as teams move through the migration. Then, as those teams work through it, they feed what they learn back into the recipe, so the next team hits fewer surprises than the last.

This is the horizontal approach playing out in practice because the same recipe runs across every repo, each team's fixes improve it for the team behind them, and the migration builds momentum as it goes.

Manual migrations tend to do the opposite, slowing down over time because every team starts from scratch.

In this lesson, you'll walk through DevCenter and learn how to read the dashboard, customize it for what your organization cares about, and connect it to recipes and migrations. Here is a look at the learning objectives for this section: