Jonathan Schneider

Generative AI can be a powerful force multiplier for developers, but it also comes with limitations. Developers are expected to co-create with AI, and check the generated output, or risk hallucinations running wild. This can aid development at a local machine, but what happens when you try to apply these tools on a massive scale?

For mass-scale code operations, AI needs to have agency, able to operate with some degree of autonomy. In this session, we’ll cover how you can combine retrieval and tool calling techniques, the richest code data source for Java called the Lossless Semantic Tree (LST), and OpenRewrite rules-based recipes to drive more efficient and accurate AI model output for refactoring and analyzing large codebases.

You’ll learn about how you can use AI embeddings as a powerful tool to visualize, analyze, and even do smarter sampling for your codebase. Plus, we’ll show you how to leverage GenAI to accelerate writing OpenRewrite deterministic recipes.

We’ll take an honest look back and a look ahead on our process, to show you how enterprises can now reliably leverage AI for code modernization at scale.

As AI agents take more and more of a leading role in crafting code, it’s suddenly become apparent that the “first user” of engineering productivity tooling will be shifting towards agents rather than individual human developers.

With a human still at the helm of a fleet of agents in producing software, and increasingly less involved in the writing of individual lines of code, maximizing engineering value delivery means making every tool call faster, more token efficient, and more accurate.

Many of our members have now brought in not one but several coding agents and foundation models in an effort to accelerate everything from feature delivery to application modernization. But now attention will shift to how to ever tighten the tool call feedback loops. Each percentage gain in tool call efficiency multiplied across an increasingly large fleet of agents creates an outsized impact.

We’ll cover a variety of concrete cases where tool call efficiency can be harvested immediately:

• Trigram index based code search
• Lossless Semantic Tree access/manipulation patterns
• Mining data from chat transcripts
• Exposing multi-repository commit/PR activity to agents.

Join a panel of trailblazing engineering leaders who are shaping how the industry thinks about scaling software development. From navigating technical debt to responsibly integrating generative AI, this conversation will cover the hard-won lessons and emerging strategies for managing massive codebases.

We’ll dive into:

• Impact of developer time spent on code refactoring.
• The influence of generative AI code creation on automated code refactoring.
• Techniques for ensuring genAI authored code is high quality, maintainable, and secure—and proving it meets standards.
• Organizational challenges of managing large-scale code changes, including PR overload, developer trust, and risk mitigation.
• Measuring the impact of technical debt across large software organizations and driving leadership action.
• Risk assessment and mitigation strategies when rolling out changes that affect thousands of developers.
• The role of auto-refactoring in developer portals and real-world use cases for integration.
• Challenges and lessons learned from using generative AI for testing and dead code removal at scale.

Come with questions—this panel is built to spark insight and honest discussion.

Software keeps moving—and so must we. From end-of-life frameworks to sprawling polyglot stacks and never-ending CVEs, modernizing code at scale is one of the toughest, most necessary problems in engineering today. In this keynote, we’ll take a clear-eyed look at where we are—and what it really takes to move forward.

We’ll unpack the rise of agentic AI, and why the future isn’t just about bigger models but better data and tools. Generative AI may be great at writing new code, but modernizing existing code? That takes precision—and deterministic systems that know when not to guess.

We’ll also dig into the language engineering problem: how do you unify modernization with codebases written in Java, C#, Python, JavaScript, and more? Each language needs a custom model that captures types, formatting, and structure for meaningful, accurate change at scale.

Finally, we’ll confront the security tradeoffs facing modern teams: should you upgrade fast to stay on the latest most secure versions, or leverage back patches to stay secure on what you know? The answer isn't always forward motion—it’s smarter, safer modernization.

We're helping teams navigate all of this with confidence at Moderne, providing AI-driven, multi-language refactoring and modernization at scale. After all, modern software demands more than speed—it demands the ability to evolve, safely and continuously, no matter how complex the codebase or how fast the industry moves.

Join us as we kick off Code Remix Summit—your front-row seat to the future of code.