agent-common
Use when a cc10x agent starts a task: the shared preamble for the memory protocol, the contract format, and the output rules.
Use when designing or checking a QA test system: choosing the right tier, scenario matrices with pipeline-wide observation points, test-environment topology and isolation, fixture lifecycle, and flake sources. Also the coverage lens for reviewing a QA plan (it reaches a plan
Claude Code
$ npx -y skills add romiluz13/cc10x --skill qa-strategy --agent claude-code
Codex
$ npx skills add romiluz13/cc10x --skill qa-strategy -a codex -y
Cursor
$ npx skills add romiluz13/cc10x --skill qa-strategy -a cursor -y
Gemini CLI
$ npx skills add romiluz13/cc10x --skill qa-strategy -a gemini-cli -y
GitHub Copilot
$ npx skills add romiluz13/cc10x --skill qa-strategy -a github-copilot -y
OpenCode
$ npx skills add romiluz13/cc10x --skill qa-strategy -a opencode -y
Windsurf
$ npx skills add romiluz13/cc10x --skill qa-strategy -a windsurf -y
name: qa-strategy description: | Use when designing or checking a QA test system: choosing the right tier, scenario matrices with pipeline-wide observation points, test-environment topology and isolation, fixture lifecycle, and flake sources. Also the coverage lens for reviewing a QA plan (it reaches a plan reviewer as a file to Read in the task scaffold, not as a SKILL_HINTS entry). allowed-tools: Read Grep Glob Bash LSP user-invocable: false
This skill is the QA route's test-system design discipline.
**Core:** A test suite's value is not how many tests it has. It is how much you would believe a green run.
The three-layer model in `cc10x:building` still governs — unit proves local behavior, integration proves boundary wiring, E2E proves system truth. QA owns the outer two, plus UI.
| Tier | Proves | Use when | | ------ | -------- | ---------- | | `integration` | one boundary really works | route→service, service→DB, producer→consumer, cache/side effects | | `e2e_backend` | a flow across services really works | the value is produced by services cooperating | | `ui` | a human can actually do the thing | the deliverable is something a person operates |
**Choose the cheapest tier that can still fail for the right reason.** An E2E test that would also fail for ten unrelated reasons is a bad detector: it fires often and tells you little. Push a check down a tier whenever the lower tier can catch the same defect.
**But do not push everything down.** The defects that survive good unit coverage are exactly the ones that live *between* components — serialization mismatches, transaction boundaries, retry storms, partial failures. Those only appear at the tier where the components are real.
Every feature gets scenarios in three classes. A plan with only the first is not a test plan, it is a demo.
| Class | Question it answers | | ------- | --------------------- | | `happy-path` | Does the thing work when everything cooperates? | | `error-handling` | When a dependency fails, does the system fail *correctly* — right status, right message, right rollback, right log? | | `edge-case` | What about empty, one, many, max, concurrent, duplicate, out-of-order, expired, and unauthorized? |
For each boundary the flow crosses, ask: what happens when it is slow, down, returns garbage, returns a partial result, or succeeds after the caller gave up? Each answer that matters is a scenario.
The most valuable single question: **when this fails halfway, what state is left behind?** Partial-failure state is where data corruption lives, and it is almost never covered by accident.
The goal is to cover **as many user actions and chains of actions as possible**: every option in a dropdown, every date class, every filter, every combination that a real user could produce.
For every interactive surface in the flow, list every option a user can actually pick:
**Discover, do not assume.** Options are usually data-driven; reading the component tells you a `<select>` exists, not what is in it at runtime. Drive the real UI to enumerate actual values (see *UI tier tooling* below). An enumeration built from the code alone will miss the options that only appear for certain roles, tenants, or feature flags.
Record the full enumeration in the test plan even when you will not execute all of it. **The enumeration is the coverage claim.** What you skip must be visible.
Full combinatorial coverage is not achievable and pretending otherwise produces an unbuildable plan: 5 filters × 4 options each is 1,024 combinations; add a date and a sort and you are past 10,000. Nobody runs that suite, so in practice it never gets written, and you end up with *less* coverage than an honest reduction would have given.
Reduce with a named technique, and **record which one you used and what it leaves uncovered**:
| Technique | Use for | What it costs | | ----------- | --------- | --------------- | | **Every-option-once** | dropdowns, radio groups | Each option exercised at least once. Misses interactions between options. | | **Pairwise (all-pairs)** | combinations of 3+ independent controls | Every *pair* of values co-occurs in some case. Collapses 1,024 → ~25. Misses 3-way interactions, which are rare. | | **Equivalence classes** | free text, numbers, dates | One representative per class of behavior. Misses defects inside a class. | | **Boundary values** | anything with a range | 0, 1, max, max+1, empty, null. Where most defects actually live. | | **Full combinatorial** | 2 controls with few values, or a genuinely safety-critical path | Complete. Only affordable when the space is tiny. |
**Default recipe:** every-option-once for single controls, pairwise across combinations, boundary values on every range, plus full combinatorial on any combination that is known to be risky (billing, permissions, anything where two settings interact by design).
**Pairwise is the highest-leverage tool here.** Most combination defects come from two settings interacting, not five. All-pairs buys the large majority of that value for a small fraction of the runs.
A user action rarely stands alone. Cover the sequences too:
The Loop Engine for Claude Code — engineer the loop, not the prompt. 1 router · 14 agents · 21 skills · 8 workflows. Fail-closed gates, test honesty, anti-anchored review.
Use when a cc10x agent starts a task: the shared preamble for the memory protocol, the contract format, and the output rules.
Greenfield architecture design: map functionality flows, draw components, design APIs, classify dependencies, plan observability.…
Use when writing production code test-first: the RED-GREEN-REFACTOR cycle, false-RED detection, vertical slicing, scope…
Answers questions about cc10x itself — what it is, how to install and configure it, how the router, workflows, memory, and hooks…
Routes build, debug, review, plan, QA, and triage requests through the cc10x workflows (task graphs, workflow artifacts, gates);…
Two-mode skill: (1) adversarial review — spec compliance + code quality + security, confidence-scored findings with file:line…
You MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or…
Ask which skill or flow fits your situation. A router over the skills in this repo.