Quarkus Insights #249: Using Coding Agents with Quarkus
By
This summary was generated using AI, reviewed by humans - watch the video for the full story.
In episode 249 of Quarkus Insights, Philip Krüger from Australia joined the team to demonstrate how coding agents can enhance the Quarkus developer experience. Despite battling flu season and joining at 11 PM his time, Philip showcased the new Quarkus Agent MCP server and how it enables AI-powered development workflows.
News: Quarkus 3.36 Platform Release
Before diving into coding agents, the team announced the Quarkus 3.36 platform release, which includes:
-
**OIDC Spiffe authentication
-
Signals - a new eventing infrastructure
-
Enhanced developer experience features
For those interested in the design decisions behind signals, the team recorded a detailed presentation during the Quarkus community call with extensive discussion about the architecture and future direction.
The Evolution: From Dev UI to AI Experience
Philip explained the journey from developer-focused tools to AI-focused tools:
Dev UI Foundation
Dev UI provides developers with a web console to access services on their running application in dev mode. This has been a core part of Quarkus’s developer experience pillar.
Chappie: AI-Enhanced Developer Experience
Chappie emerged to enhance the developer experience using AI, integrating with Dev UI and other components like error screens. Key features include:
-
Chat interface within Dev UI
-
RAG (Retrieval-Augmented Generation) integration with Quarkus documentation
-
Version-aware documentation access
-
CLI support for AI interactions
Important: Chappie is still actively maintained and focuses on enhancing the developer experience through Dev UI and other channels.
MCP: The Bridge to Coding Agents
When Model Context Protocol (MCP) emerged, the team realized it shared a similar architecture with Dev UI (both use JSON-RPC for client-server communication). This made it straightforward to expose Dev UI’s backend as an MCP server.
However, this revealed a critical insight: the user had changed. Instead of targeting developers directly, the tools now needed to serve coding agents, requiring a shift from "developer experience" (DevX) to "AI experience" (AIX).
The Quarkus Agent MCP Server
Philip demonstrated the Quarkus Agent MCP server, a standalone tool designed specifically for coding agents building Quarkus applications.
Key Advantages Over Dev MCP
Decoupled from Applications: - Runs as a standalone MCP server - Can create applications (doesn’t require an existing app) - Remains available even when applications crash - Supports the full application lifecycle
Optimized Tool Management: - Uses a "search tools" pattern instead of exposing hundreds of individual tools - Tools are discovered dynamically based on installed extensions - Reduces context window usage for LLMs
Documentation Integration: - RAG access to Quarkus documentation - Version-aware documentation - Support for extension-specific documentation - Includes documentation from transitive dependencies (like Hibernate)
Skills System: - Extension-specific skills guide the agent - Skills are version-controlled with Quarkus releases - Can be customized at user or project level
Installation and Setup
The Quarkus Agent MCP is available through multiple channels:
Via Claude Marketplace: Simply install from the marketplace in Claude Desktop.
Manual Configuration (using JBang):
{
"mcpServers": {
"quarkus-agent": {
"command": "jbang",
"args": ["io.quarkus:quarkus-agent-mcp:LATEST"]
}
}
}Local Development (using Java):
{
"mcpServers": {
"quarkus-agent": {
"command": "java",
"args": ["-jar", "/path/to/quarkus-agent-mcp-SNAPSHOT.jar"]
}
}
}Live Demo: Building a Vinyl Collection Manager
Philip demonstrated the agent in action by asking it to create a vinyl collection management application:
Please create an app that I can use to manage my vinyl collection and add a nice web UI.The agent automatically:
-
Selected the tech stack: Chose Quarkus without being explicitly told (due to the MCP context)
-
Refined requirements: Asked clarifying questions about database and UI preferences
-
Created the application: Used the Quarkus CLI through MCP tools
-
Built the features: Implemented CRUD operations with PostgreSQL backend
-
Added a web UI: Created a static HTML/JavaScript interface
-
Tested the application: Verified functionality using browser automation
The entire process happened with minimal intervention, showcasing how the agent leverages the MCP tools to understand Quarkus conventions and best practices.
Available Tools in Quarkus Agent MCP
Philip outlined the tool categories available to coding agents:
Application Lifecycle Tools
-
create_application- Bootstrap new Quarkus projects -
start_application- Start applications in dev mode -
stop_application- Stop running applications -
restart_application- Restart applications -
application_status- Check application state -
open_browser- Open Dev UI or application in browser
Knowledge Tools
-
search_docs- Search Quarkus documentation with RAG -
get_skills- Access extension-specific skills -
list_skills- View available skills
The Skills System
Skills are markdown files that guide coding agents on how to work with specific Quarkus features.
Extension Skills
Each Quarkus extension can provide a skill that includes:
-
Metadata: Extension name, description, documentation URL
-
Usage patterns: How to use the extension effectively
-
Best practices: Quarkus-specific conventions
-
Available tools: What Dev MCP methods are available
Example skill structure:
# Quarkus REST Skill
## Description
Guide for building REST endpoints with Quarkus REST (formerly RESTEasy Reactive)
## Usage
- Use `@Path` annotations for endpoint routing
- Leverage reactive programming with Mutiny
- Use `@GET`, `@POST`, etc. for HTTP methods
## Available Tools
- test_endpoint
- view_openapi_schemaSkill Generation Process
Philip described an interesting approach to generating skills:
-
Start two AI instances (one with Claude Sonnet, one with Claude Opus)
-
Have Sonnet attempt to build a feature (e.g., GraphQL endpoint)
-
When Sonnet struggles, ask Opus for help
-
Ask Opus to generate a skill based on what it learned
-
Test the skill with Sonnet to validate effectiveness
This iterative process helps create skills that genuinely improve agent performance.
Skill Customization
Skills can be customized at different levels:
Project-level: Saved in .quarkus/skills/ directory
.quarkus/
skills/
quarkus-rest.md
quarkus-hibernate-orm.mdUser-level: Saved in user’s home directory
~/.quarkus/skills/Enhancement mode: Add organization-specific guidance without replacing the base skill:
---
enhance: true
---
## Company-Specific Guidelines
- Always use our custom error handling pattern
- Include audit logging for all mutationsDocumentation Integration
The documentation system has evolved significantly:
Current Approach (Chappie)
Chappie builds a vector database from documentation, exports it, and publishes it as a Docker image. Dev services download this image when needed.
New Approach (Quarkus 3.37+)
Starting with the next release:
-
Maven plugin: Extensions use a Maven plugin to generate vector database SQL exports from their documentation
-
Aggregation: The agent MCP aggregates documentation from all extensions and dependencies
-
Broader coverage: Includes documentation for libraries like Hibernate, not just Quarkus extensions
This approach is more distributable and supports the full dependency tree.
RAG vs. Direct Documentation
Philip questioned whether RAG is still necessary, given modern LLMs' large context windows. The team discussed trade-offs:
RAG Benefits: - Reduces context window usage - Provides focused, relevant information - Works with smaller models
Direct Documentation: - Simpler implementation - No vector database maintenance - Better for comprehensive understanding
The team continues to evaluate the best approach as LLM capabilities evolve.
Extension Developer Guide
For extension maintainers, Philip outlined what’s needed to support AI experience:
1. Review Dev MCP Methods
Ensure Dev MCP methods target AI use cases, not just human developers:
Example - Continuous Testing: - For humans: Toggle continuous testing on/off - For agents: Run tests at specific points in time
Example - Hot Reload: - For humans: Automatic reload on file changes - For agents: Explicit reload command when ready
2. Add Extension Skills
Create a skill file in your extension:
deployment/src/main/resources/quarkus-skill.mdThe skill should include: - Clear description of the extension’s purpose - Usage patterns and examples - Common pitfalls and solutions - Integration points with other extensions
3. Ensure Documentation Quality
Make sure your extension’s documentation is: - Accurate and up-to-date - Well-structured with clear headings - Includes practical examples - Links to related documentation
For core Quarkus extensions, documentation is already integrated. For Quarkiverse extensions, add this to your POM:
<plugin>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-doc-maven-plugin</artifactId>
<version>${quarkus.version}</version>
</plugin>4. Follow the Extension Maturity Matrix
The Extension Maturity Matrix now includes AI experience criteria. Following these guidelines ensures your extension works well with coding agents.
Team’s AI Development Practices
In response to questions on the live-stream chat, the team shared their diverse approaches to AI-assisted development:
Tools and Models Used
IDEs and Harnesses: - Claude Desktop (most popular) - IntelliJ IDEA with AI Assistant - https://bob.ibm.com/ - Cursor - GPT Pilot - JetBrains Qodana
Models: - Claude (Sonnet and Opus) - GitHub Copilot - Google Gemini
Workflow Patterns
Philip’s Approach: - Uses Claude Desktop exclusively - Views code through Dev UI’s workspace browser - Treats the agent as a soundboard for design discussions - Runs multiple Claude instances for different tasks - Rarely opens a traditional IDE
Max’s Approach: - Prefers GPT Pilot - Focuses on incremental development - Uses plan mode but avoids over-planning - Emphasizes iterative refinement
Eric’s Approach: - Uses IntelliJ with Claude integration - Leverages IDE context sensitivity - Benefits from IDE’s diff viewer - Combines IDE refactoring with AI generation
Holly’s Approach: - Swaps between Claude Code and Bob - Uses Test-Driven Development (TDD) with agents - Writes tests first, then has agent implement - Finds TDD particularly effective for reproducers
Common Themes
-
Not necessarily faster for new features: AI doesn’t dramatically speed up complex feature development
-
Excellent for maintenance: Fixing bugs, updating dependencies, handling CI failures
-
Great for boilerplate: Generating repetitive code structures
-
Requires review: All code is reviewed before merging
-
Reduces mental load: Handles tedious tasks while developers focus on design
Babysitting vs. Collaboration
The team discussed the evolution from "babysitting" agents to true collaboration:
Test-Driven Development with Agents
Holly emphasized the value of TDD when working with agents:
The TDD Workflow
-
Write the test first: Define expected behavior
-
Verify it fails: Ensure the test catches the issue
-
Have agent implement: Let the agent write code to pass the test
-
Review the solution: Ensure quality and correctness
Spec-Driven Development
When to Use Coding Agents
The team shared guidance on when agents provide the most value:
Excellent Use Cases
-
Bug fixes: Especially with clear reproducers
-
Dependency updates: Handling breaking changes
-
CI/CD maintenance: Fixing build failures
-
Boilerplate generation: CRUD operations, DTOs, mappers
-
Documentation: Generating or updating docs
-
Refactoring: Mechanical code transformations
Challenges and Future Directions
Current Challenges
Non-deterministic behavior: Same prompt can produce different results, making testing difficult.
Rapid evolution: The AI landscape changes quickly, requiring constant adaptation.
Tool proliferation: Managing the growing ecosystem of AI tools and approaches.
Context management: Balancing between providing enough context and overwhelming the model.
Future Improvements
Better sandboxing: The team mentioned Incus Spawn for safer agent execution.
Skill refinement: Continuing to improve extension skills based on real-world usage.
Documentation evolution: Determining the right balance between RAG and direct documentation access.
Tool consolidation: Potentially combining or removing redundant tools.
Community Contributions
Philip expressed appreciation for the community’s early adoption and contributions:
-
Multiple pull requests from community members
-
Valuable feedback on tool design
-
Skill contributions and improvements
-
Bug reports and feature requests
The project is actively maintained on GitHub, and contributions are welcome.
Resources for Developers
Official Resources
-
Quarkus Agent MCP: https://github.com/quarkusio/quarkus-agent-mcp
-
Quarkus Skills Repository: https://github.com/quarkusio/quarkus-skills
-
Quarkus Dev Skills: https://github.com/quarkusio/skills (for Quarkus contributors)
-
Extension Maturity Matrix: https://quarkus.io/guides/extension-maturity-matrix
-
Model Context Protocol: https://modelcontextprotocol.io/
Key Takeaways
-
AI experience differs from developer experience - tools must target the agent as the primary user
-
Skills guide agents effectively - well-crafted skills dramatically improve agent performance
-
MCP provides standardization - the Model Context Protocol enables tool interoperability
-
Documentation integration is crucial - agents need access to accurate, version-specific documentation
-
Extension developers play a key role - quality skills and Dev MCP methods enhance the ecosystem
-
Review is still essential - agents are collaborators, not replacements for human judgment
-
TDD works well with agents - test-first development produces better results
-
Spec-driven development pays off - time spent planning improves implementation quality
-
The landscape is evolving rapidly - approaches that work today may change tomorrow
-
Community contributions matter - the project benefits from diverse perspectives and use cases
Conclusion
The Quarkus Agent MCP represents a significant step forward in AI-assisted development for Quarkus applications. By providing a standardized interface for coding agents to interact with Quarkus tools, documentation, and extension-specific knowledge, it enables developers to leverage AI more effectively throughout the application lifecycle.
The shift from developer experience to AI experience reflects a broader trend in software development: AI is becoming a first-class participant in the development process, not just a tool for individual developers. By designing tools specifically for this new user, the Quarkus team is helping shape how AI-assisted development will work in the future.
Whether you’re building new applications, maintaining existing ones, or contributing to the Quarkus ecosystem, the Quarkus Agent MCP offers new possibilities for productivity and collaboration. As the technology continues to evolve, the community’s feedback and contributions will be essential in refining these tools and patterns.
