Your Tests Are Your Spec

You write the code.
You write the tests.
Tests validate your work.

bottleneck: developer writing speed

AI writes the code — fast, confident,
syntactically correct, sometimes subtly wrong.

bottleneck: verification infrastructure

• Huge PRs with no baby steps
• No behavioral tests or spec docs
• Vague issues, no acceptance criteria
• Slow, flaky CI pipeline
• Problems hidden for months → exposed in hours

• Small, atomic, reviewable PRs
• Behavioral tests that enforce intent
• Well-defined issues with acceptance criteria
• Fast, stable CI with real feedback
• Guardrails catch AI mistakes before prod

Developer drives all three steps.

TDD is a development loop.

TDD shifts from a development discipline to a

design communication tool — authoring intent for both humans and machines.

@Mock KubernetesClient client;
@Test void deletesPod() {
    service.delete("foo");
    // agent renames pods()→resources()
    // agent rewrites this mock in lockstep
    // nothing pins the actual contract
    verify(client.pods()
           .withName("foo")).delete();
}

Test and impl travel together. No guardrail survives the refactor.

@QuarkusTest @WithKubernetesTestServer
class PodBehaviorIT {
  @Test
  @DisplayName("DELETE removes the pod")
  void removesPodFromCluster() {
    k8s.pods().resource(pod).create();
    given().delete("/api/v1/pods/foo")
           .then().statusCode(204);
    assertThat(k8s.pods()
        .withName("foo").get()).isNull();
  }
}

Zero test edits after agent refactor. The outcome is the contract.

• KubernetesMockServer — no real cluster in unit tests
  ~50s/class → ~1s/class
• Parallel matrix — Java versions & HTTP backends run concurrently
• Maven dep caching — eliminated cold-start download cost
• Selective E2E — KinD cluster tests on PR label or main only

@Nested
@DisplayName("PodService")
class PodServiceTest {
@Nested @DisplayName (“when deleting a pod”)
class WhenDeletingAPod {
@Test
@DisplayName("removes it from the cluster")
void removesPodFromCluster() { ... }

@Test
@DisplayName("returns 404 for unknown pod")
void returnsNotFoundForUnknownPod() { ... }
} }

An AI agent given this test hierarchy understands exactly what to implement — not from a prose comment, but from code that runs on every commit.

Text docs are advisory.
Tests push back.

// a failing @DisplayName reads like a sentence top to bottom

Fix one test this week — rename it to describe what it guards, not how it works.