Skip to main content
skill CX Codex

team-build — Claude Code skill: what it does, how to install

team-build is a Claude Code skill that enforces TDD workflows, test seams, and deterministic test suites. It guides code changes against ticket acceptance criteria before QA handoff.

MIT ★ 71 updated 2026-11-13

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add sametcelikbicak/opencode-team --skill team-build -a claude-code
Open on GitHub

What team-build does

The skill implements test-driven development using small vertical slices. Before running tests, the agent checks the ticket in .team/03-backlog.md and boundary specs in .team/06-architecture.md. Work proceeds strictly through failing tests, minimal implementations, and refactoring steps that keep contracts intact.

Testing targets explicit public seams confirmed in advance rather than private implementation details. The pyramid targets 70% unit tests, 20% integration tests, and 10% e2e journeys. Tests stay deterministic by seeding randomness, using fake clocks, and mocking solely at external boundaries.

A build concludes only after every acceptance criterion passes with clean test coverage and a specialist report in .team/07-build-fe.md or .team/07-build-be.md. If a refactor alters module boundaries or data models, the task shifts to team-architecture.

What it helps with

  • enforce red-green-refactor cycles for code changes
  • define and verify public testing seams before implementation
  • prevent flaky tests caused by clocks, network, or execution order
  • generate build reports for QA handoff

Example prompts for the agent

  • Write a failing unit test for the acceptance criteria in .team/03-backlog.md
  • Verify the seams for the checkout interface and write the minimal passing code
  • Refactor the database adapter without altering contracts and log .team/07-build-be.md

How to install team-build

1Skills CLI (Vercel)

npx skills add sametcelikbicak/opencode-team --skill team-build -a claude-code

2Manually: put the files in place

~/.claude/skills/team-build/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/team-build/

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

Questions about team-build

How to install team-build in Claude Code?

Run npx skills add sametcelikbicak/opencode-team --skill team-build -a claude-code in your terminal. Alternatively, place the file in ~/.claude/skills/team-build/SKILL.md.

What does team-build do?

It provides a TDD playbook covering the red-green-refactor loop, test pyramid ratios, boundary mocking, and deterministic test requirements.

What files are needed for team-build?

The skill relies on ticket definitions in .team/03-backlog.md and architecture contracts in .team/06-architecture.md. Module restructuring hands off to team-architecture.

Source text

SKILL.md · MIT
---
name: team-build
description: The build and TDD playbook for this team. Red-green-refactor, test-first vertical slices, seams, test pyramid, mocking at boundaries, deterministic tests and definition of done.
---

# Build: Test-Driven Development

TDD is the **red → green → refactor** loop. This skill is the reference that makes that loop produce tests worth keeping: what a good test is, where tests go, what to mock, how to keep tests deterministic, and when the build is done.

Read [tests.md](tests.md) for examples and [mocking.md](mocking.md) for boundary guidelines.

Before the first test, read the ticket in `.team/03-backlog.md` and the contract in `.team/06-architecture.md`. The acceptance criteria and the API contract are the source of truth, not the implementation you are about to write. Use the project's domain vocabulary so test names match the product language.

## The loop

1. **Red** — write one failing test for one acceptance criterion. Run it and see it fail for the right reason.
2. **Green** — write only enough code to pass that test. Do not anticipate the next test or add speculative features.
3. **Refactor** — with the test still green, remove duplication in the production code and the test. Keep the public contract unchanged.

One seam, one test, one minimal implementation per cycle. If a refactor changes module boundaries, the API contract or the data model, stop: that is an architecture change for the `team-architecture` skill ([SKILL.md](../team-architecture/SKILL.md)) and belongs in the next cycle, not hidden inside a green step.

## What a good test is

Tests verify **behavior through public interfaces**, not implementation details. Code can change entirely; tests should not. A good test reads like a specification: "user can checkout with valid cart" tells you exactly what capability exists, and it survives refactors because it does not care about internal structure.

A test is the verification of an acceptance criterion, not proof that a line of code ran. Coverage percentage is not the goal; reliability is.

See [tests.md](tests.md) for good and bad examples.

## Seams: where tests go

A **seam** is the public boundary you test at: the interface where you observe behavior without reaching inside. Tests live at seams, never against internals.

Test only at pre-agreed seams. Before writing tests, write down the seams under test and confirm them with the user. No test is written at an unconfirmed seam. You cannot test everything, so agreeing the seams up front is how testing effort lands on critical paths and complex logic instead of every edge case.

Ask: "What is the public interface, and which seams should we test?" Give each proposed seam a one-line note on what it catches and what it misses.

When the shape of that interface is itself in question — how deep the module is, where the seam belongs, what it should expose — consult the `team-architecture` skill ([SKILL.md](../team-architecture/SKILL.md)). Its module boundaries and API contract define the seams; do not invent a second interface just for tests.

## The test pyramid

| Type | What it tests | Ratio | Speed |
|---|---|---|---|
| Unit | Business logic, edge cases | 70% | ms |
| Integration | DB, API, file system, external boundary adapters | 20% | s |
| e2e | The user journey | 10% | s–min |

Do not write e2e for everything. e2e is fragile and slow; use it only for the main journeys that bring in money.

## Anti-patterns

- **Implementation-coupled**: mocks internal collaborators, tests private methods, or verifies through a side channel (querying the database instead of using the interface). The tell: the test breaks when you refactor but behavior has not changed.
- **Tautological**: the assertion recomputes the expected value the way the code does (`expect(add(a, b)).toBe(a + b)`, a snapshot derived by hand the same way, a constant asserted equal to itself), so it passes by construction and can never disagree with the code. Expected values must come from an independent source of truth: a known-good literal, a worked example, the spec.
- **Horizontal slicing**: writing all tests first, then all implementation. Bulk tests verify _imagined_ behavior: you test the _shape_ of things rather than user-facing behavior, the tests go insensitive to real changes, and you commit to test structure before understanding the implementation. Work in **vertical slices** instead: one test → one implementation → repeat, each test a **tracer bullet** that responds to what the last cycle taught you.
- **Weakening the test**: deleting or loosening an assertion to make a test pass. See "Definition of done".

## Deterministic tests

A test that depends on the clock, the network, random data or execution order is a flaky test. Flaky tests train the team to ignore red.

- Fix time with the test framework's fake clock, or inject a clock. Never assert against `Date.now()`.
- Seed randomness, or inject the random source.
- Mock only the external boundary (see [mocking.md](mocking.md)); never reach the real network in a unit test.
- Each test creates its own state and cleans it up. Tests must pass in any order and in parallel where the runner allows.
- Do not hide a race condition by raising a timeout. Fix the cause or mark the test as an explicit known issue.

## Definition of done

The build is done only when all of these are true:

- Every acceptance criterion in the ticket has at least one test that maps to it.
- Each test was seen failing before the implementation that made it pass.
- The full suite passes, deterministically, in the project's configured command.
- No test was skipped, deleted, loosened or given a longer timeout to get green.
- Tests are versioned next to the code they verify.
- No known failing case is hidden. If something cannot be tested, say why in the build report.

## Handoff to QA

After implementation and tests are green, write your specialist report — `.team/07-build-fe.md` for frontend, `.team/07-build-be.md` for backend:

- What was built, per ticket and per acceptance criterion.
- Tests added, with the criterion each one covers.
- Exact commands run and their exact output (or "not run").
- Known gaps, shortcuts and risks.

The orchestrator consolidates the specialist reports into `.team/07-build.md` after every requested specialist has completed successfully. Do not write the consolidated report yourself.

Then hand off to the **QA stage**: the `qa` agent ([agents/qa.md](../../agents/qa.md)) reads `.team/06-architecture.md` and `.team/07-build.md`, follows the `team-qa` skill ([SKILL.md](../team-qa/SKILL.md)), and independently verifies the acceptance criteria. Do not report the QA stage as passed from the build stage; only QA can do that.

> Adapted from the MIT-licensed test-driven development skill by Matt Pocock. See THIRD_PARTY_NOTICES.md.

© sametcelikbicak · MIT · sametcelikbicak/opencode-team

Similar skills

All skills for Testing and QA →

From the same set25

The whole set →
team-market-research team-market-research is a Claude Code skill that structures market, competitor, and user research. Guides niche validation, source hierarchy checks, and product risk evaluations. CX Codex +1 ★ 71repo stars team-architecture team-architecture is a Claude Code skill for planning software architecture, from data models and API contracts to module boundaries and risks. It activates for architecture design requests. CX Codex +1 ★ 71repo stars team-security-review team-security-review is a Claude Code skill that enforces a strict security auditing playbook. It inspects authentication flows, access control, input handling, and secret leaks. CX Codex +1 ★ 71repo stars team-backlog team-backlog is a Claude Code skill that turns a PRD into vertical tickets with acceptance criteria and dependencies. It writes the approved plan to .team/03-backlog.md. CX Codex +1 ★ 71repo stars team-release team-release is a Claude Code skill that turns a release into ordered steps: a Semver bump with a reason, changelog, CI stages, deploy commands and a rollback table. It switches on when a project is ready to tag and ship. CX Codex +1 ★ 71repo stars team-discipline team-discipline is a Claude Code skill that sets the default rules for coding tasks. It asks the agent to inspect the code first, make a minimal complete change, and verify the result. CX Codex +1 ★ 71repo stars team-brand team-brand is a Claude Code skill for developing brand identities and logos, from a brief through concepts and a brand guide. It can also critique an existing mark or create icon assets. CX Codex +1 ★ 71repo stars team-memory team-memory is a Claude Code skill that stores project context and decisions in local .team/memory files. Runs at task boundaries, during /memory calls, and when resuming interrupted pipelines. CX Codex +1 ★ 71repo stars

Project sponsors

Companies that keep this analytics open