In the rapidly evolving landscape of modern software development, artificial intelligence has shifted from a novelty to an integral component of the professional toolkit. While the industry is often preoccupied with the raw speed at which AI can generate code, seasoned software engineers are discovering that velocity is only a small part of the equation. True expertise lies in how developers manage context, validate outcomes, ensure long-term maintainability, and retain ultimate accountability for the software they ship. To explore how this balance is achieved in practice, we spoke with three Java Champions—veterans with over a decade of experience in the language—about how they are using GitHub Copilot to solve complex problems and refine their craft.
Vlad Mihalcea: Elevating Productivity Through Contextual AI
For Vlad Mihalcea, a recognized expert in the Java ecosystem, GitHub Copilot serves as an essential partner for both his production work and open-source contributions. Mihalcea has been leveraging the tool to streamline the development of his projects, such as Hypersistence Utils and Hypersistence Optimizer. His recent experience highlights a common bottleneck in software development: the gap between identifying a valuable feature and having the time to build it.
Mihalcea had long planned to develop a web application capable of visualizing performance optimization event history, but the sheer volume of work required had led him to delay the project for months. By treating Copilot as an additional team member rather than a simple code-completion tool, he was able to condense what would have been a multi-week undertaking into a two-day sprint. This efficiency, however, did not come at the cost of quality. Mihalcea emphasizes that he remains firmly in control of the design and implementation, utilizing the AI as a sounding board for prototypes and as an assistant during complex debugging sessions within his primary environment, IntelliJ IDEA.
To ensure the output aligns with his standards, Mihalcea has developed a highly personalized approach to AI interaction. By training the model on his extensive archive of technical writing—spanning over a decade of blog posts and articles—he has created a "voice" for his AI assistant. This ensures that the generated documentation and code snippets reflect his established principles of expressiveness, testability, and simplicity. He maintains that because software maintenance consumes far more time than initial creation, his AI-assisted workflows are strictly governed by the "principle of least astonishment," ensuring that all generated code remains predictable and maintainable for the long term. His strategy also involves tactical model selection: he reserves high-reasoning models like Opus for complex analytical tasks, while relying on more efficient, lighter models for routine operations like generating release notes or verifying documentation.
Patrick Baumgartner: Architecting Solutions and Agentic Workflows
Patrick Baumgartner, who spends much of his time coaching development teams, approaches AI from the perspective of systemic improvement. For Baumgartner, the introduction of AI tools is not about replacing the human element but about augmenting it. He views his role as a collaborator who works alongside teams to solve immediate business problems, helping them implement modern practices like Test-Driven Development (TDD), continuous delivery, and modular architecture.
Baumgartner’s experience with GitHub Copilot is diverse, ranging from large-scale migrations to the creation of entirely new products. One of his most telling examples involved migrating nearly 900 teaching slides from Reveal.js to Marp. This was a high-stakes task where the pedagogical flow and interactive code examples had to remain perfectly intact. Rather than treating it as a simple copy-paste job, Baumgartner and the AI analyzed the existing structure, defined strict constraints, and established a migration plan. The critical success factor was verification: they generated screenshots and visual comparisons of the slides to ensure the migration was not just "complete," but accurate. This reinforced a core tenet of his philosophy: developers must delegate execution, but never responsibility.
His shift toward agentic workflows represents a significant evolution in how he interacts with technology. Baumgartner rarely uses standard autocomplete anymore; instead, he interacts with coding agents to execute complex, multi-step tasks. During a recent four-hour trip to the JavaLand conference, he managed the development of a Maven plugin for Spring Boot optimization entirely from his phone. By steering the agent, reviewing its progress, and providing iterative instructions, he arrived at his destination with a fully functional plugin, complete with CI pipelines and performance benchmarks.
Baumgartner cautions against the dangers of "one-shot prompting," where a developer gives a complex instruction and hopes for the best. Instead, he advocates for an interview-style approach, where the agent is asked to query the developer to uncover implicit assumptions. By setting up "verification gates" for every task—ensuring that code meets specific architectural and testing standards before it is considered done—he maintains rigorous control over the output. He views these agents as sophisticated sparring partners that can help expand the solution space, challenging his initial assumptions and helping him refine the architecture before a single line of code is written.
Frank Delporte: Investigating Complexities in the IoT Ecosystem
The utility of AI extends deep into the realm of hardware and systems programming, as demonstrated by Frank Delporte. A long-time contributor to the Pi4J library—which enables Java applications to interface with electronic components on the Raspberry Pi—Delporte recently encountered a frustrating bug that highlights the detective work involved in modern maintenance.
Following the release of Pi4J V4, which introduced a new plugin using the Foreign Function & Memory (FFM) API, users reported that a five-button input configuration was failing; the fifth button simply refused to register. Despite thorough pre-release testing, the bug proved elusive because it produced no logs or exceptions. It was a classic "silent" failure rooted in the interaction between Java virtual threads and native Linux kernel calls.
Delporte tasked the GitHub Copilot coding agent with investigating the provider class and the FFM digital input files. Within thirty minutes, the agent identified the root cause: the virtual threads were blocking inside a native poll() call, causing them to remain pinned to the carrier threads. Because the Raspberry Pi 4 has four cores, the four available carrier threads were occupied by the first four inputs, leaving no room for the fifth. The AI not only identified the problem but also provided a clear, technical explanation and a proposed fix.
What stood out to Delporte was not just the efficiency of the fix, but the collaborative nature of the review process. When he challenged the AI’s explanation regarding virtual thread behavior, it was able to synthesize the specifics of the Raspberry Pi architecture with the requirements of the FFM API, demonstrating a deep level of technical reasoning. For Delporte, this experience solidified the role of AI as a powerful diagnostic companion. By allowing the agent to handle the deep investigation of complex, native-code interactions, he could focus on verifying the architectural implications and ensuring that the fix adhered to the project’s long-term standards.
These three perspectives underscore a common theme: while the tools have become more powerful, the role of the software engineer has become more critical. Whether it is by maintaining a consistent coding voice, establishing strict verification gates, or using AI to debug low-level hardware interactions, these developers are treating AI as a sophisticated, context-aware extension of their own expertise. They are not merely generating code; they are managing the engineering lifecycle, proving that in the age of AI, the human capacity for critical thinking, architectural foresight, and ultimate responsibility remains the most vital asset in the software industry.
