Eighty-four percent of developers now use or plan to use AI coding tools in their workflows. Code generation is accelerating. But understanding, governing, and modernizing the code already in production remains the harder problem.
In this episode of AppDevANGLE, I spoke with Jonathan Schneider, CEO and Co-Founder of Moderne, about why large-scale, deterministic modernization is becoming mission-critical as AI-generated code expands enterprise portfolios.
Our discussion explored why probabilistic code generation cannot safely handle cross-repository transformations, how deterministic “recipes” enable auditability at scale, and why modernization must shift from reactive firefighting to horizontal, cross-business remediation.
The Real Scale of Enterprise Codebases
Before AI code generation arrived, enterprise codebases were already massive.
Jonathan illustrated the scale with a powerful analogy:
“One of the earliest customers we worked with has about 500 million lines of source code under management… If I printed that code out in books and stacked them end to end, that bookcase would stretch all the way from Montreal to Miami.”
That volume is not an outlier. The largest organizations Moderne works with manage orders of magnitude more.
AI code generation is now compounding that footprint. As Jonathan put it:
“I think of AI code generation as giving you a lot of free puppies — and at some point you have to feed those puppies.”
The acceleration of code creation without a proportional acceleration in governance and modernization creates an exponential debt curve.
Probabilistic Generation vs. Deterministic Transformation
AI copilots and LLMs are highly effective at generating code snippets or assisting with new development. But they remain probabilistic systems. When applying changes across large, multi-repository codebases, probabilistic outputs introduce risk.
Jonathan drew a critical distinction:
“If I make that change with a probabilistic system like an LLM, then I have to inspect every change uniquely… If instead, I can have generative AI build a deterministic recipe, that recipe becomes a machine that makes the same change repeatedly without having to inspect every call site.”
The shift here is subtle but powerful:
- Generative AI can propose patterns.
- Deterministic engines execute them safely and repeatedly.
Jonathan described it as:
“We want generative AI to build a cookie cutter that then goes out and stamps out low-variability cookies across a lot of different call sites.”
This separation between semantic intelligence (AI) and deterministic execution (repeatable transformation) becomes the foundation for trust, auditability, and scale.
Why Horizontal Modernization Wins
Enterprises often modernize vertically, or one application at a time. But at scale, that approach stalls. Jonathan advocates for horizontal modernization across business units:
“It’s generally more productive to make the change horizontally across whole business units rather than trying to make a whole set of changes vertically on one application at a time.”
Horizontal modernization enables:
- Momentum preservation
- Reduced regression risk
- Easier pause-and-resume workflows
- Cross-portfolio consistency
This model becomes especially important as governance requirements expand under regulations like the EU Cyber Resilience Act (CRA) and other software supply chain mandates.
Multi-Repo Complexity Is the Real Bottleneck
Modern enterprises rarely operate single-repository applications. Instead, production systems span dozens, hundreds, or even thousands of repositories. Jonathan pointed out an industry blind spot:
“It’s kind of remarkable that the developer tools landscape to this point has been largely single repository… and yet a particular business application typically consists of many repositories.”
Traditional version control and tooling ecosystems treat code as text within isolated repositories. But text is a lossy representation. To reason across multi-repo systems, organizations must move beyond plain-text storage toward structural models.
Jonathan emphasized:
“When I look at code as text, I don’t understand what the relationships between symbols are or the dependency relationships between repositories.”
The solution is to model code as structured semantic data (abstract syntax trees (ASTs) enriched with symbolic and dependency relationships) enabling cross-repo reasoning and large-scale transformation.
Cross-Language Reuse Reduces Modernization Cost
One of the more surprising findings from Moderne’s language engineering work is that many programming languages share structural similarities.
Jonathan noted:
“A method invocation in Java actually has the same structure as it does in JavaScript.”
Within language families (Java, C#, JavaScript, Python, Ruby), semantic trees and program analysis patterns are often reusable. This means modernization recipes can extend across languages, dramatically reducing redundancy and accelerating remediation efforts.
The result:
- Lower duplication
- Smaller attack surfaces
- Broader reuse of transformation logic
- Reduced engineering overhead
Governance in the Age of Agentic AI
The rise of agentic AI in pipelines raises new governance questions. Jonathan offered a reductionist perspective:
“Suppose an agent writes 100 percent perfect code today… Six months from now, that code is no longer perfect.”
Even flawless code degrades over time due to:
- Library evolution
- Dependency updates
- Newly discovered vulnerabilities
- API deprecations
This reality predates AI, but AI accelerates it. Governance cannot focus solely on how code is generated. It must focus on how code is maintained at scale over time. The same deterministic modernization engine that handles human-written code must also govern AI-generated code.
Liquid Tech Stacks and Business Drivers
Modernization is not purely technical. Jonathan highlighted a key business dimension:
“It’s not always about developer productivity… It’s about being able to have a liquid tech stack that you are able to move from one stack to another as the environment changes around you.”
Vendor price increases, framework deprecations, cloud shifts, and compliance mandates all require portfolio-level transformation.
Deterministic modernization enables:
- Framework migrations
- Library standardization
- Vendor consolidation
- Cost optimization
At scale, modernization becomes a financial strategy as much as a technical one.
Analyst Take
AI code generation is not the modernization solution; it is the modernization multiplier.
As AI accelerates code creation, the surface area for technical debt, compliance risk, and multi-repository complexity expands dramatically. Enterprises cannot rely on probabilistic tools alone to govern that footprint.
The emerging pattern is clear:
- Generative AI proposes.
- Deterministic engines enforce.
- Governance frameworks validate.
- Horizontal execution scales.
Moderne’s deterministic, cross-repo approach reflects a broader market shift: modernization is no longer episodic. It is continuous, structured, and portfolio-wide.
In an era where 84% of developers use AI coding tools and regulatory frameworks tighten around software supply chains, modernization must move from reactive remediation to systemic, auditable transformation. The future of AI-driven development will not be defined by how fast code is generated, but by how safely, repeatably, and economically it can be governed across the entire codebase.
