In the rapidly evolving landscape of modern software development, the promise of AI-powered coding tools often centers on a single metric: velocity. By automating boilerplate and generating snippets in seconds, tools like GitHub Copilot have undeniably transformed how developers approach the keyboard. However, for seasoned engineers—specifically those who have spent decades navigating the complexities of the Java ecosystem—speed is merely a starting point. True expertise lies not in the mere generation of code, but in the orchestration of context, the rigorous validation of results, and the unwavering commitment to human accountability.
To understand how high-level practitioners reconcile the efficiency of machine-generated output with the stringent requirements of enterprise-grade software, we spoke with three distinguished Java Champions. These experts, each boasting over a decade of deep experience in the field, shared their strategies for integrating GitHub Copilot into both production and open-source environments, proving that the most effective AI usage is less about replacement and more about augmenting the human engineer’s capacity for critical thought.
Vlad Mihalcea: Elevating Productivity Through Customization
For Vlad Mihalcea, a recognized authority in Java persistence and performance, GitHub Copilot serves as an essential extension of his development team. His recent work on projects like Hypersistence Utils and Hypersistence Optimizer highlights a dramatic shift in how he manages feature development. Mihalcea notes that a specific goal—developing a web application to visualize performance improvement efforts—had been shelved for an extended period simply due to the sheer volume of time required for manual implementation.
With the aid of Copilot, what would have historically consumed weeks of focused effort was reduced to a two-day prototype. However, Mihalcea is careful to emphasize that the AI acts as a sophisticated assistant rather than an autonomous developer. He relies on the IDE integration within IntelliJ IDEA to assist in code review and debugging, but he maintains final oversight. The critical element of his workflow is the creation of personalized "skills" that act as a stylistic filter for the AI.
By training these custom skills on his extensive library of over 65 technical articles, Mihalcea ensures that the documentation and code generated by the AI mirror his own writing voice and technical principles. This approach ensures that the output prioritizes expressiveness, testability, and simplicity—core tenets he has championed throughout his career. Furthermore, he practices strategic model selection: utilizing high-reasoning, context-heavy models like Opus for complex design and architectural challenges, while reserving lighter, faster models for routine tasks like generating release notes or verifying basic documentation. For Mihalcea, the goal is to respect the principle of least astonishment, ensuring that AI-generated code remains consistent with the existing codebase.
Patrick Baumgartner: Architecting Agentic Workflows
Patrick Baumgartner, who specializes in coaching teams through complex technical transformations, views the rise of AI as a fundamental shift in the "sparring partner" model of software engineering. His approach is rooted in the belief that teams should not become dependent on external consultants—or, by extension, black-box AI tools. Instead, he treats AI as a powerful collaborator capable of handling execution, provided the human in the loop retains full responsibility for the strategy.
Baumgartner’s experience with a massive migration of 900 teaching slides from Reveal.js to Marp illustrates this philosophy. Recognizing that a manual migration would be both tedious and prone to human error, he used Copilot to perform the heavy lifting. Crucially, he did not simply ask the AI to "convert the slides." He first analyzed the material, defined strict migration constraints, and established clear verification gates. By using visual and algorithmic comparisons to confirm that the integrity of the content remained intact, he ensured the migration was evidence-based. This experience cemented his core principle: delegate the execution, but never the responsibility.
His experimentation extends into "agentic engineering," where he moves beyond simple autocomplete to steer autonomous coding agents. During a recent four-hour journey, he successfully developed a Maven plugin for optimizing Spring Boot configurations by providing instructions from his mobile device while an agent executed the tasks. This workflow, he argues, forces the developer to become an architect of the process. He advises against "one-shot prompting," instead encouraging developers to ask the agent to interview them first to uncover hidden assumptions. By wrapping these probabilistic models in deterministic engineering tools—such as automated checkers and custom quality harnesses—Baumgartner ensures that his projects maintain high standards for maintainability and architectural integrity.
Frank Delporte: Troubleshooting at the Kernel Level
The practical application of AI in debugging is perhaps best exemplified by the experience of Frank Delporte, a longtime technologist and advocate for the Pi4J library. When a complex bug surfaced in the library’s new Foreign Function & Memory (FFM) API implementation—specifically, an issue where a fifth input button failed to trigger code execution on a Raspberry Pi—it was far from a simple fix. The problem involved native calls to the Linux kernel and the nuances of virtual thread scheduling, a domain where quick, superficial answers rarely suffice.
Delporte assigned the issue to the GitHub Copilot coding agent, providing specific file paths to ground the investigation. Within thirty minutes, the agent identified the root cause: the virtual threads were blocking inside a native poll() call, effectively pinning themselves to the carrier threads and exhausting the available scheduler capacity on a four-core processor. The efficiency of the diagnosis was impressive, but for Delporte, the true value was the subsequent dialogue. By engaging with the AI to verify its reasoning and clarify how the virtual thread model interacted with the hardware, he was able to gain a deeper understanding of the system’s behavior.
This interaction underscores a vital theme shared by all three experts: AI tools are most effective when they facilitate a deeper engagement with the underlying technology. Whether it is Mihalcea’s focus on maintaining a consistent architectural "voice," Baumgartner’s emphasis on rigorous verification gates, or Delporte’s use of AI to navigate complex threading bugs, the common thread is that the human engineer remains the final arbiter of quality. As these Java Champions demonstrate, the future of software engineering is not about automating away the developer, but rather about using AI to elevate the craft, allowing engineers to focus on the high-level problem-solving that defines the profession. By treating these models as sophisticated partners rather than mere code generators, developers can reclaim the "engineering" in software engineering, ensuring that the systems they build are as robust as they are efficient.
