If you're not doing agentic engineering, you will fall behind.
Every team that doesn't adopt agentic engineering will be out-shipped by one that does — at a fraction of the cost, in a fraction of the time, with more quality.
I spent the last four months refining an agentic engineering loop on a production SaaS. With the right tools and structure, the code is better than what I write by hand. Consulting brings that loop into your team's codebase.
Talk resources or team implementation.
The Spring I/O talk is the entry point. From there, you can study the material yourself or bring the workflow into a team codebase.
Take the talk home
Slides, learn.md, and the full toolbelt from Claude Code for Spring Developers. Use the material in your own Spring project and replay the exercises at your own pace.
Open resources ↓Adapt it to your team
Focused help for teams that need their own context files, skills, hooks, MCP wiring, and enablement around the way they already build Spring and JVM software.
See consulting ↓Four months of real numbers on a real SaaS.
PhotoQuest is the wedding photo game platform I founded and still run. Year three, 300+ weddings served. You only get one shot at each — a bad deploy on a Saturday evening is not recoverable. That's the constraint behind the talk and the consulting work.
Mid-December to mid-March — four months. Not generated garbage: feature commits grouped by vertical slice, tests that cover behaviour, static-analysis constraints that keep deprecated APIs and forbidden imports out of the codebase. Reliability went up over the same window — Sentry errors down.
Engineering quality doesn't disappear when AI writes code. It migrates to specs, tests, constraints, and risk management. — Thoughtworks, Deer Valley 2026
A focused agentic coding setup for your team.
Consulting adapts the loop to the way your team actually builds software: your repo, your tests, your review habits, your release risks.
Project memory that survives sessions
AGENTS.md / CLAUDE.md context, project conventions, build commands, and the failure notes that keep agents from rediscovering the same mistakes.
Workflows for your stack
Reusable skills for planning, TDD, focused test runs, commits, restart loops, and review flows that match your Spring Boot, Gradle, Kotlin, Java, and database setup.
Constraints that actually run
Command policy, post-edit lint feedback, commit gates, MCP integrations, and lightweight evals so the workflow gets safer as it gets faster.
Drop learn.md in your project. Claude becomes your tutor.
A single file that turns your own Spring project into the training ground. Claude reads it, greets you, and teaches you Claude Code hands-on — using your real code, your real conventions, your real friction.
How to use it
- Download
learn.mdinto the root of your Spring project. - Open Claude Code in that directory.
- Prompt:
Read learn.md and act as my Claude Code tutor. - Pick a mode — walkthrough (7 short chapters) or free-form Q&A.
Seven chapters, seven exercises
Setup → CLAUDE.md → Workflows → Skills → Hooks → MCP → Tips. Each chapter ends with one real change you ship to your own project. No toy examples.
Ask anything, anytime
You heard the talk. You know the shape. Skip ahead, jump back, ask "why." The tutor prompt lets Claude answer off-topic without losing the thread.
Claude uses your real codebase
Every exercise runs against your actual project — your build tool, your package structure, your conventions. By the end of the session, you have shipped one real change.
Everything I showed on stage.
The full toolbelt from Claude Code for Spring Developers, grouped the way the talk was structured: Context, Skills, Hooks, MCP, Workflows, Tips. Take what solves your friction first. View the slides ↗
# Context — Every Session Is Day One
My full CLAUDE.md for Spring Boot 4, Kotlin, jOOQ. Earned line by line, not generated. The scaffolding every new session starts from.
Rahul Garg (Principal Engineer, Thoughtworks) on externalising decision context into living documents. What you write down today is what the agent reads tomorrow.
Matt Pocock's full pattern for agent instruction files. Structure, anti-patterns, worked examples — the thing to copy before writing your own.
# Skills — The Documentation You Should Have Written
The AI interviews you before implementation. 8 rounds, 20+ design decisions, a 171-line spec you'll actually build from.
Strict TDD: RED → GREEN → REFACTOR, every phase tracked with TodoWrite. No skipping, no claiming green when red is still the truth.
Run tests headless, return only the failures. No full stack traces, no context pollution, no noise for the agent to filter out.
Group uncommitted changes into logical feature commits. An 8-line prompt, cleaner history, no more commit-and-forget.
Stop, start via IntelliJ MCP, wait for ready, check logs for errors. MCP wrapped in a workflow the agent can re-run itself.
Clean history from messy sessions. 46 debugging commits → 10 reviewable feature commits the team can actually read.
# Hooks — The Rules That Actually Stick
SessionStart, PreToolUse, PostToolUse, SessionEnd. Command, http, prompt, agent types. Every point in the session loop is a hook.
PreToolUse / Bash — block git push, reset --hard, clean -fd, branch -D. Exit 2 is a hard block the agent can't argue its way past.
PreToolUse / Bash — block every commit if lint, compile, or type check fails first. The constraint compounds; that mistake can't happen again.
PostToolUse / Edit|Write — feed Detekt / Checkstyle violations straight into the next turn. Self-correction loop, no human in between.
SessionEnd — warn when the CLI closes with uncommitted work. Saves the half-finished branch you were about to walk away from.
# MCP — One Protocol, Every Tool
Reformat, rename, execute_run_configuration. The IDE becomes an API the agent calls — a refactor tool, not just a search tool.
Read tickets, update status, pick up the next task. Organised my whole backlog in a few prompts — no more context-switching to Linear.
Investigate production errors directly from the agent. No more pasting stack traces from Sentry into the terminal.
Up-to-date documentation for every library you actually use. Resolved from Maven coordinates — no training-cutoff drift.
Build your own MCP server in Spring. Need something custom for your stack? Start here — the official starter makes it trivial.
The full IntelliJ API — debugger, refactorings, inspections, screenshots. The agent becomes the user, not the developer.
The protocol itself. Read once, understand every MCP tool you'll ever install or build. The one-pager that ties it all together.
# Workflows — From Vibe Coding to Agentic Engineering
Describe, watch, redirect. Where everyone starts — and where you should stay for anything on a critical path.
Shift+Tab to enter plan mode. Claude explores, proposes a plan, you review before any code actually lands.
Drive the design up front. /interview → spec → phased plan → TDD. Drift stays out because the spec is fixed.
What breaks when spec-driven scales without guardrails. Skills like /frontend-design and agent-browser drifting across phases P1–P7.
Fully autonomous overnight loop. Only safe once hooks, skills, and a sandbox are already in place — don't skip here.
# Tips — The Tools Behind the Workflow
Filesystem + network isolation. Seatbelt on macOS, Bubblewrap on Linux. Auto-allow kills permission prompts without sacrificing safety.
Open-source, local, unlimited speech-to-text. Voice is faster than typing for planning, reviews, and long-form thinking.
wt switch -c -x claude — branch + worktree + Postgres + LocalStack + IntelliJ + Claude in one step. Three agents, zero conflicts.
# Reading list
Adjacent reading — not covered on stage. Sharper framing of why the classical lifecycle doesn't survive agentic development.
Matt Pocock, Boris Cherny, Kun Chen, Thariq Shihipar, Andrej Karpathy
"If an AI generates code from a spec, the spec is now the highest-leverage artifact for catching errors." Thoughtworks, Deer Valley 2026.
Java-specific perspective on compounding engineering. How agents get better over time, once per codebase, if you let them.
Anthropic's own guide on conciseness, naming, feedback loops, and skill anti-patterns. Worth rereading every few skills you write.
Ground truth for every feature and configuration option. The page you'll come back to most once the CLI starts feeling natural.