200+ international talks (Devoxx, SpringOne, Microsoft Build…)
Today: shipping real projects by managing AI agents
💭 The project I never had time to build
I always wanted a real developer UI for Spring Boot.
🔭 The itch
Every Spring app is a black box in development
Actuator gives you raw JSON, not a console
I wanted health, metrics, security and tracing in one embedded UI
🧱 The catch: it's massive
~40 panels, each = backend + frontend + tests
Deep integration across a dozen JVM subsystems
By hand, one experienced dev: 6.5–8.5 months
I'd shipped a slice of this in JHipster years ago, but only for generated apps. A real console for any Spring Boot app sat on my wishlist for years. Too big to justify, until I stopped writing the code myself.
⚡ Then I did it in 11 days
223
pull requests merged
11
calendar days · v1 in < 2 weeks
~20
PRs merged per day
83k
lines of code shipped
Not by typing faster. I didn't even open my IDE. I managed a fleet of AI agents while I architected, reviewed and steered.
The agents did the scaffolding, the panels and the tests. I did the judgement.
🖥️ What I built: BootUI
A production-grade Spring Boot 4 starter that adds an embedded, local-only developer console to your app.
🧩 Multi-module & deeply integrated
5-module Maven build · Spring Boot 4 / Java 17
Actuator, Spring Security, Flyway/Liquibase, Hibernate
📦 Open source at github.com/jdubois/boot-ui · docs at julien-dubois.com/boot-ui
📐 The measured facts · v1.0.0
Derived from git history, PR metadata and code metrics, not time-tracking logs.
~264
commits on main
~223
squash-merged PRs (to #239)
~50k
Java lines · ~461 files · ~81 test classes
~52
Vue components · ~40 panels · ~35 e2e specs
~83k
total tracked source lines
~116
test suites (~81 Java + ~35 Playwright)
~5,800
doc lines + a VuePress site
5
Maven modules · 1.0.0 released
👥 One human driver + the Copilot agent (~44 commits), with dependabot, github-actions & one collaborator.
Part 01 · The proof
01
Calculating the performance gains
11 days of agents vs. the honest by-hand estimate.
✅ With AI: the bottom line
Built through a tagged 1.0.0 release by one developer driving the GitHub Copilot coding agent.
~11 days
calendar time, to 1.0.0
~80–110 h
actual human hands-on effort · ≈ 2 intense solo weeks
~20 / day
merged PRs · ~223 in ~11 days
A cadence of ~20 PRs/day with an AI agent co-authoring commits is impossible to achieve by hand. The agent did the typing; the human dispatched many asynchronous tasks in parallel.
🔍 With AI: the evidence
📈 Velocity
~223 merged PRs / ~10.8 days (~264 commits)
Commit clock runs ~05:00 → midnight most days
Consistent with parallel async tasks, not continuous typing
🤖 Authorship pattern
"Copilot" is a named commit / PR author (~44 commits)
Token charts, a proxied-Hikari fix, a docs refactor
Polish that is itself several days of solo work
🧭 Where the human time went
Writing prompts, reviewing & merging ~223 PRs
Resolving CI failures (Spring Boot 4, Flyway 11, OTLP)
Review-and-orchestrate, not write-every-line
🛠️ Without AI: the honest estimate
One experienced Spring Boot + Vue developer, no AI codegen, through the same polished 1.0.0.
6.5–8.5
months of full-time work · ~28–36 weeks
~1,100–1,450
hours of hands-on effort
~40
feature panels = the dominant cost
🧮 Cross-check: a COCOMO "organic" estimate on ~50 KLOC yields 100+ person-months, which is too high because much of the code is repetitive scaffolding. A domain-expert solo figure of ~7.5 months is the defensible middle ground.
🗂️ Without AI: where ~7 months goes
Estimated weeks per phase · one senior developer, no AI codegen.
Lighter bar ends show the ranges.
Overall estimate~28–36 wk ≈ 6.5–8.5 mo
⚖️ The verdict: with vs. without AI
With AI: project figures. Without AI: a solo-work estimate for the same 1.0.0 release.
Calendar timeHuman effort
Lighter bar ends show the ranges. Calendar scale uses 30-day months.
Throughput
~20 PRs/day, parallel vs. a few features/week, serial
Human's role
Architect + reviewer vs. author of every line
40 panels
Near-free to replicate vs. repetition as the biggest cost
From months of solo work to 11 days of agent-assisted delivery.
Part 02 · The recipe
02
How to run it yourself
Six ingredients for agentic engineering.
Agentic engineering, not vibe coding
~$2,000 of tokens across the sprint — about $9 per merged PR. That's the cheap part. The real question is when you pay for the code.
🎲 Vibe coding — low up front
No specs, no harness: you start shipping immediately
You pay in retry loops, and again six months later reverse-engineering code nobody understands
That's the maintenance tax — invisible on day one
🏗️ Agentic engineering — pay first
Specs, tests and CI cost you real days before the first agent runs
They keep your agent iterating toward a solid solution, rather than rushing out an incorrect answer
The harness takes real investment up front, but skipping it costs more later
12 weeks and 552 more merged PRs later, the maintenance tax still hasn't come due. That's the harness paying back its up-front cost.
1
Ingredient
Pick the right model for the task
🧠 Workhorse
GPT-5.5 Extra-High reasoning handles most of the work, ~90% of tokens served from cache.
🎯 The tricky parts
Claude Opus 4.8 and Gemini 3.1 Pro. Three strong models, cross-checking each other to find the best fix.
⚡ The easy stuff
A smaller model or "Auto" mode for simple, mechanical tasks. Fast and cheap.
💰 The whole bill
~2.7B
total tokens
~95%
served from cache
120M
fresh input · 15M output
~$2,000
total cost
2
Ingredient
Write the specifications
📜 Technical standards · AGENTS.md
Set the conventions once: stack, build, test, style
Repository instructions define the rules, not every task's procedure
Per-panel conventions so 40 panels come out consistent
🎯 Complete, clear business specifications
What to build, where, what "done" looks like
Acceptance tests the implementation must pass, even when using a skill
Small, self-contained, no hidden dependencies
The spec is the product now. The better the brief, the less you babysit.
3
Ingredient
Build the test harness
✅ A build + test they can run
One command runs compile, unit and e2e: green or red
Agents run the checks after using skills and tools, before opening a PR
No tests = you can't trust the output
🛡️ CI is the trust layer
~116 test suites · ~81 Java + ~35 Playwright
CodeQL + e2e gate every PR to main
This is what lets you merge ~20 PRs/day safely
You can't read every line of 223 PRs. A green build you trust is what makes the volume reviewable.
📏 Rules, specs and checks—in numbers
The repository foundation for ingredients 2 and 3: instructions, specifications and checks. Skills and code tools complement it.
63
lines of always-on house rules copilot-instructions.md
6
path-scoped rule files 156 lines, glob-attached
2,083
lines of CI 8 workflows · 121 steps
641
test files 536 Java · 105 Playwright
📋 Keep the always-on file short
Static — 63 lines sent on every call. You pay for it every time, so it stays short
Dynamic — 6 rule files attach only when their glob matches. Quarkus rules never load for a Vue change
📐 Put the detail in the spec
2,670 lines in SPECIFICATION.md — the behaviour contract
~13,700 doc lines total, reviewed in PRs exactly like code
On Terminal Bench 2.0, a team moved a coding agent from outside the Top 30 to the Top 5 by changing only the harness — no model change at all.
~220 lines of instructions steer 2,083 lines of CI and 641 test files. Keep always-on instructions short; load task-specific details only when needed.
4
Ingredient
Equip your agents
From my recent BootUI sessions: reusable skills for the workflow, Java code intelligence when needed.
📚 Skills: reusable workflows
Impeccable — craft beautiful Web designs, fix accessibility issues
orchestrate — coordinate advisor audits across sessions
agent-merge — PR review, CI and conflict follow-ups
bootui-release — a custom skill written specifically to guide a BootUI release
🔎 Java LSP: occasional code intelligence
Ask the language server about symbols, not just matching text
Used to explore advanced Java modules and inspect code during review
The project needs to be indexed by the language server first
Skills, MCP servers and tools connect agents to documentation, data and external systems.
Recorded examples, 9 August–8 September 2026, plus the custom release skill; not a claim about the original sprint.
5
Ingredient
Split the work, run agents in parallel
🧩 Make it parallel-ready
~40 near-identical panels = perfect to fan out
One task per agent: small scope, clear goal
One branch / worktree each, no collisions
🚀 A fleet, not one chat
GitHub Copilot App: many agents live on one machine
Mobile app: agents in Docker containers, on the go
Your throughput isn't your keyboard. It's your briefs.
The whole point is parallelism. Don't babysit one agent. Run ten.
🧑✈️ The mindset shift
I didn't open my IDE. I wasn't the developer. I was the manager.
🧑✈️ You · the manager
🎛️ Panels
clone the ~40 feature panels
🔌 Integrations
the deep JVM subsystems
🎨 Frontend
the embedded Vue SPA
🏗️ CI & docs
release, tests, VuePress
Many agents in parallel. You brief, review, merge.
You don't type faster. You ship what used to take months.
6
Ingredient · The daily loop
Drive the daily loop
⚡ most of the work: you, driving the fleet
9am11am2pm5pm7pm↻
☕ MergeLand last night's deep plans
Spec & launchBrief tasks, fan out the fleet
DriveReview, merge, re-task, live
DriveMost PRs land by evening
🌙 QueueA few deep plans for the night
↻ Repeat×~11 days → v1.0.0
Day: the engine
Hands-on all day: spec, launch, review, merge, re-task. Most of the ~20 PRs a day land right here.
Evening: hand off
Queue a few deep, long-running plans before you step away.
Night: the bonus
A handful of deep autonomous runs finish by morning. The minority, not the engine.
Let a few deep plans run overnight
The day is the engine. The night is a bonus shift: before you log off, hand a few deep, long-running plans to autonomous agents. These are the big jobs you don't want to babysit, and they land by morning while you're away.
🔌 Deep integration
Security filter chains: 37 rules, wired & tested
long run · 3 PRs
🧪 Test generation
Push coverage across the 116 suites
long run · 2 PRs
♻️ Big refactor
Reshape the Actuator data layer
long run · 2 PRs
A few deep plans, finished by morning. A bonus on top of your day, not a replacement for the driving.
Merge the results over coffee
☕ First thing, over coffee
Triage the few deep overnight PRs
Merge the green ones fast
Drop or re-task what didn't land
Cherry-pick the good parts of the rest
Then start driving the day's fleet
🔎 Review is the real bottleneck
It's not the typing anymore. It's the merging. Make review a fast, trusted ritual you run all day, not a line-by-line slog.
Drive all day, merge as you go, hand off a few deep plans at night. ~11 days to a tagged 1.0.0.
📋 The six ingredients of agentic engineering
1Pick the right model for the task — balance capability, speed and cost.
2Write the specifications — repository rules, scoped tasks and acceptance criteria.
3Build the test harness — runnable tests and CI checks before merge.
4Equip your agents — skills for workflows, tools for code intelligence and execution.
5Split the work, run agents in parallel — one task and branch each; you brief, review and steer.
6Drive the daily loop — drive by day, let a few deep plans run overnight, merge the results over coffee.
If there's one slide to screenshot, this is it.
🧨 Why the multiplier was so large
This codebase is unusually well-suited to AI, for two reasons. Not every project gets 17–23×.
🔁 Massive repetition
~40 structurally similar panels an agent clones cheaply. By hand, that's the most expensive part.
🔌 Well-documented technologies
Many Spring subsystems, each with a focused integration. Their extensive documentation and examples gave agents reliable material to research and build on, instead of working from guesswork.
🚀 Net effect: a ~6.5–8.5 month solo effort, compressed into ~11 days and ~2 weeks of human attention. The biggest leverage is on large-surface, pattern-heavy, well-tested code, not hard algorithms.
⚠️ Watch out for
Scope creep
"Build the whole thing" makes an agent wander. Fix: one tight goal per task.
No tests, no trust
You can't read every line of 223 PRs. Fix: harness first, green build before merge.
Giant PRs & review fatigue
A 2,000-line PR is impossible to review well. Fix: small, reviewable chunks; pace yourself.
Wrong model
A weak model fails the hard tasks; a strong one is slow and costly. Fix: match the model to the job.
Most failed runs aren't the agent's fault. They're a briefing problem.
Part 03 · The GitHub advantage
03
The GitHub advantage
The platform, the models, and the economics.
Copilot writes the code. The platform around it helps you ship it.
🔗 One loop, one platform
The brief, the agent, the review and the release stay connected.
🎫 Issue & board
The brief lives with the code: scope, priorities and acceptance criteria.
🤖 Copilot agent
CLI, app or cloud: work from task context and repository instructions.
🔀 Pull request
The unit of review: diff, evidence and conversation in one place.
⚙️ Actions + security
Build, tests, CodeQL and compatibility checks give feedback.
🚢 Merge & release
Required checks, review approvals and release workflows.
AI-written code benefits from the full GitHub platform, just like human-written code.
Reading the novel was cheaper than writing the book report.
Quiz: the cheaper model trap
You have 100,000 tokens of reusable context. Another model has half the fresh-input price. Is switching cheaper?
Current: $5 / million fresh, $0.50 cached. Alternative: $2.50 fresh. Assume a full cache hit if you stay, no matching cache if you switch. Input cost only.
A
Yes. Half the price!
B
No. The next input bill is five times higher.
C
Same context, same cost.
Vote A, B or C · then advance to reveal
B — Stay: $0.05. Switch: $0.25.
The new model cannot reuse the old model's cached computation.
You picked the cheaper model. Your input bill went up fivefold.
♻️ How the token cache works
The model can reuse the processing of an identical prompt prefix — the unchanged beginning of its input. It still processes new input and generates a new answer.
What changes?
Effect on cache reuse
Append a message or tool result
The unchanged prefix can still hit; the new suffix needs processing.
Switch the model
The old model's cached computation cannot transfer to the new one.
Edit AGENTS.md or instructions
Once reloaded into the prompt, changed content breaks the match from that point onward.
Change tools or compact history
If the rendered prefix changes, later cached context no longer matches.
Wait too long / cache is evicted
Even identical input can miss. Retention and routing depend on the provider.
A cache miss is not necessarily a full reset. An earlier, unchanged prefix may still be reusable.
New bootui CLI: query the same diagnostics from scripts or a terminal
🩺 Advisors that tell you what's wrong
Security, memory, databases, Hibernate, REST, architecture and native-image readiness
Live CVE checks against the OSV feed for your actual dependency tree
🤖 And it makes your agents smarter
Opt-in MCP server: agents read runtime diagnostics and run advisors
Pairs with Coffilot in the Copilot App to build, run and scan your app
<!-- Spring Boot MVC starter · use only in development --><dependency><groupId>com.julien-dubois.bootui</groupId><artifactId>bootui-spring-boot-starter</artifactId><version>1.16.0</version></dependency>
