Overview of Java’s age is its AI superpower
This episode of the Stack Overflow Podcast explores why Java’s long history is becoming an advantage in the age of AI agents. Host Ryan Donovan speaks with Markus Eisler, a developer advocate at IBM, about why Java’s maturity, strict type system, enterprise ecosystem, and rich training data make it especially well-suited for agentic engineering—particularly in large-scale enterprise environments where reliability, auditability, and controlled change matter more than flashy “vibe coding.”
Why Java Works Well for Agentic Engineering
Two major advantages
Markus argues that Java is strong for AI-assisted development for two main reasons:
- Massive training-data footprint: Java has been around for decades, and much of its ecosystem has been open and widely documented through OpenJDK, enterprise frameworks, and public code examples.
- Structured, type-safe design: Java’s strict syntax and predictable patterns make it easier for models and agents to read, generate, and modify code safely.
Java is not “old” in the bad sense
The episode emphasizes that modern Java is very different from “classic” Java:
- The language has evolved significantly while staying mostly backward compatible.
- The JVM ecosystem is mature, stable, scalable, and widely trusted in production.
- Frameworks like Spring and Quarkus add abstraction and enterprise-ready patterns that make Java even more AI-agent-friendly.
The Real Challenge: Legacy, Not Java Itself
History and technical debt are the problem
Markus says the biggest obstacle in agentic enterprise work is not Java, but the age of the systems built on it:
- Extremely large codebases
- Poor or outdated documentation
- Hidden customer-specific exceptions
- Long-tenured systems with fragile assumptions
- Limited automated testing in older projects
These are the kinds of systems where agents can help, but only if they are grounded carefully and used with strong guardrails.
Why brute-force agent loops are risky
He draws a sharp distinction between:
- Vibe coding / brute-force looping: fast, but often opaque and hard to trust
- Precision engineering: smaller, controlled, auditable changes that preserve stability
For enterprise systems—especially in regulated industries—confidence, traceability, and reviewability matter more than speed alone.
How Modernization Should Work
Version bumps are not enough
A key theme of the conversation is that modernization should be more than updating a version number in a build file.
Markus points out that many teams:
- Upgrade the runtime to satisfy support/CVE requirements
- Avoid touching the code unless absolutely necessary
- Miss the opportunity to adopt newer idioms and more efficient patterns
Static rewriting plus AI is the winning combo
He highlights tools and workflows that combine:
- Static code rewriting
- Agentic assistance
- Workflow-driven modernization
A notable example is OpenRewrite, which can mechanically transform code toward more modern, idiomatic Java while preserving correctness. AI agents then help guide and scale those changes.
Frameworks, Specs, and Harnesses
Specifications create a shared language
A recurring point is that Java frameworks benefit from strong specs because agents can rely on a common vocabulary:
- CDI beans
- Annotations
- MicroProfile
- Jakarta EE
That shared domain language helps both humans and AI systems understand the codebase.
The harness matters as much as the model
Markus argues that the workflow/harness around the model is often more important than the model itself.
Good harnesses should:
- Shape context
- Expose the right tools
- Provide transparency into what the agent is doing
- Limit random wandering through the codebase
- Deliver up-to-date knowledge and docs
Quarkus and MCP integration
He specifically calls out Quarkus Agent MCP, which provides:
- Documentation search
- Application control endpoints
- Packaged skills/tools
- Access to the running app during development
This makes the agent much better grounded than a generic model asked to “build a Quarkus app” from scratch.
Guardrails and Human Control
Human-in-the-loop is really human-in-control
Markus prefers a model where the developer remains actively involved, not just reviewing a giant finished diff after the fact.
He wants:
- Step-by-step visibility
- Auditable changes
- Clear review points
- A guided workflow instead of “here’s the finished result”
Guardrails are essential
To keep agents from causing chaos, he uses several kinds of safeguards:
- Repository-level controls
- Secret scanning like GitLeaks
- Code quality/security tools like Semgrep
- Testing boundaries that agents should not cross casually
He also mentions using tailored agent personas/modes in IBM’s toolset to reduce the “blast radius” of changes.
Practical Workflow Advice
A developer’s preferred flow
Markus describes his own style of agent-assisted development:
- Start with a specification
- Focus first on non-functional requirements
- Move into scaffolding
- Build for stability
- Extract architecture/design guidance
- Use agents to implement within those boundaries
- Add guardrails and testing early
Testing still matters, even if nobody loves it
He admits he is not a huge fan of writing tests, but he sees them as a critical safety net. Agents help by handling more of the testing burden while keeping tests as part of the guardrail system.
Key Takeaways
- Java’s age is a strength because it has enormous training-data coverage and a mature, predictable ecosystem.
- Enterprise Java is ideal for agents because its structure and tooling reduce ambiguity.
- Legacy systems are the hard part, not the language itself.
- Modernization should be surgical, not just a runtime bump.
- The workflow/harness matters greatly—often more than the model.
- Human control, not just human review, is the goal.
- Guardrails, documentation, and testing are essential for safe agentic development.
Notable Insights
“The complication is history.”
“Human in the loop” should really mean human in control.
Agentic coding works best when it is assisted, guided, and auditable, not just brute-forced with tokens.
Mentioned Tools and Technologies
- Java / OpenJDK
- Spring
- Quarkus
- Jakarta EE
- MicroProfile
- Project Panama
- OpenRewrite
- MCP servers
- Quarkus Agent MCP
- Grounded Docs
- Semgrep
- GitLeaks
- IBM Bob