In the rapidly evolving landscape of modern software development, the promise of AI-powered coding assistants has long been centered on the allure of raw speed. However, for seasoned professionals who have spent decades navigating the complexities of large-scale systems, the true value of tools like GitHub Copilot lies not in how quickly they can generate lines of code, but in how effectively they can be integrated into a rigorous, responsible engineering workflow. For these developers, AI is not a replacement for human oversight; it is a sophisticated, albeit probabilistic, partner that requires clear context, validation, and a firm hand on the tiller of accountability.
To understand how high-level practitioners are bridging the gap between AI-generated output and production-ready software, we spoke with three Java Champions. Each brings over a decade of deep experience in the Java ecosystem, offering a nuanced look at how they manage the balance between AI’s productivity gains and the non-negotiable requirements of software maintainability and reliability.
Vlad Mihalcea: Balancing Innovation with Established Principles
For Vlad Mihalcea, a recognized authority in the Java space, GitHub Copilot has become an essential force multiplier in his work on Hypersistence Utils and Hypersistence Optimizer. Mihalcea notes that before the integration of AI, significant feature development—such as building an analytics dashboard to track performance improvements—often languished in his backlog due to the sheer time investment required. By leveraging Copilot as a virtual team member, he successfully transitioned from a multi-week projection to a two-day implementation cycle.
However, Mihalcea is quick to emphasize that the convenience of an IDE plugin—which he utilizes primarily within IntelliJ IDEA—does not absolve the developer of their duties. He views the AI as a tool for investigation and prototyping that ultimately remains subordinate to his own architectural vision. He maintains a critical stance, constantly reviewing generated code to ensure it meets his standards for expressiveness, testability, and simplicity.
A key part of Mihalcea’s strategy involves the creation of personalized skills that force the AI to adopt his specific "voice." By training the model to draw from his extensive history of technical blogging—spanning over 12 years—he ensures that the documentation and code snippets generated by Copilot align with his established coding philosophies. He stresses that software engineering is fundamentally about maintenance; therefore, he prioritizes "the principle of least astonishment," ensuring that AI-generated code mirrors the practices already embedded in his projects. Furthermore, Mihalcea employs a strategic approach to model selection, opting for high-reasoning models for complex design tasks and lightweight models for routine documentation or report generation, thereby optimizing for both quality and efficiency.
Patrick Baumgartner: From Coding Machine to Strategic Sparring Partner
Patrick Baumgartner, who frequently coaches teams through the complexities of digital transformation, views the rise of agentic engineering through the lens of human collaboration. For Baumgartner, the goal is never to foster dependence on the AI, but rather to use it as a tool that empowers teams to solve problems more effectively. His philosophy is defined by a clear distinction between delegating execution and abdicating responsibility.
Baumgartner recounts three distinct experiences that shifted his perception of AI, starting with a massive migration of nearly a thousand teaching slides from Reveal.js to Marp. This was not a simple conversion task; the slides contained interactive code and animations that were critical to his teaching pedagogy. By treating the AI as an executor, he first defined strict migration constraints and verification gates. He implemented a rigorous validation process, generating visual and algorithmic comparisons to ensure the integrity of the content. The result was a successful migration completed in a fraction of the time, with Baumgartner retaining full ownership of the educational intent.
In another instance, Baumgartner utilized Copilot to address a cross-platform bug in a terminal UI application. When users reported issues with the Enter key in Windows environments, he used the AI to help design a new, more efficient way of representing test data, moving away from verbose tables to a compact, semantic-friendly notation. This experience highlighted for him that AI can be a partner in determining how information is structured for machine execution.
Perhaps most notably, Baumgartner has evolved his workflow away from simple autocomplete toward agentic, terminal-based interactions. He describes a scenario where he managed the development of a Maven plugin entirely from his mobile phone while traveling, steering the AI through a multi-step process of coding, testing, and documentation. This convinced him that the future of the profession lies in the developer acting as an architect and navigator rather than a manual typist. He advises fellow developers to abandon "one-shot prompting" in favor of iterative, interactive sessions where the AI is encouraged to interview the human to uncover hidden assumptions before any code is written.
Frank Delporte: Investigating the Unseen with AI Assistance
Frank Delporte, whose deep history in technology stretches back to the era of the Commodore 64, finds that AI excels as a diagnostic tool, particularly when investigating complex bugs that defy simple explanations. His experience with the Pi4J library—a project designed to interact with Raspberry Pi hardware—serves as a compelling case study.
Following a major release, users reported that a fifth input button failed to function, despite the code appearing perfectly sound. The issue was buried deep within the library’s interaction with the Linux kernel via the Foreign Function & Memory API. Traditional debugging was failing to surface the cause. Delporte assigned the issue to the Copilot coding agent, providing it with the relevant file paths.
Within half an hour, the agent returned with a sophisticated diagnosis: the implementation was pinning virtual threads in a way that exhausted the available carrier threads on a four-core processor. The AI did not just provide a fix; it sparked a technical dialogue that allowed Delporte to verify the underlying logic and ensure the proposed solution was robust. For Delporte, this exchange underscored the power of AI to serve as an expert-level research assistant, capable of navigating and explaining complex interactions between high-level code and low-level system behavior.
As these experts demonstrate, the integration of AI into the software development lifecycle does not signal the end of traditional engineering. Instead, it signals a transition toward a more deliberate, architecturally-focused practice. By combining the probabilistic power of large language models with the deterministic rigors of testing, validation, and deep domain expertise, developers are finding that they can spend less time on the mechanics of code generation and more time on the complex, human-centric challenges that define true software engineering. As the industry continues to experiment with these tools, the consensus among these Java Champions is clear: the most effective developers will be those who remain firmly in charge of the vision, using AI to execute the details while keeping the responsibility for the final product firmly in human hands.
