# Tried IBM Bob, an AI agentic coding assistant. Built a basic Java microservices architecture in ~15 minutes > Source: > Published: 2026-09-09 05:44:07+00:00 I've been trying out **IBM Bob**, an AI coding assistant, and recently watched a demo that caught my attention. A lot of coding demos focus on generating a single function or API. This one was different. The goal was to start with a high-level idea and see how far a few prompts could take a Spring Boot microservices project. The first prompt was pretty simple: ``` Design a customer order management system with separate services for customers, orders, inventory, and notifications. ``` Bob broke the problem down into multiple services and proposed a reasonable microservices architecture. It felt similar to the kind of architecture sketch you'd normally put together before writing any code. The next step was expanding that architecture into actual services. ``` Generate Spring Boot microservices for the architecture above. Include REST APIs, service layers, JPA repositories, Swagger documentation, and standardized error handling. ``` From there, Bob generated: What surprised me wasn't any individual component. It was how much of the repetitive setup work was handled automatically. Once the services were in place, the focus shifted to reliability. ``` Add retry patterns and health checks to the order service. ``` Bob then generated: These are the kinds of things that often get postponed until later in a project, so it was interesting to see them added through a follow-up prompt. Finally, the generated services were started and validated. ``` Start all services, verify health endpoints, and open the generated API documentation. ``` The workflow included: At that point, there was a runnable system rather than just generated source files. The interesting part wasn't that AI generated Java code. We've all seen that before. What stood out was the progression: ``` Idea ↓ Architecture ↓ Multiple Services ↓ Resilience ↓ Observability ↓ Runnable System ``` All of that came from a small series of prompts rather than manually building everything piece by piece. Is it production-ready? Obviously not. There are still questions around security, testing, deployment, performance, governance, and long-term maintainability. But as a way to bootstrap a cloud-native Java project, it was impressive to see how much groundwork could be laid in a short time. Has anyone here used **IBM Bob**, **Claude Code**, **Cursor**, **GitHub Copilot**, or similar agentic coding tools for Java/Spring Boot projects? What's the most useful thing you've had them build, and where do you still find yourself taking over manually?