building
Implementation skill for writing production code with TDD. Covers the RED-GREEN-REFACTOR cycle, false-RED detection, vertical slicing, scope escalation, test process discipline, and code generation patterns. Loaded by component-builder and bug-investigator.
romiluz13 · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add romiluz13/cc10x --skill building技能说明
name: building description: | Implementation skill for writing production code with TDD. Covers the RED-GREEN-REFACTOR cycle, false-RED detection, vertical slicing, scope escalation, test process discipline, and code generation patterns. Loaded by component-builder and bug-investigator. allowed-tools: Read Write Edit Bash Grep Glob LSP user-invocable: false
Building (Code Generation + TDD)
Iron Law: NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST.
Reference Files
Read only what's needed:
references/testing-patterns.md— test structure, isolation, naming; load when writing the first test of a cycle or a test feels awkward to structurereferences/test-data-and-mocks.md— mock discipline, test data factories; load when a test needs fixtures/factories or you are about to mock anythingreferences/integration-and-live-proof.md— integration test guidance, live verification; load when the slice crosses a service/DB/API boundary or the plan names live proof
Test Process Discipline
- Always use run mode:
CI=true npm test,npx vitest run(NOTnpx vitest),CI=true npx jest— watch mode never exits, so the agent hangs waiting for a prompt that never returns - Timeout guard:
timeout 60s npx vitest runif uncertain about CI=true - After TDD cycle:
pgrep -f "vitest|jest" || echo "Clean". Kill if found — orphaned watchers hold ports and re-run stale code, producing false greens in later cycles. - IDE vs CLI truth: If CLI tests pass with exit 0, trust CLI over IDE/LSP errors (stale cache)
RED → GREEN → REFACTOR
RED — Failing Test First
Write one failing test for the current slice. Run it. RED = a behavioral failure ("X is not a function", "expected 3, received undefined") — never a bare exit code.
False-RED guard (CRITICAL): Exit 1 from an import/syntax/collection ERROR is a broken harness, not a RED — fix the harness and re-run. Record the observed failure reason verbatim.
GREEN — Minimal Code
Write the minimum code to pass the test. No extra features, no abstractions for hypothetical futures. No unrelated test breakage. If existing tests break, fix the code not the tests.
REFACTOR — Clean Up
Improve code quality while keeping tests green. If tests fail during refactor, revert — a red test proves it wasn't a refactor, and debugging forward mixes two changes. Re-run after every refactor step.
Safety-Check Guard (MANDATORY): Never simplify away a safety check during refactoring. Safety checks include:
- Input validation at trust boundaries (API entry points, user input, external data)
- Error handling that prevents data loss or corruption
- Security checks (auth, authorization, sanitization)
- Accessibility checks (ARIA, keyboard navigation, semantic HTML)
If a safety check seems unnecessary, verify with a test that proves it's dead code before removing. "Looks redundant" is not sufficient evidence.
Vertical Slicing (CRITICAL)
Build in thin vertical slices that cross all layers: UI → API → logic → data → test. A horizontal slice (all UI, then all API, then all logic — or all tests first, then all implementation) defers integration risk to the end and produces untestable layers. Each slice should be independently verifiable and shippable.
Seam Discipline
One seam, one test, one minimal implementation per cycle. Each test is a tracer bullet that responds to what the last cycle taught you — work one vertical slice at a time.
Test only at pre-agreed seams. A seam is the public boundary where you observe behavior without reaching inside. Before writing any test, know which seam you're testing at. Prefer existing seams to new ones; use the highest seam possible; the fewer seams across the codebase, the better (ideal is one). If the plan provides a ### Test Seams subsection or an Interfaces block, draw your seams from there.
Implementation-coupled anti-pattern. A test is implementation-coupled if it 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 hasn't changed. Test through the public interface, not internals.
Record your seams (enforced contract fields). Your Router Contract carries two seam fields:
TEST_SEAMS: [seam names you actually tested at]SEAM_GATE_STATUS: "confirmed" | "proposed" | "disagreed" | "not_applicable"
Set SEAM_GATE_STATUS as follows:
confirmed— the plan providedtest_seamsand you used them (TEST_SEAMS non-empty, matching the plan).proposed— no plan (direct/no-plan path) OR a legacy plan whose phase omitstest_seams; you proposed seams at BUILD_PREFLIGHT (TEST_SEAMS non-empty).disagreed— the plan's proposed seam cannot exercise the phase's real risk. Record the disagreement inDECISIONSand either propose a better seam (TEST_SEAMS non-empty with the better seam) or block on genuine ambiguity (STATUS: FAIL,REMEDIATION_REASON: "Ambiguous test surface — no seam exercises the real risk").not_applicable—build_scope=trivial; no seam expectation.
The router validates these per build_scope (see the contract-override table). This is the enforced gate — not advisory.
Study Project Patterns First
Before writing code: read 2-3 existing similar components in the repo. Match naming, file structure, export style, test patterns. Follow the project's conventions — don't introduce a new pattern when an existing one works.
LSP before writing: Use LSP to find definitions, references, and type information before writing code that interfaces with existing modules.
Scope Escalation (SCOPE_INCREASES)
If the build scope grows beyond the approved phase — new files not in the plan, new dependencies, API contract changes — emit SCOPE_INCREASES: ["new scope item"] in the contract. The router decides whether to escalate to a full BUILD (with pl