Agentic Coding for Java and Spring Teams

Where Java helps agents and where it hurts

Java is a good language for coding agents in one important way: static types and a strict compiler give precise, immediate feedback. An agent that breaks a method signature finds out at the next compile, not in production. The difficulties lie elsewhere:

• Slow builds: a full multi-module build can take many minutes, and an agent that runs it after every edit wastes most of its time waiting.
• Hidden behavior: Spring auto-configuration, proxies and annotation processors like Lombok mean that much of what happens is not visible in the source file.
• Version drift: agents have seen every Spring and Java version. Without guidance they mix javax.* and jakarta.* imports or suggest APIs from the wrong major version.

Give the agent a fast feedback loop

The single most effective step is to document narrow build and test commands in the instruction file (CLAUDE.md or AGENTS.md):

• Maven: mvn -pl billing -am test -Dtest=InvoiceServiceTest -Dsurefire.failIfNoSpecifiedTests=false builds only the module and its dependencies and runs one test class.
• Gradle: ./gradlew :billing:test --tests "*InvoiceServiceTest", ideally with the build cache enabled.
• Spring test slices such as @WebMvcTest or @DataJpaTest start much faster than a full @SpringBootTest. Tell the agent to prefer them for new tests.
• If integration tests use Testcontainers, make sure the agent's environment can run Docker, or mark those tests as CI-only.

Also pin the facts the agent tends to guess: Java version, Spring Boot version, the persistence approach, the logging setup and how configuration properties are structured.

Working in large monorepos

In repositories with dozens or hundreds of modules, scope is everything. Start the agent in the module it should change, add short per-module instruction files describing boundaries and owners, and ask for a plan before code. Keep pull requests small: one module, one concern. Agents search code quickly with text search, but they do not see what your IDE's index sees, so name the relevant interfaces and entry points explicitly.

Legacy modules and migrations

Upgrades from older Java versions or from Spring Boot 2 to 3 – with its Java 17 baseline and the move to the Jakarta namespace – are a strong use case, but not for the agent alone. Let deterministic recipes from OpenRewrite do the mechanical bulk, then use the agent for what remains: compile errors in custom code, broken tests, deprecated APIs without a recipe. For legacy modules without tests, have the agent write characterization tests that pin current behavior before anything is changed.

Review and guardrails

1. Architecture tests: ArchUnit rules make layer boundaries executable, so violations fail the build instead of relying on reviewers.
2. Static analysis in CI: Checkstyle, SpotBugs, PMD, Error Prone or SonarQube, whatever your team already trusts.
3. Dependencies: no new libraries without approval; check licences and known vulnerabilities.
4. Spring-specific review points: transaction boundaries (self-invocation bypasses the proxy), N+1 queries in JPA, exception handling, thread safety in singleton beans.
5. Human approval: the reviewer must understand the change, not just see green checks.

See also our guide on legacy code modernization with AI agents.

How jocapps helps

neooutput runs hands-on agentic coding workshops and team trainings in English and German, on-site or remote, where Java teams set up instruction files, feedback loops and review rules and leave with working results. If you need delivery capacity, OnlineAppCreator builds custom software, hardens AI-built prototypes for production and offers long-term SLAs. Formats are described on our agentic coding workshops page; a free 30-minute intro call is available via the meeting planner.