New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

TDD London Chicago

by proffesor-for-testing in proffesor-for-testing/agentic-qe

Apply London (mock-based) and Chicago (state-based) TDD schools.

MITAuto-check passedTesting & QA

Install TDD London Chicago

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

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install proffesor-for-testing/agentic-qe tdd-london-chicago --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/proffesor-for-testing/agentic-qe.git skills-src && mkdir -p .claude/skills && cp -r skills-src/assets/skills/tdd-london-chicago .claude/skills/tdd-london-chicago && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
tdd-london-chicago
GitHub stars
495
Token cost
~2k tokens
SKILL.md length
520 words
Files
3 (incl. scripts)
Skills in repo
93
Repo updated
First seen
Licence
MIT

At a glance

Apply London (mock-based) and Chicago (state-based) TDD schools.

  • Works in 5 steps: IDENTIFY code type: domain logic →… → WRITE failing test first (Red phase) → IMPLEMENT minimal code to pass (Green… → …
  • Practicing test-driven development
  • SKILL.md covers Quick Reference Card, Chicago School (State-Based), London School (Mock-Based) and Mixed Approach (Recommended), plus 6 more sections
  • Choosing testing style for your context

What it does

TDD London Chicago is an agent skill from proffesor-for-testing/agentic-qe. Apply London (mock-based) and Chicago (state-based) TDD schools. Use when practicing test-driven development or choosing testing style for your context.

Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including scripts (for example `schemas/output.json` and `scripts/validate-config.json`).

It sits in Testing & QA, covering Test-driven development. The repository describes itself as: Agentic QE Fleet is an open-source AI-powered QA/QE platform designed for use with Coding Agents (works best with Claude Code) featuring specialized agents and skills to support… The licence is MIT.

When your agent uses it

  • Practicing test-driven development
  • Choosing testing style for your context

Example prompts

  • “/tdd-london-chicago”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  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

What it can do on your machine

Read from SKILL.md and the folder at commit 1363bc7. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/, which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

TDD London Chicago loads about 2k tokens when it runs. Until then it costs about 43 tokens; SKILL.md has 520 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~43
When it runs · the whole SKILL.md, loaded when a task matches
~2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from proffesor-for-testing/agentic-qe at commit 1363bc7, republished under its MIT licence (© proffesor-for-testing). 520 words, ~1,987 tokens.

Download SKILL.mdSave it as .claude/skills/tdd-london-chicago/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
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
last_optimized
2025-12-02
quick_reference_card
true
tags
tdd, testing, london-school, chicago-school, red-green-refactor, mocks
trust_tier
2

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
PhaseActionDiscipline
RedWrite failing testVerify it fails, check message is clear
GreenMinimal code to passNo extra features, don't refactor
RefactorImprove structureKeep tests passing, no new functionality
School Comparison
AspectChicago (Classicist)London (Mockist)
CollaboratorsReal objectsMocks/stubs
VerificationState (assert outcomes)Interaction (assert calls)
IsolationLower (integrated)Higher (unit only)
RefactoringEasierHarder (mocks break)
Design feedbackEmerges from useExplicit 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)
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

Show full SKILL.md (210 more words)Show less
❌ 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'
});

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. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (scripts) in assets/skills/tdd-london-chicago of proffesor-for-testing/agentic-qe.

  • SKILL.md
  • schemas/output.json
  • scripts/validate-config.json

Open the folder on GitHubat commit 1363bc7

Compare with similar skills

TDD London Chicago next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

TDD London Chicago compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
TDD London Chicago this skillproffesor-for-testing/agentic-qe495—~2kAutomated safety check: PassMIT
TDDpietheinstrengholt/rssmonster56430 repos~906Automated safety check: PassMIT
TDD WorkflowhellangleZ/burn-in-cceverywhere-ralph11211 repos~2.4kAutomated safety check: PassNone
TDDsanity-io/sanity6.4k20 repos~1kAutomated safety check: PassMIT
Test Driven Developmentfarm-fe/farm5.6k52 repos~2.5kAutomated safety check: PassMIT
Tapd Story PipelineTencentBlueKing/bk-bcs840—~2.6kAutomated safety check: PassCustom licence

Similar skills

  • TDD

    pietheinstrengholt/rssmonster

    Test-driven development. An agent skill from pietheinstrengholt/rssmonster.

    564 GitHub starsUsed in 30 repos~906 tokens
    Testing & QAAuto-check passed

  • TDD Workflow

    hellangleZ/burn-in-cceverywhere-ralph

    A skill your agent uses when writing new features, fixing bugs, or refactoring code.

    112 GitHub starsUsed in 11 repos~2.4k tokens
    Testing & QAAuto-check passed

  • TDD

    sanity-io/sanity

    Official

    Test-driven development with red-green-refactor loop. An agent skill from sanity-io/sanity.

    6.4k GitHub starsUsed in 20 repos~1k tokens
    Testing & QAAuto-check passed

  • Test Driven Development

    farm-fe/farm

    A skill your agent uses when implementing any feature or bugfix, before writing implementation code

    5.6k GitHub starsUsed in 52 repos~2.5k tokens
    Testing & QAAuto-check passed

  • Tapd Story Pipeline

    TencentBlueKing/bk-bcs

    单需求实现流水线——把一个 TAPD 需求从零推进到代码提交。自动串联技术澄清、 开发计划、任务拆分、TDD 实现、架构/安全校验、代码提交六个阶段。

    840 GitHub stars~2.6k tokensUpdated 2 days ago
    Testing & QAAuto-check passed

  • Absolute Init

    maddhruv/absolute

    One-time setup for absolute: interview how you want it to behave (output style, autonomy, TDD strictness, spec dir, families) + detect the stack once, then write .absolute.config.json (project…

    219 GitHub starsUsed in 1 repo~3k tokens
    Testing & QAAuto-check passed

More from proffesor-for-testing/agentic-qe

All 93 skills in this repo

  • Contract Testing

    proffesor-for-testing/agentic-qe

    Consumer-driven contract testing for microservices using Pact, schema validation, API versioning, and backward compatibility testing.

    495 GitHub stars~1.8k tokensUpdated today
    Auto-check passed

  • Mutation Testing

    proffesor-for-testing/agentic-qe

    Test quality validation through mutation testing, assessing test suite effectiveness by introducing code mutations and measuring kill rate.

    495 GitHub stars~1.7k tokensUpdated today
    Auto-check passed

  • Performance Testing

    proffesor-for-testing/agentic-qe

    Profiles application performance under load using k6, Artillery, or JMeter to measure latency, throughput, and error rates.

    495 GitHub stars~2.4k tokensUpdated today
    Auto-check passed

  • Code Review Quality

    proffesor-for-testing/agentic-qe

    Conduct context-driven code reviews focusing on quality, testability, and maintainability.

    495 GitHub starsUsed in 1 repo~1.9k tokens
    Auto-check passed

  • Security Testing

    proffesor-for-testing/agentic-qe

    Scans for security vulnerabilities including XSS, SQL injection, CSRF, and auth flaws using OWASP Top 10 methodology.

    495 GitHub stars~2.7k tokensUpdated today
    Auto-check: notes

  • Database Testing

    proffesor-for-testing/agentic-qe

    Database schema validation, data integrity testing, migration testing, transaction isolation, and query performance.

    495 GitHub starsUsed in 1 repo~1.7k tokens
    Auto-check passed

Categories

Questions about TDD London Chicago

What does TDD London Chicago do?

Apply London (mock-based) and Chicago (state-based) TDD schools. TDD London Chicago is an agent skill from proffesor-for-testing/agentic-qe. Apply London (mock-based) and Chicago (state-based) TDD schools.

When should I use TDD London Chicago?

TDD London Chicago fits situations like: practicing test-driven development; choosing testing style for your context.

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`. Or copy the skill folder (assets/skills/tdd-london-chicago in proffesor-for-testing/agentic-qe) into .claude/skills/tdd-london-chicago in your project. Claude Code loads it when a task matches its description.

How do I install TDD London Chicago in Codex?

Run `npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a codex`. Or copy the skill folder (assets/skills/tdd-london-chicago in proffesor-for-testing/agentic-qe) into .agents/skills/tdd-london-chicago in your project. Codex loads it when a task matches its description.

Can I use TDD London Chicago in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add proffesor-for-testing/agentic-qe --skill tdd-london-chicago -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tdd-london-chicago, .gemini/skills/tdd-london-chicago, .github/skills/tdd-london-chicago and .opencode/skills/tdd-london-chicago in your project.

What does TDD London Chicago need to run?

SKILL.md names no scripts, command-line tools or credentials: TDD London Chicago is instructions for the agent only.

Does TDD London Chicago access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is TDD London Chicago safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does TDD London Chicago use?

TDD London Chicago is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does TDD London Chicago use?

About 2k tokens (SKILL.md is roughly 7.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to TDD London Chicago?

Skills that share tags, products or a category with TDD London Chicago: TDD (pietheinstrengholt/rssmonster, 564 stars), TDD Workflow (hellangleZ/burn-in-cceverywhere-ralph, 112 stars), TDD (sanity-io/sanity, 6.4k stars) and Test Driven Development (farm-fe/farm, 5.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains TDD London Chicago?

proffesor-for-testing (a GitHub user) maintains it in proffesor-for-testing/agentic-qe, which has 495 GitHub stars. The repository holds 93 skills in this directory. The repository was last updated on October 9, 2026.

Source: proffesor-for-testing/agentic-qe on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.