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?