From c82369b9ac7f7c6ab5307225b8d4b9759f5e094e Mon Sep 17 00:00:00 2001 From: James Cobb Date: Wed, 3 Jun 2026 12:08:50 -0600 Subject: [PATCH 1/9] Add EP249 summary blog post --- ...01-quarkus-insights-249-coding-agents.adoc | 540 ++++++++++++++++++ 1 file changed, 540 insertions(+) create mode 100644 _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc new file mode 100644 index 0000000000..334de5dbc2 --- /dev/null +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -0,0 +1,540 @@ +--- +layout: post +title: 'Quarkus Insights #249: Using Coding Agents with Quarkus' +date: 2026-06-01 +tags: insights ai coding-agents mcp claude developer-experience +synopsis: 'Philip Krüger demonstrates the Quarkus Agent MCP server, showing how coding agents can enhance the developer experience through skills, tools, and documentation integration for building Quarkus applications.' +author: jcobb +--- + +This summary was generated using AI, reviewed by humans - https://youtube.com/live/EczihvU1gG8[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 https://quarkus.io/[Quarkus] developer experience. Despite battling flu season and joining at 11 PM his time, Philip showcased the new https://github.com/quarkusio/quarkus-agent-mcp[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 https://quarkus.io/blog/[Quarkus 3.36 platform release], which includes: + +- **Tree shaking** for optimized builds +- **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 + +https://quarkus.io/guides/dev-ui[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 + +https://github.com/quarkiverse/quarkus-chappie[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 https://modelcontextprotocol.io/[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 https://github.com/quarkusio/quarkus-agent-mcp[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 https://hibernate.org/[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 https://claude.ai/[Claude Desktop]. + +**Manual Configuration** (using https://www.jbang.dev/[JBang]): +[source,json] +---- +{ + "mcpServers": { + "quarkus-agent": { + "command": "jbang", + "args": ["io.quarkus:quarkus-agent-mcp:LATEST"] + } + } +} +---- + +**Local Development** (using Java): +[source,json] +---- +{ + "mcpServers": { + "quarkus-agent": { + "command": "java", + "args": ["-jar", "/path/to/quarkus-agent-mcp-SNAPSHOT.jar"] + } + } +} +---- + +The server works with various AI harnesses including Claude, https://github.com/Pythagora-io/gpt-pilot[GPT Pilot], https://www.cursor.com/[Cursor], and others that support MCP. + +== Live Demo: Building a Vinyl Collection Manager + +Philip demonstrated the agent in action by asking it to create a vinyl collection management application: + +[source,text] +---- +Please create an app that I can use to manage my vinyl collection and add a nice web UI. +---- + +The agent automatically: + +1. **Selected the tech stack**: Chose Quarkus without being explicitly told (due to the MCP context) +2. **Refined requirements**: Asked clarifying questions about database and UI preferences +3. **Created the application**: Used the Quarkus CLI through MCP tools +4. **Built the features**: Implemented CRUD operations with https://www.postgresql.org/[PostgreSQL] backend +5. **Added a web UI**: Created a static HTML/JavaScript interface +6. **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 + +=== Dev MCP Integration + +- `search_tools` - Discover available Dev MCP tools dynamically +- `call_tool` - Execute Dev MCP tools (proxied through) + +=== Logging and Debugging + +- `get_logs` - Access application logs +- `set_log_level` - Adjust logging verbosity + +=== Skill Customization + +- `save_skill` - Persist skills locally +- `update_skill` - Modify existing skills +- `install_quarkus_skills` - Install official Quarkus 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: +[source,markdown] +---- +# 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_schema +---- + +=== Skill Generation Process + +Philip described an interesting approach to generating skills: + +1. Start two AI instances (one with https://www.anthropic.com/claude[Claude Sonnet], one with Claude Opus) +2. Have Sonnet attempt to build a feature (e.g., GraphQL endpoint) +3. When Sonnet struggles, ask Opus for help +4. Ask Opus to generate a skill based on what it learned +5. 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 +[source,text] +---- +.quarkus/ + skills/ + quarkus-rest.md + quarkus-hibernate-orm.md +---- + +**User-level**: Saved in user's home directory +[source,text] +---- +~/.quarkus/skills/ +---- + +**Enhancement mode**: Add organization-specific guidance without replacing the base skill: +[source,markdown] +---- +--- +enhance: true +--- + +## Company-Specific Guidelines +- Always use our custom error handling pattern +- Include audit logging for all mutations +---- + +== Documentation 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: + +1. **Maven plugin**: Extensions use a Maven plugin to generate vector database SQL exports from their documentation +2. **Aggregation**: The agent MCP aggregates documentation from all extensions and dependencies +3. **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: + +[source,text] +---- +deployment/src/main/resources/quarkus-skill.md +---- + +The 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 https://github.com/quarkiverse[Quarkiverse] extensions, add this to your POM: + +[source,xml] +---- + + io.quarkus + quarkus-doc-maven-plugin + ${quarkus.version} + +---- + +=== 4. Follow the Extension Maturity Matrix + +The https://quarkus.io/guides/extension-maturity-matrix[Extension Maturity Matrix] now includes AI experience criteria. Following these guidelines ensures your extension works well with coding agents. + +== Team's AI Development Practices + +The team shared their diverse approaches to AI-assisted development: + +=== Tools and Models Used + +**IDEs and Harnesses**: +- https://claude.ai/[Claude Desktop] (most popular) +- https://www.jetbrains.com/idea/[IntelliJ IDEA] with AI Assistant +- https://www.cursor.com/[Cursor] +- https://github.com/Pythagora-io/gpt-pilot[GPT Pilot] +- https://www.jetbrains.com/qodana/[JetBrains Qodana] + +**Models**: +- Claude (Sonnet and Opus) +- https://github.com/features/copilot[GitHub Copilot] +- https://ai.google.dev/gemini-api[Google Gemini] +- https://www.ibm.com/watsonx[IBM watsonx] + +=== 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 https://github.com/Pythagora-io/gpt-pilot[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 and Qodana +- Uses Test-Driven Development (TDD) with agents +- Writes tests first, then has agent implement +- Finds TDD particularly effective for reproducers + +=== Common Themes + +1. **Not necessarily faster for new features**: AI doesn't dramatically speed up complex feature development +2. **Excellent for maintenance**: Fixing bugs, updating dependencies, handling CI failures +3. **Great for boilerplate**: Generating repetitive code structures +4. **Requires review**: All code is reviewed before merging +5. **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: + +=== Six Months Ago +- Approve every single change +- Watch every step +- Constant intervention required + +=== Today +- Outline the approach +- Let the agent work independently +- Review the final result +- Treat it like a skilled junior developer + +**Key insight**: Modern agents can work autonomously on well-defined tasks, but still require human review and guidance on architecture decisions. + +== Test-Driven Development with Agents + +Holly emphasized the value of TDD when working with agents: + +=== The TDD Workflow + +1. **Write the test first**: Define expected behavior +2. **Verify it fails**: Ensure the test catches the issue +3. **Have agent implement**: Let the agent write code to pass the test +4. **Review the solution**: Ensure quality and correctness + +=== Benefits + +- **Focused tests**: Tests target specific functionality, not just coverage +- **Better reproducers**: Excellent for bug reports and issue reproduction +- **Guided development**: Tests provide clear success criteria +- **Reduced boilerplate**: Agents handle test setup code + +=== Caveat + +Asking agents to "write tests" without guidance often produces low-value tests that are "paid by the line." TDD keeps tests meaningful and purposeful. + +== Spec-Driven Development + +Philip and Max advocated for spending more time on specifications: + +=== The Spec-First Approach + +1. **Define the plan**: Outline architecture and approach +2. **Persist the plan**: Save it for reference +3. **Follow the plan**: Have the agent implement according to spec +4. **Iterate on the plan**: Refine based on results + +=== Benefits + +- **Better results**: More time planning = better implementation +- **Clearer communication**: Specs serve as documentation +- **Easier review**: Reviewers understand the intent +- **Reusable patterns**: Specs can be adapted for similar features + +== 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 + +=== Less Effective Use Cases + +- **Complex architecture decisions**: Still requires human judgment +- **Novel algorithms**: Agents struggle with truly new approaches +- **Performance optimization**: Requires deep understanding +- **Security-critical code**: Needs expert review + +=== The "Soundboard" Pattern + +Philip highlighted using agents as a soundboard for design discussions, especially valuable when working across time zones without human colleagues available. + +== 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 https://get-inca.com/en/[Inca Sandbox] 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 https://github.com/quarkusio/quarkus-agent-mcp[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/ + +=== Getting Started + +1. Install the Quarkus Agent MCP in your preferred AI harness +2. Try building a simple Quarkus application +3. Explore the available skills and tools +4. Customize skills for your organization's needs +5. Contribute improvements back to the community + +== Key Takeaways + +1. **AI experience differs from developer experience** - tools must target the agent as the primary user +2. **Skills guide agents effectively** - well-crafted skills dramatically improve agent performance +3. **MCP provides standardization** - the Model Context Protocol enables tool interoperability +4. **Documentation integration is crucial** - agents need access to accurate, version-specific documentation +5. **Extension developers play a key role** - quality skills and Dev MCP methods enhance the ecosystem +6. **Review is still essential** - agents are collaborators, not replacements for human judgment +7. **TDD works well with agents** - test-first development produces better results +8. **Spec-driven development pays off** - time spent planning improves implementation quality +9. **The landscape is evolving rapidly** - approaches that work today may change tomorrow +10. **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. + +====== Watch the full episode on the https://www.youtube.com/quarkusio[Quarkus YouTube channel] and explore more at https://quarkus.io[quarkus.io]. Join the conversation on https://quarkusio.zulipchat.com/[Zulip] or raise discussions on https://github.com/quarkusio/quarkus-agent-mcp[GitHub]. \ No newline at end of file From cc51f0dcd259df35d402c8f7c9b421ed3fac72f9 Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:02:16 -0600 Subject: [PATCH 2/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index 334de5dbc2..897a6de86d 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -19,7 +19,7 @@ In episode 249 of Quarkus Insights, Philip Krüger from Australia joined the tea Before diving into coding agents, the team announced the https://quarkus.io/blog/[Quarkus 3.36 platform release], which includes: -- **Tree shaking** for optimized builds +- **OIDC Spiffe authentication - **Signals** - a new eventing infrastructure - Enhanced developer experience features From b9459593fa7d0e5d24b06c2cc163edf416ed37eb Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:02:36 -0600 Subject: [PATCH 3/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index 897a6de86d..dc662627e1 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -17,7 +17,7 @@ In episode 249 of Quarkus Insights, Philip Krüger from Australia joined the tea == News: Quarkus 3.36 Platform Release -Before diving into coding agents, the team announced the https://quarkus.io/blog/[Quarkus 3.36 platform release], which includes: +Before diving into coding agents, the team announced the https://quarkus.io/blog/quarkus-3-36-released/[Quarkus 3.36 platform release], which includes: - **OIDC Spiffe authentication - **Signals** - a new eventing infrastructure From 2f1e647333f8fbc4fef7973f12af11df91466c94 Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:02:48 -0600 Subject: [PATCH 4/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index dc662627e1..ea1e224491 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -23,7 +23,7 @@ Before diving into coding agents, the team announced the https://quarkus.io/blog - **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. +For those interested in the design decisions behind signals, the team recorded a https://www.youtube.com/watch?v=_VY9G_DMFjw[detailed presentation] during the Quarkus community call with extensive discussion about the architecture and future direction. == The Evolution: From Dev UI to AI Experience From 97c362d0dae94e9e74ce166cbb3fa8e3c737dae0 Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:03:05 -0600 Subject: [PATCH 5/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index ea1e224491..5e3f06613d 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -332,7 +332,7 @@ The https://quarkus.io/guides/extension-maturity-matrix[Extension Maturity Matri == Team's AI Development Practices -The team shared their diverse approaches to AI-assisted development: +In response to questions on the live-stream chat, the team shared their diverse approaches to AI-assisted development: === Tools and Models Used From 76483866851b4c00379006a9a966ee7d7c935e5e Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:03:18 -0600 Subject: [PATCH 6/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 1 + 1 file changed, 1 insertion(+) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index 5e3f06613d..fbcbce4a4f 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -339,6 +339,7 @@ In response to questions on the live-stream chat, the team shared their diverse **IDEs and Harnesses**: - https://claude.ai/[Claude Desktop] (most popular) - https://www.jetbrains.com/idea/[IntelliJ IDEA] with AI Assistant +- https://bob.ibm.com/ - https://www.cursor.com/[Cursor] - https://github.com/Pythagora-io/gpt-pilot[GPT Pilot] - https://www.jetbrains.com/qodana/[JetBrains Qodana] From 9562ab75838b0e6f6f0f8ed4a6f550c5c38fdaf2 Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:03:53 -0600 Subject: [PATCH 7/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index fbcbce4a4f..99f9aeba82 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -480,7 +480,7 @@ Philip highlighted using agents as a soundboard for design discussions, especial === Future Improvements -**Better sandboxing**: The team mentioned https://get-inca.com/en/[Inca Sandbox] for safer agent execution. +**Better sandboxing**: The team mentioned https://github.com/Sanne/incus-spawn[Incus Spawn] for safer agent execution. **Skill refinement**: Continuing to improve extension skills based on real-world usage. From d4f716d1b6d550d350c396a8992b865dabfe650d Mon Sep 17 00:00:00 2001 From: insectengine Date: Thu, 4 Jun 2026 06:04:02 -0600 Subject: [PATCH 8/9] Update _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc Co-authored-by: Holly Cummins --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index 99f9aeba82..491a188019 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -372,7 +372,7 @@ In response to questions on the live-stream chat, the team shared their diverse - Combines IDE refactoring with AI generation **Holly's Approach**: -- Swaps between Claude and Qodana +- 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 From c3e5e3bc1966b023ca58f8b8b04cd3939efd3257 Mon Sep 17 00:00:00 2001 From: James Cobb Date: Thu, 4 Jun 2026 07:36:41 -0600 Subject: [PATCH 9/9] Edited as per Holly's suggestion. --- _posts/2026-06-01-quarkus-insights-249-coding-agents.adoc | 1 - 1 file changed, 1 deletion(-) diff --git a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc index 491a188019..2c60c38021 100644 --- a/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc +++ b/_posts/2026-06-01-quarkus-insights-249-coding-agents.adoc @@ -348,7 +348,6 @@ In response to questions on the live-stream chat, the team shared their diverse - Claude (Sonnet and Opus) - https://github.com/features/copilot[GitHub Copilot] - https://ai.google.dev/gemini-api[Google Gemini] -- https://www.ibm.com/watsonx[IBM watsonx] === Workflow Patterns