The rapid rise of artificial intelligence in software engineering has fundamentally altered the development landscape, promising unprecedented speed and efficiency. However, for seasoned professionals, the true value of tools like GitHub Copilot lies not merely in the velocity of code generation, but in the ability to solve complex engineering problems while maintaining rigorous standards of quality and human accountability. To understand how the most experienced practitioners are navigating this shift, we sat down with three Java Champions—developers with over a decade of deep expertise in the language—to explore how they are integrating AI into their workflows to build reliable, maintainable software.
For these experts, the consensus is clear: while AI can accelerate the writing of code, it cannot replace the essential roles of context, architectural validation, and human responsibility. The goal is to leverage AI as a sophisticated assistant that handles execution while the developer remains the primary architect of the system.
Vlad Mihalcea: Balancing Automation with Professional Voice
Vlad Mihalcea, a recognized authority in the Java ecosystem, has been utilizing GitHub Copilot to streamline the development of his projects, including Hypersistence Utils and Hypersistence Optimizer. For Mihalcea, the impact of AI is best illustrated by a recent project: the creation of a web application to track performance improvement events. Previously, the sheer scope of the task had led him to postpone it for months, anticipating weeks of manual development. With the assistance of Copilot, he was able to prototype and implement the application in just two days.
Mihalcea emphasizes that he views the tool as a new team member rather than a replacement. "I still review the plans and the code that is generated by AI," he notes. "Their goal is to improve my productivity, not replace me entirely." To ensure the output meets his professional standards, Mihalcea has developed a series of personalized skills for his AI assistant. By training the model on his archive of over a decade’s worth of technical blogging, he ensures that the documentation and code snippets generated by the tool reflect his specific principles of expressiveness, testability, and simplicity.
His approach to tooling is highly strategic. Mihalcea advocates for model selection based on the specific requirements of the task. He utilizes high-reasoning models for complex design and architectural analysis, while relying on lighter, faster models for routine administrative tasks like report generation or documentation verification. By tailoring the AI’s behavior to his existing code practices, he ensures that his projects remain consistent and adhere to the "principle of least astonishment," making future maintenance significantly easier.
Patrick Baumgartner: Redefining the Agentic Workflow
Patrick Baumgartner, who spends much of his time coaching development teams, views the integration of AI through the lens of long-term sustainability and problem-solving. His philosophy is grounded in the idea that AI should be a partner in a collaborative process rather than a shortcut. He argues that developers must resist the temptation to treat AI as a "code-producing machine" and instead focus on becoming stronger problem solvers who can verify results and maintain architectural integrity.
Baumgartner highlights three distinct experiences that shaped his approach to modern AI workflows. First, he successfully migrated 900 complex teaching slides from Reveal.js to Marp. Rather than delegating the entire task blindly, he analyzed the source material, defined a migration plan, and established clear verification gates—including visual and algorithmic comparisons—to ensure the final output matched his intent. "Delegate execution, not responsibility," he explains, noting that while the AI performed the tedious labor, he remained the owner of the content and the teaching logic.
In a second example, he utilized AI to troubleshoot a terminal UI application that was failing for users on Windows. By using Copilot to reproduce the issue through automated testing and iteratively refining the test representations, he was able to submit an upstream fix to the library he was using. This experience taught him that AI can also assist in optimizing how information is represented for machine execution, moving beyond mere code generation to structural design.
Finally, Baumgartner’s work on a children’s math learning application served as a lesson in using AI as a "sparring partner." When the tool challenged his initial assumptions about creating a "universal" application, it pushed him to research actual school curricula and focus on a localized, high-quality experience. This shift in thinking—from implementation to discovery—is central to his methodology. He has moved away from the traditional autocomplete experience, instead favoring agentic workflows where he acts as the steering authority, reviewing, deciding, and guiding the AI through complex execution tasks. He stresses that developers should move away from "one-shot prompting" and instead treat the AI as a partner that should be required to interview the developer, uncovering implicit assumptions before a single line of code is written.
Frank Delporte: Troubleshooting at the Kernel Level
For Frank Delporte, the power of AI lies in its ability to assist in the investigation of high-level, complex bugs that would otherwise require exhaustive manual research. A recent challenge with the Pi4J library, which interacts with the Raspberry Pi’s hardware, highlights this potential. When a new release caused intermittent issues with input buttons, the team was baffled. The bug occurred in the library’s interface with the Linux kernel via the Foreign Function & Memory (FFM) API, a notoriously difficult area to debug.
Delporte assigned the issue to the GitHub Copilot coding agent, providing only the relevant file paths as a starting point. Within half an hour, the agent returned a pull request with a sophisticated diagnosis: virtual threads, when used in native calls, were pinning to carrier threads, exhausting the Raspberry Pi’s limited CPU cores. This effectively paralyzed the event watchers.
What impressed Delporte most was not just the resolution, but the subsequent dialogue. By questioning the agent on its reasoning, he was able to confirm the technical validity of the fix and gain a deeper understanding of the interaction between virtual threads and native hardware constraints. This interaction illustrates a critical shift in the developer’s role: from manual debugging to managing an expert system that can parse intricate technical environments.
The Human Element in the Age of AI
Across these three perspectives, a common theme emerges: the role of the software engineer is evolving, not disappearing. As these Java Champions demonstrate, the most effective use of AI is to treat it as an extension of the developer’s intent. Whether through creating custom skills that mirror one’s own coding style, implementing rigorous verification gates for AI-generated output, or using the model as a partner to challenge architectural assumptions, the human remains at the center of the development lifecycle.
The profession is moving toward a model where engineers spend less time on the mechanics of writing syntax and more time on high-level decision-making, requirement analysis, and the orchestration of automated systems. As Baumgartner aptly summarizes, this transition is, in many ways, "putting the engineering back into software engineering." By leveraging AI to handle the heavy lifting of execution, developers are finding more space to focus on the essential human tasks of understanding users, making trade-offs, and ensuring that the software they ship is both reliable and purposeful.
