How Java Champions Leverage GitHub Copilot for Enhanced Engineering Productivity
Three expert developers share strategies for integrating AI agents into professional software workflows.
1Beyond Simple Code Generation
AI coding tools offer speed, but software engineering requires context, validation, and accountability. Three Java Champions—Vlad Mihalcea, Patrick Baumgartner, and Frank Delporte—demonstrate that productivity gains come from treating AI as a partner rather than a replacement. They emphasize that developers must remain responsible for the final output and maintainability of shipped code.
2Accelerating Feature Development
Vlad Mihalcea utilized GitHub Copilot to build a web application for Hypersistence Optimizer event history. A task previously estimated to take weeks was completed in just two days. By using the tool within IntelliJ IDEA, he maintains a tight feedback loop for investigations and prototyping while personally reviewing all AI-generated code.
3Personalizing AI Output
Mihalcea created custom skills that mirror his writing style from 65 published articles. This ensures generated documentation maintains principles like expressiveness, testability, and simplicity. He also adjusts model types based on the task, using high-reasoning models for complex logic and lighter, token-efficient models for routine reports and release notes.
4Delegating Execution, Not Responsibility
Patrick Baumgartner migrated 900 teaching slides from Reveal.js to Marp using Copilot. He treated the AI as an executor, defining constraints and migration plans beforehand. The process took eight to ten hours, with Baumgartner maintaining ownership of the teaching intent and content, proving that delegation requires strict oversight of the final result.
5Evidence-Based Migration Verification
To ensure the slide migration was accurate, Baumgartner implemented algorithmic and visual verification. He built a tool to compare screenshots and PDFs of the old and new slide decks. This approach provided concrete evidence that the migration was successful, moving beyond simple AI assertions to verify that no content was lost.
6Iterative UI Testing Fixes
When a user reported that the Enter key failed in a terminal UI application, Baumgartner used Copilot to create reproducible UI tests. By navigating the app with tmux and PowerShell, they identified the bug and submitted an upstream fix. They also redesigned test representations into compact arrow notation for better agent efficiency.
7AI as a Sparring Partner
Baumgartner developed a math learning app for children, using Copilot to research pedagogical approaches like spaced repetition and adaptive difficulty. The AI challenged his initial assumption of a universal curriculum, leading him to align the app with specific Swiss school standards. This transformed the project from a simple quiz into a product.
8Agentic Workflows from Anywhere
Baumgartner now prefers agentic workflows over standard autocomplete. During a four-hour journey to JavaLand, he steered an agent from his phone to build a Maven plugin. By reviewing, deciding, and providing instructions, he successfully produced a working plugin, CI pipeline, and performance tests without writing a single line of code manually.
9Avoiding Expensive Detours
Baumgartner warns against one-shot prompting, which often leads to wasted effort. He now asks agents to interview him first to uncover implicit assumptions. In a previous project, he implemented two different architectural paths for Spring Boot versions, only to realize later that one was unnecessary, proving that detours are costly.
10Defining Strict Verification Gates
For any task, Baumgartner defines specific verification gates that must be met before completion. These include passing tests, updated documentation, and visual diffs. He advocates for the 'unlazy' principle, where the agent must provide evidence that the work satisfies the definition of done rather than just claiming the task is finished.
11Building Reusable Agent Skills
Both experts emphasize turning lessons into reusable skills. When an agent misunderstands a convention or misses a check, they update the skill set to prevent future errors. This iterative process ensures that the AI becomes more aligned with the team's specific coding practices and architectural standards over time, improving long-term consistency.
12Strategic AI Integration Summary
The core takeaway is that AI productivity depends on human-led context and rigorous verification. By treating AI as a sparring partner, defining clear requirements, and implementing automated verification gates, developers can handle complex tasks efficiently. Success lies in the ability to steer the agent while retaining full ownership of the final software.