skills.rest
aquariuscook
aquariuscookCOMMUNITY
Explore all skills by this author →
GitHub

tdd-london-chicago

Guide Test-Driven Development cycles with London and Chicago school distinctions.

1|Updated Dec 29, 2025
Search Tags:#testing#tdd#refactoring#mocking#development practices#state-based testing
One-click install
npx skills add https://github.com/aquariuscook/Agent_Modus_Map --skill tdd-london-chicago-aquariuscook
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: tdd-london-chicago
Source: https://github.com/aquariuscook/Agent_Modus_Map/tree/main/.claude/skills/tdd-london-chicago
Command: npx skills add https://github.com/aquariuscook/Agent_Modus_Map --skill tdd-london-chicago-aquariuscook

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill helps developers understand and apply the principles of Test-Driven Development (TDD) by differentiating between the London (mock-based) and Chicago (state-based) schools of thought, enabling better testing strategies and code design.

Core Features & Use Cases

  • TDD Methodology Guidance: Provides clear instructions on the Red-Green-Refactor cycle.
  • School Comparison: Explains the philosophies, strengths, and weaknesses of London and Chicago TDD approaches.
  • Practical Examples: Demonstrates code snippets for both schools and a hybrid approach.
  • Agent Coordination: Shows how AI agents can assist in the TDD process.
  • Use Case: When starting a new feature, use this Skill to decide whether to primarily use mocks (London) for external dependencies or test the state of real objects (Chicago) for domain logic, or a combination of both.

Quick Start

Use the tdd-london-chicago skill to understand the difference between London and Chicago TDD schools and when to apply each.

Frequently Asked Questions about tdd-london-chicago

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is the difference between London and Chicago TDD schools?▼

The London TDD school uses mocking to verify interactions between modules, while the Chicago school uses state-based testing to verify real object outputs. This Skill differentiates both approaches to guide your testing strategy.

How do I implement the Red-Green-Refactor cycle in TDD?▼

To implement the TDD cycle, you write a failing test, write code to pass it, and then refactor. This Skill provides practical examples and best practices for executing these development practices effectively.

When should I use mocking versus state-based testing in TDD?▼

Use mocking for external dependencies and state-based testing for domain logic. This Skill helps you decide when to apply each approach or combine both for optimal code design and maintainability.

Can AI agents assist with the Test-Driven Development process?▼

AI agents can assist with TDD by coordinating the testing cycles. This Skill demonstrates agent coordination strategies to help execute Red-Green-Refactor cycles and apply London or Chicago methodologies.

What are the limitations of mock-based testing in TDD?▼

Mock-based testing can tightly couple tests to implementation details, making refactoring harder. This Skill explains the strengths and weaknesses of London and Chicago approaches to avoid such design pitfalls.

Related Skills

Explore More Software Engineering Skills→
1molchuan1molchuan
1

oh-my-ccg-init

Verify MCP, Codex, and Gemini endpoints and initialize RPI state.

Community
Intermediate
CENKSSSCENKSSS

tdd-london-chicago

Coordinate test-driven development cycles for London and Chicago TDD schools.

Community
Advanced
EngineerWithAIEngineerWithAI
4

javascript-testing-patterns

Implement Jest, Vitest, and Testing Library tests for JavaScript and TypeScript.

Official
Intermediate
summarybotngsummarybotng
2

tdd-london-chicago

Compare London and Chicago Test-Driven Development schools with code examples.

Official
Intermediate