Big Sky Dev Conf · 2026

Agentic Engineering
for JVM Developers

How to keep quality high when coding agents can implement faster than you can review: align the work, equip the agent, verify the behavior, and spend human judgment where mistakes matter most.

Thomas Schilling · Bozeman, Montana · July 25, 2026

View the talk slides ↗ Use the JVM resources ↓
The evidence

Velocity is easy. Judgment is the work.

These patterns come from six months of daily agent work on PhotoQuest, a production Kotlin and Spring Boot product. The talk is about the harder question behind the output: how do you ensure quality and manage risk?

3,200+commits
1,900+sessions
100+prompts per day
12×commit velocity
Choose the right level

More autonomy moves human thinking to the edges.

The right workflow depends on how well you understand the problem and how large it is. Prototype when uncertainty is high. Add durable structure as the work becomes clearer and larger.

  1. 04Sliced loopsGive every slice a fresh context.
  2. 03Spec-drivenDrive the design before implementation.
  3. 02Plan modeReview the proposal, then implement.
  4. 01Pair programmingWatch the work and redirect continuously.

Failure state: big specs. One overloaded session fills its context and loses important steps. Slice the specification so each group of stories starts fresh.

The workflow

Align → implement → review.

01 · ALIGNMENT

Decide before code

Grill the idea with focused questions. Turn the answers into ADRs, shared domain language, and a phase specification future sessions can inherit.

02 · IMPLEMENTATION

Compile the feedback

Give agents repository instructions, current JVM expertise, hooks, semantic IDE operations, focused tests, and current API documentation.

03 · REVIEW

Judge the behavior

Use behavioral contracts, tests, reports, screenshots, and independent reviewers. Reserve human attention for ambiguity, interfaces, and high-risk decisions.

The failure mode: autonomous implementation without review checkpoints can produce more correct-looking work than a human can hold in their head. A faster loop needs better judgment, not a larger final diff.

Take it into your repository

The JVM toolbelt from the talk.

Start with the constraint that matches your current bottleneck. You do not need every tool at once.

jvm-skills

Deep JVM knowledge built by JVM experts you can trust.

 jOOQ skill

Load focused production knowledge such as MULTISET guidance only when the task needs it.

 tdd-task

Keep implementation inside a visible red → green → refactor loop.

 grill-with-docs

Grill the design one decision at a time while building the domain glossary and recording durable architectural decisions.

 spec

Turn resolved decisions into a durable, verifiable implementation contract.

 IntelliJ MCP

Give the agent semantic JVM operations instead of shell-only feedback.

 JavaDoc Central

Resolve current Java and Kotlin library documentation from Maven coordinates.
The takeaway

Align. Build. Prove.

Align before the agent builds. Build through verified feedback loops. Turn behavior into reviewable evidence.

Open the slides ↗ Connect on LinkedIn ↗