Skip to main content
skill CX Codex

tdd-london-chicago — Claude Code skill: TDD and setup

tdd-london-chicago — a skill for choosing London or Chicago TDD, using mocks or real objects, and moving through the Red–Green–Refactor cycle.

MIT 124 installs ★ 533 updated 2026-10-25

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code
Open on GitHub

What tdd-london-chicago does

This skill maps testing style to the code under test. Use the Chicago school for domain rules, calculations, and value objects, where real collaborators and state assertions fit well. Use the London school for controllers, services, and external integrations, where mocks isolate dependencies and interaction checks matter.

Its workflow starts with a failing test, adds the smallest implementation that passes, then refactors without adding behavior. The package describes qe-test-generator, qe-test-implementer, and qe-test-refactorer, and shows how to combine both schools: London around external dependencies and Chicago inside domain logic.

London-style tests are harder to refactor because mocks can break when the code changes. That trade-off matters when you choose a testing style for a project.

What it helps with

  • choose between mocks and real collaborators
  • write a failing test before implementation
  • run a feature through Red–Green–Refactor
  • verify the state of a domain object
  • isolate APIs and other external services

Example prompts for the agent

  • Choose London or Chicago for src/domain/Order.ts and explain the choice.
  • Generate a failing test for order total calculation, then write the smallest implementation needed to pass it.
  • Suggest refactorings while keeping the current test suite passing.

How to install tdd-london-chicago

1Skills CLI (Vercel)

npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code

2Manually: put the files in place

~/.claude/skills/tdd-london-chicago/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tdd-london-chicago/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tdd-london-chicago

How do I install tdd-london-chicago in Claude Code?

Run npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a claude-code, then check ~/.claude/skills/tdd-london-chicago/SKILL.md.

What does tdd-london-chicago do?

The skill guides TDD with two schools. Chicago tests state through real objects, while London isolates units with mocks and checks their interactions.

When should I use London or Chicago TDD?

Choose Chicago for calculations, algorithms, and value objects. Choose London for APIs, databases, and other external integrations; the skill also describes combining both styles.

Source text

SKILL.md · MIT
---
name: tdd-london-chicago
description: "Apply London (mock-based) and Chicago (state-based) TDD schools. Use when practicing test-driven development or choosing testing style for your context."
category: development-practices
priority: high
tokenEstimate: 1100
agents: [qe-test-generator, qe-test-implementer, qe-test-refactorer]
implementation_status: optimized
optimization_version: 1.0
last_optimized: 2025-12-02
dependencies: []
quick_reference_card: true
tags: [tdd, testing, london-school, chicago-school, red-green-refactor, mocks]
trust_tier: 2
validation:
  schema_path: schemas/output.json
  validator_path: scripts/validate-config.json
---

# Test-Driven Development: London & Chicago Schools

<default_to_action>
When implementing TDD or choosing testing style:
1. IDENTIFY code type: domain logic → Chicago, external deps → London
2. WRITE failing test first (Red phase)
3. IMPLEMENT minimal code to pass (Green phase)
4. REFACTOR while keeping tests green (Refactor phase)
5. REPEAT cycle for next functionality

**Quick Style Selection:**
- Pure functions/calculations → Chicago (real objects, state verification)
- Controllers/services with deps → London (mocks, interaction verification)
- Value objects → Chicago (test final state)
- API integrations → London (mock external services)
- Mix both in practice (London for controllers, Chicago for domain)

**Critical Success Factors:**
- Tests drive design, not just verify it
- Make tests fail first to ensure they test something
- Write minimal code - no features beyond what's tested
</default_to_action>

## Quick Reference Card

### When to Use
- Starting new feature with test-first approach
- Refactoring legacy code with test coverage
- Teaching TDD practices to team
- Choosing between mocking vs real objects

### TDD Cycle
| Phase | Action | Discipline |
|-------|--------|------------|
| **Red** | Write failing test | Verify it fails, check message is clear |
| **Green** | Minimal code to pass | No extra features, don't refactor |
| **Refactor** | Improve structure | Keep tests passing, no new functionality |

### School Comparison
| Aspect | Chicago (Classicist) | London (Mockist) |
|--------|---------------------|------------------|
| Collaborators | Real objects | Mocks/stubs |
| Verification | State (assert outcomes) | Interaction (assert calls) |
| Isolation | Lower (integrated) | Higher (unit only) |
| Refactoring | Easier | Harder (mocks break) |
| Design feedback | Emerges from use | Explicit from start |

### Agent Coordination
- `qe-test-generator`: Generate tests in both schools
- `qe-test-implementer`: Implement minimal code (Green)
- `qe-test-refactorer`: Safe refactoring (Refactor)

---

## Chicago School (State-Based)

**Philosophy:** Test observable behavior through public API. Keep tests close to consumer usage.

```javascript
// State verification - test final outcome
describe('Order', () => {
  it('calculates total with tax', () => {
    const order = new Order();
    order.addItem(new Product('Widget', 10.00), 2);
    order.addItem(new Product('Gadget', 15.00), 1);

    expect(order.totalWithTax(0.10)).toBe(38.50);
  });
});
```

**When Chicago Shines:**
- Domain logic with clear state
- Algorithms and calculations
- Value objects (`Money`, `Email`)
- Simple collaborations
- Learning new domain

---

## London School (Mock-Based)

**Philosophy:** Test each unit in isolation. Focus on how objects collaborate.

```javascript
// Interaction verification - test method calls
describe('Order', () => {
  it('delegates tax calculation', () => {
    const taxCalculator = {
      calculateTax: jest.fn().mockReturnValue(3.50)
    };
    const order = new Order(taxCalculator);
    order.addItem({ price: 10 }, 2);

    order.totalWithTax();

    expect(taxCalculator.calculateTax).toHaveBeenCalledWith(20.00);
  });
});
```

**When London Shines:**
- External integrations (DB, APIs)
- Command patterns with side effects
- Complex workflows
- Slow operations (network, I/O)

---

## Mixed Approach (Recommended)

```javascript
// London for controller (external deps)
describe('OrderController', () => {
  it('creates order and sends confirmation', async () => {
    const orderService = { create: jest.fn().mockResolvedValue({ id: 123 }) };
    const emailService = { send: jest.fn() };

    const controller = new OrderController(orderService, emailService);
    await controller.placeOrder(orderData);

    expect(orderService.create).toHaveBeenCalledWith(orderData);
    expect(emailService.send).toHaveBeenCalled();
  });
});

// Chicago for domain logic
describe('OrderService', () => {
  it('applies discount when threshold met', () => {
    const service = new OrderService();
    const order = service.create({ items: [...], total: 150 });

    expect(order.discount).toBe(15); // 10% off > $100
  });
});
```

---

## Common Pitfalls

### ❌ Over-Mocking (London)
```javascript
// BAD - mocking everything
const product = { getName: jest.fn(), getPrice: jest.fn() };
```
**Better:** Only mock external dependencies.

### ❌ Mocking Internals
```javascript
// BAD - testing private methods
expect(order._calculateSubtotal).toHaveBeenCalled();
```
**Better:** Test public behavior only.

### ❌ Test Pain = Design Pain
- Need many mocks? → Too many dependencies
- Hard to set up? → Constructor does too much
- Can't test without database? → Coupling issue

---

## Agent-Assisted TDD

```typescript
// Agent generates tests in both schools
await Task("Generate Tests", {
  style: 'chicago',      // or 'london'
  target: 'src/domain/Order.ts',
  focus: 'state-verification'  // or 'collaboration-patterns'
}, "qe-test-generator");

// Agent-human ping-pong TDD
// Human writes test concept
const testIdea = "Order applies 10% discount when total > $100";

// Agent generates formal failing test (Red)
await Task("Create Failing Test", testIdea, "qe-test-generator");

// Human writes minimal code (Green)

// Agent suggests refactorings
await Task("Suggest Refactorings", { preserveTests: true }, "qe-test-refactorer");
```

---

## Agent Coordination Hints

### Memory Namespace
```
aqe/tdd/
├── test-plan/*        - TDD session plans
├── red-phase/*        - Failing tests generated
├── green-phase/*      - Implementation code
└── refactor-phase/*   - Refactoring suggestions
```

### Fleet Coordination
```typescript
const tddFleet = await FleetManager.coordinate({
  workflow: 'red-green-refactor',
  agents: {
    testGenerator: 'qe-test-generator',
    testExecutor: 'qe-test-executor',
    qualityAnalyzer: 'qe-quality-analyzer'
  },
  mode: 'sequential'
});
```

---

## Related Skills
- [agentic-quality-engineering](../agentic-quality-engineering/) - TDD with agent coordination
- [refactoring-patterns](../refactoring-patterns/) - Refactor phase techniques
- [api-testing-patterns](../api-testing-patterns/) - London school for API testing

---

## Remember

**Chicago:** Test state, use real objects, refactor freely
**London:** Test interactions, mock dependencies, design interfaces first
**Both:** Write the test first, make it pass, refactor

Neither is "right." Choose based on context. Mix as needed. Goal: well-designed, tested code.

**With Agents:** Agents excel at generating tests, validating green phase, and suggesting refactorings. Use agents to maintain TDD discipline while humans focus on design decisions.

## Gotchas

- Agent skips Red phase and writes test + implementation together — enforce "test must fail first" by running test before writing code
- London school over-mocking creates brittle tests that break on any refactor — mock at architectural boundaries, not every function
- Chicago school tests become slow as integration scope grows — keep test boundaries tight
- Agent defaults to jest.mock() for everything — prefer dependency injection for testability
- Refactor phase is where agent cuts corners most — verify no behavior changes by checking test output is identical

© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe

Similar skills

All skills for Testing and QA →

From the same set73

The whole set →
qe-iterative-loop qe-iterative-loop — a skill that runs autonomous red-green-refactor cycles: the agent fixes failing tests, achieves coverage targets, and passes quality gates on its own. CX Codex +1 126installs xp-practices xp-practices — a skill for pair programming, continuous integration, TDD, and other extreme programming practices in AI coding. CX Codex +1 125installs context-driven-testing context-driven-testing adapts software testing strategies to specific project constraints, risks, and goals instead of blindly applying generic best practices. CX Codex +1 125installs n8n-integration-testing-patterns n8n-integration-testing-patterns is a Claude Code skill for testing API contracts, authentication flows, and rate limits in n8n integrations. CX Codex +1 124installs qe-chaos-resilience qe-chaos-resilience — a skill for Claude Code, Codex, Cursor and other agents that injects controlled faults into distributed systems and checks recovery behavior. Runs during circuit breaker, failover, and retry logic validation. CX Codex +1 123installs consultancy-practices consultancy-practices is a Claude Code skill that applies software quality consulting practices: it identifies client pain, prioritizes work by impact and effort, and transfers knowledge. CX Codex +1 122installs mutation-testing Skill runs mutation testing: mutates code (operators, boundaries, logic), runs tests, and counts surviving mutants — weak spots in your test suite. CX Codex +1 122installs qe-code-intelligence qe-code-intelligence builds a semantic code index, dependency graphs and knowledge graphs. Helps understand unfamiliar codebases, trace call chains, and find code by meaning rather than keywords. CX Codex +1 122installs

Project sponsors

Companies that keep this analytics open