The rapid evolution of artificial intelligence in software engineering has shifted the conversation from simple code generation to the complex art of orchestration. While AI-powered tools can generate snippets at breakneck speeds, experienced developers understand that velocity is not a proxy for quality. To solve the industry’s most challenging problems, engineers must provide rigorous context, validate outputs against strict performance criteria, and maintain absolute accountability for the software that enters production.
To understand how high-level practitioners are navigating this transition, we spoke with three Java Champions—veterans with over a decade of deep experience in the Java ecosystem. Their insights reveal a common theme: the goal of AI is not to replace the human developer, but to augment their ability to manage complex, large-scale systems while delegating the most tedious execution tasks to intelligent agents.
Vlad Mihalcea: Balancing Innovation and Maintainability
For Vlad Mihalcea, an expert known for his work on Hypersistence Utils and Hypersistence Optimizer, GitHub Copilot has become an essential force multiplier. Mihalcea views the AI as a new team member that allows him to pursue complex features that were previously shelved due to time constraints. Recently, he leveraged the tool to build an application for tracking performance optimization events, a task that would have historically required weeks of manual development. With the assistance of Copilot, he successfully implemented the project in just two days.
Mihalcea emphasizes that his usage is deeply integrated into his existing workflow, primarily within IntelliJ IDEA. He relies on the tool for code analysis, debugging sessions, and prototyping. However, he remains a vigilant overseer of the process. He notes that while AI often delivers high-quality solutions, it is not infallible; human intervention remains necessary to review plans and validate the generated code.
Central to his success is the creation of personalized skills. By training the model on his extensive archive of technical writing, Mihalcea ensures that the AI’s output mirrors his own voice and adheres to his established principles of expressiveness, testability, and simplicity. He is particularly focused on code maintenance, a phase of development that often consumes more time than initial creation. By ensuring that the AI mimics his existing code practices and adheres to the "principle of least astonishment," he minimizes the long-term technical debt that often plagues rapidly developed software. Furthermore, he practices intelligent model selection: utilizing high-reasoning models for complex architectural tasks while reserving lighter, faster models for routine documentation and reporting.
Patrick Baumgartner: The Shift to Agentic Workflows
Patrick Baumgartner’s approach to AI is rooted in his role as a team coach, where he balances the need for innovation with the reality that businesses cannot simply pause for months to undergo a digital transformation. Baumgartner sees AI as a powerful tool to assist with Software Craft practices—such as Test-Driven Development (TDD), continuous delivery, and modular architecture—while working directly alongside his teams.
His experience with AI has been marked by three distinct shifts in strategy. First, he successfully migrated hundreds of complex, interactive teaching slides from Reveal.js to Marp. Rather than relying on simple automation, he treated the process as an engineering project: defining constraints, establishing a migration plan, and implementing rigorous verification gates. By using visual and algorithmic comparisons to validate the results, he proved the migration’s integrity, reinforcing the critical principle that developers should delegate execution, not responsibility.
Baumgartner’s second success involved a terminal UI application where he discovered a compatibility issue between Linux and Windows environments. By using Copilot to turn user feedback into reproducible UI tests and redesigning the way test data was represented, he was able to submit an upstream fix that was eventually merged. This highlighted the importance of shipping software early to gather real-world data. His third experience involved building a learning application for children, where he used Copilot not just to write code, but as a "sparring partner" to challenge his assumptions about learning methodologies and architecture, ultimately leading to a more robust, decentralized product.
His workflow has evolved away from the classic autocomplete experience toward agentic workflows. He finds that he is more effective when he can delegate a complex piece of work, let the agent execute it, and then inspect the results. During a recent journey to JavaLand, he even managed the development of a Maven plugin entirely from his mobile phone, steering the agent through various tasks while he focused on the higher-level decision-making. He stresses that "stop one-shot prompting" is the most important lesson for developers; instead, he advocates for an iterative process where the agent interviews the developer to uncover implicit requirements before any code is generated.
Frank Delporte: Troubleshooting and Deep Investigation
For Frank Delporte, the power of AI is best demonstrated in its ability to assist with complex debugging—a task that historically required deep, time-consuming investigation into the darkest corners of a codebase. Delporte recounts a recent challenge with the Pi4J library, which interacts with electronic components on the Raspberry Pi. After a major release, a user reported a bug where the fifth input button in a series failed to trigger, despite the hardware functioning perfectly with older plugins.
The issue was not immediately obvious; there were no logs or exceptions, and the problem appeared to be buried in the library’s interaction with the Linux kernel’s GPIO character device. By assigning the issue to the GitHub Copilot coding agent and providing the relevant file paths, Delporte received a sophisticated analysis within thirty minutes. The agent identified that virtual threads blocking inside a native poll() call were causing a bottleneck, effectively pinning the carrier threads and preventing further execution.
Delporte highlights that the most valuable part of the experience was the subsequent conversation with the AI. He was able to interrogate the reasoning behind the findings, forcing the tool to explain the relationship between the Raspberry Pi’s four-core architecture and the virtual thread limitations. This interaction not only provided a fix but also yielded additional improvements that the agent identified during its deep dive.
For all three developers, the message is clear: the future of software engineering lies in the ability to balance the raw power of AI with the irreplaceable judgment of the human engineer. By treating AI as a sparring partner, a delegate for execution, and a tool for deep investigation, these Java Champions are finding ways to elevate their craft, focusing on the architectural trade-offs and critical problem-solving that define true software engineering. As they continue to integrate these tools into their daily routines, the emphasis remains on the human responsibility to shape, verify, and maintain the systems that run our world.
