Agentic Spring Boot Testing. Reliable, meaningful test suites with AI agents.
- Online Course & Skill Library - six hands-on modules plus seven agent skills you tailor to your project.
- Agent harnessing for testing - the setup that makes agents choose the right test type before writing a line.
- Don't just press Tab and Enter - learn how to build and maintain a fast, comprehensive test suite with your agent.
Sound familiar?
You ask Claude Code for tests. Twenty seconds later there are forty green tests and a confident summary. It feels like magic.
Two weeks later a bug ships that the suite should have caught. You open the test class: @SpringBootTest on top, five mocks, and assertions that check for status 200. The build takes 20 minutes now, and nobody remembers what those tests prove.
That is not the agent being bad at testing. It is the agent doing what every agent does without judgment: the most common pattern from its training data. Maybe it has happened to you. It happened in every team I consulted with this year.
Does this sound like your test suite since the agents arrived?
None of this is a developer problem. It is what every coding agent produces when nobody tells it how your project tests.
Forty green tests, few meaningful assertions
The agent delivers a full test class in seconds and every test is green. Look closer and many of them check only a status code or a non-null result, not the behavior that matters.
@SpringBootTest for a utility class
A date formatter gets a complete application context because that is the annotation the agent has seen most often. A plain JUnit test would run in milliseconds.
Twelve contexts, twenty minutes
Every generated class brings its own @MockitoBean mix, so context caching never hits, and each class starts its own Testcontainers. The build that took 3 minutes takes 20 and fails at random on CI.
Mocks of the class under test
The repository is mocked, the service is mocked, and sometimes the class the test is supposed to cover. The test passes and proves nothing.
Green on the PR, broken in production
The suite passes on every pull request. The bug ships anyway, because no test ever ran the real query, the real serialization, or the real database.
Review fatigue
Developers turn into auditors of tests they did not write. After the tenth 400-line generated test class, nobody reads closely anymore and nobody trusts the suite.
“This course is quite dangerous as it will leave you expecting the same level of high-quality material from every other course you take going forward.”
Your status quo before taking this course
Before
- You review generated tests line by line because you cannot tell which ones prove anything.
- Agents reach for @SpringBootTest for everything and the build grows with every PR.
- Every test class starts its own Spring context and its own containers.
- The suite is green while production breaks.
- Your CLAUDE.md has rules the agent ignores half of the time.
- You are not sure whether to let agents write tests at all.
After the course
- A harness that makes the agent pick the right test type before writing a line.
- Seven skills that encode unit, slice, integration, end-to-end and Testcontainers decisions the way I make them.
- A test suite focused on speed and fast feedback.
- Every test asserts behavior, with mocks only at real boundaries.
- A reviewer skill that flags anti-patterns before you open the PR.
- A test suite you trust enough to let agents refactor.
Same prompt, same project, different harness
Claude Code on Spring PetClinic, asked to write tests for the OwnerController. Once without any skills, once with the seven skills from this course. Scroll down and watch both sessions run.
What the seven skills enforce
Testing standards
One test type per concern: unit, slice or integration. The skill decides before a line of test code is written, and the reviewer skill checks the result.
Best practices
Assertions on behavior, mocks only at real boundaries, one shared Testcontainers setup, no @SpringBootTest by default.
Minimum overhead
LSP navigation instead of reading whole files, sliced contexts, and one cached integration context per build.
Parallelizability
Tests written to run in parallel forks from day one: no shared mutable state, isolated test data, reused containers.
Illustrative session, condensed. Output is shortened and numbers are rounded from a single local run; they will differ on your project and machine.
To be clear
This is not a prompt-engineering course
You will not learn magic prompts or yet another framework. You will learn how to harness any coding agent so it tests like a senior Spring Boot engineer: an online course that teaches the testing decisions, and a skill library that brings them into your project. And the skills are files you own, not a tool you rent.
- Works with Claude Code, GitHub Copilot and Cursor
- Plain Markdown, no vendor lock-in, no subscription
- Maven and Gradle projects, Spring Boot 3 and 4
“Honestly, it's the best course content on testing in general. Most importantly, it gives you the structure - how to navigate the testing field. Yet it still provides real-world examples. A good investment of money and time.”
What you get
The tool your agent is missing, the manual that explains it, and the complete testing education behind both.
Part 1
Online course
A pragmatic, hands-on course that teaches what you need to know: six modules, recorded on Spring PetClinic.
Part 2
Skill library
- unit-testing
- slice-testing
- slice-testing-webmvc
- integration-testing
- e2e-testing
- testcontainers-setup
- test-setup-reviewer
Result
Your project
- The agent picks the right test type before writing a line
- A fast, parallel suite with cached contexts
- The reviewer skill on every pull request
Seven agent skills, maintained
unit-testing, slice-testing, slice-testing-webmvc, integration-testing, e2e-testing, testcontainers-setup and test-setup-reviewer as SKILL.md files. Updates for 12 months, 24 for teams.
The 2-hour Agentic Testing course
25 lessons in 6 modules, recorded on Spring PetClinic. Watch how the skills are built and applied, then code along.
Three more courses included*
Testing Spring Boot Applications Masterclass, TDD with Spring Boot Done Right and Hands-On Mocking with Mockito. Your complete testing education. *Bundle and Team editions only.
The PetClinic reference test suite
The complete before-and-after test suite from the course, so you can diff what the skills changed.
My agentic development setup
The CLAUDE.md, AGENTS.md and agent configuration I use in my own Spring Boot projects, plus the equivalent setup for GitHub Copilot and Cursor.
Certificate of completion
A certificate for your training records once you finish all lessons.
Lessons stay yours
All video lessons remain accessible after the update window. English subtitles for every lesson.
Seven fine-tailored agent skills - ready for you to adopt and copy
These skills distill my 10+ years of hands-on project work into instructions your coding agent follows on every task.
Instead of generic AI output, your agent applies the same testing decisions I make:
When to write a unit test, when a slice test is enough, and how to set up Testcontainers without slowing down your build.
- Copy them into your project and your agent works with them immediately - no framework, no lock-in.
- Adapt the skills to your project in a matter of minutes.
- You get every future update as I refine them in my daily consulting work.
- unit-testing
- slice-testing
- slice-testing-webmvc
- integration-testing
- e2e-testing
- testcontainers-setup
- test-setup-reviewer
Anatomy of a skill
What is inside one SKILL.md
A skill is not a clever prompt. It is a small, readable file that carries the testing judgment of a senior Spring Boot engineer: what to test, which test type to pick, where the test belongs, and what a good one looks like. Your agent reads it before it writes a line.
Years of experience, compressed
Every rule comes from real projects: ten years of Spring Boot testing, consulting and reviews, written down as the decisions I make instead of the patterns an agent picks up from public code.
Judgment: what to test and how
Unit, slice, integration or end-to-end, and why. The skill decides the test type from the class under test, so the agent stops reaching for @SpringBootTest as its default answer.
References, not guesswork
Links to the Spring Boot, JUnit, Mockito and Testcontainers documentation that a rule builds on, so the agent looks up the current API instead of inventing one.
Examples to copy from
Each skill carries good and bad examples from the PetClinic reference suite. The agent has a template to follow, and you have a diff that shows what changed.
---
name: unit-testing
description: <when the agent picks this skill>
---
## Hard requirements
<rules every unit test must follow>
## Parallel by default
<how to keep tests isolated and parallelizable>
## Example
<a sample unit test to copy from>
## References
<docs the rules build on>
Fit for your project
- Written for a specific Spring Boot version: Spring Boot 3 and 4, Maven and Gradle.
- Brownfield and greenfield: they work in a legacy suite and in a service you start today.
- Expect some tuning: the rules are plain Markdown, so you bend them towards your conventions and your idea of a good test.
Curriculum
Six modules. Every lesson is hands-on in Spring PetClinic with Claude Code, with notes for GitHub Copilot and Cursor.
Why AI-generated tests are bad by default
What agents optimize for when you say "write tests", and why the result looks fine and proves nothing.
Building the harness
The project files that turn a generic agent into one that tests the way your team does.
The seven skills applied to Spring PetClinic
One skill per lesson, each applied to real PetClinic code, each result reviewed.
Making the suite fast
The settings and conventions that keep an agent-written suite under a minute.
The daily workflow
TDD, pull requests and maintenance with an agent that follows your rules.
Wrap-up
A checklist you can hand to your team and where to go from here.
Concepts you will take with you
Context starvation
why an agent without your test strategy defaults to @SpringBootTest and mocks everywhere
The four default failures
the checklist to spot agent-written tests that prove nothing
Slice first
the decision rule for unit, slice or integration test, encoded in a skill
One context per build
how cached contexts and reused containers keep the suite under a minute
The reviewer loop
letting the agent audit its own output before you read a single line
Harness over prompts
where an instruction belongs: CLAUDE.md, a skill, or the prompt
Philip Riecks - international speaker and Spring Boot testing expert
Your instructor
Philip Riecks - Founder of PragmaTech GmbH and rieckpil.de
I started developing Java applications in 2015. Since 2017 I have published Spring Boot testing content on rieckpil.de, and since 2018 on YouTube. As a consultant I spend my days inside client teams fixing slow and flaky Spring Boot test suites. The seven skills in this course are the ones I use in that work every day.
- 10+ years on the developer frontlines, 6 years as a consultant inside the engine rooms of 10+ Spring Boot teams
- 10,000+ students across my Spring Boot testing courses, including the Testing Spring Boot Applications Masterclass
- 20+ conference talks in the USA, Belgium, Spain, Germany and Switzerland
- Author of Testing Spring Boot Applications Demystified, Stratospheric and the Java Testing Toolbox
- Creator of the Spring Test Profiler and a weekly testing newsletter read by 10,000 developers
What students say about my testing courses
Feedback from the Testing Spring Boot Applications Masterclass, the course this one builds on.
“Philip has made a fantastic overview of the full testing landscape of Spring.”
Wim Deblauwe
Software Engineer
“I find it wonderful for learning how to test Spring Boot applications leveraging modern testing frameworks and libraries.”
Siva
Software Engineer, AtomicJar
“After watching the Testing Spring Boot Applications Masterclass course I feel more confident in writing different types of tests for my apps.”
Anton Ždanov
Full Stack Developer
“The depth and completeness of the content truly stands out. Exceptional content with comprehensive coverage and rich examples.”
Xavier Escudero
Course Student
“Your courses are genuinely excellent. Very focused and hands-on, far more so than many of the other resources on the internet or YouTube that essentially stop at Hello World. I've been a Java and Spring developer for many years, and I learned a lot from you, especially about integration testing.”
Oli
Course Student
“This is probably the best resource that I got in this regard for real-world TDD examples with Spring.”
Siddharth Goel
Course Student
Endorsed by
“Philip transfers this knowledge to you and his courses leave you smarter than before.”
Tom Hombergs
Founder, reflectoring.io
“Philip managed to publish high quality articles and videos covering a wide range of topics.”
Vlad Mihalcea
Founder, vladmihalcea.com
“Tons of actionable tutorials and content across the Spring universes. Highly recommended!”
Marco Behler
Founder, marcobehler.com
Is this course for you?
You have let agents write tests and stopped trusting the result
You know the green-but-empty test class. This course gives you the harness that turns the same agent into one that writes tests you would accept in review, plus a reviewer skill that catches the rest.
You have not let agents touch your tests yet
Good instinct. Start with the guardrails in place: install the skills, adopt my agentic development setup, and let the agent work inside them from the first prompt. You skip the cleanup phase most teams are in right now. If you still need the testing foundations, the bundled Masterclass covers them.
Pricing
Three editions. The Course Edition is for students who already own my testing courses. The Bundle and Team editions add the full course library, and differ in seats, the implementation workshop, support and the update window.
% Purchase Power Parity discount for
applied to the Course and Bundle editions - coupon is pre-filled at checkout.
For my students
Course Edition
The brand new online course and the skill library.
329€ 329€
1 seat · one-time payment
What you get
- Agentic Spring Boot Testing course and the full skill library
- Skill updates for 12 months
- Access to the on-demand online course
- Offline access (paid)
- Q&A via comments in the course
- Invoice for your employer
60-day money-back guarantee, no questions asked
For one developer
Bundle Edition
The new course plus my entire Spring Boot testing academy.
490€ 490€
1 seat · one-time payment
Everything in Course Edition, plus
Testing Spring Boot Applications Masterclass
TDD with Spring Boot Done Right
Hands-On Mocking with Mockito
- More than 16 additional hours of Spring Boot testing content
- 160+ additional course lessons
- Understand the fundamentals behind every skill
60-day money-back guarantee, no questions asked
For teams
Team Edition
Your whole team on the same skills, with a 2-hour implementation workshop on your codebase.
3,990€
10 seats · one invoice · 399€ per seat
Everything in Bundle Edition, plus
- 10 seats, every course for all seats
- Skill updates for 24 months instead of 12
- 2-hour implementation workshop on your codebase
- 30 days of async Q&A support
- Quote or purchase order on request
Larger team or need more hands-on time? info@pragmatech.digital
Need approval from your manager?
Use my ready-to-send email template. Copy the subject and body, fill in the placeholders and send it.
Hey! It looks like you are from .
We support Purchase Power Parity. The Course and Bundle editions price you see is % off the base price.
Use the coupon code during checkout.
No risk
100% satisfaction guarantee for 60 days
Not happy with the course or the skills? No problem. Write me within 60 days of getting access and I send you a refund. No questions asked.
Try everything on your own project
Install the seven skills, let your agent work with them in your codebase, and see the tests it writes. Sixty days is more than a full sprint cycle.
One email is enough
No form, no reason, no phone call. Write from the address you bought with and the refund goes back the same way you paid.
One exception: the Team Edition
For the Team Edition the guarantee ends once the 2-hour implementation workshop has taken place, because that time is already spent on your codebase.
Team Edition: your whole team on the same skills
One developer with the skills improves their own pull requests. Ten developers with the same skills get a consistent test suite, faster reviews, and a build that stays fast while the agents write more code. The Team Edition adds a 2-hour implementation workshop on your codebase, so the skills fit your conventions from day one.
- 10 seats, 399€ per seat, one invoice for your training budget
- 2-hour implementation workshop on your codebase, not on a demo project
- 30 days of async Q&A support and 24 months of skill updates
Larger team or need more hands-on time? Email me.
Team Edition
3,990€ for 10 seats
399€ per seat, below the Bundle Edition price. Quotes and purchase orders welcome; you get the quote within a day.
“Philip delivered an outstanding session in our Spring Boot CoP, breaking down testing concepts into clear, practical bites. His structured approach to unit, sliced, and integration testing resonated with us.”
Dustin Hütter
Engineer, REWE Digital
Frequently asked questions
Do I need the Testing Spring Boot Applications Masterclass first?
I already own the Masterclass or one of the bundled courses. Do I pay twice?
Which coding agents are supported?
Does it work with Maven and Gradle?
Which Spring Boot and Java versions are covered?
How long do I have access, and what happens after the update window?
Can I pay from a company training budget or buy for a team?
What if the course is not for me?
Give your agent the testing judgment it is missing
Seven maintained skills, four courses, one harness. Start on your own project today.
Enroll nowTeam of ten or more? See the Team Edition or email me for a quote. info@pragmatech.digital