Skip to content
Back to skills

Extracting Acceptance Criteria

ASecurity

Extract atomic acceptance criteria from a feature.

  • 3 stars
  • 0 votes
  • 0 copies
  • 1 view
  • Added November 16, 2026
developmentgoshelltestingapifrontendbackendsecurityperformance

Works with

  • api

Security analysis

A100/100

Scanned November 16, 2026

npx -y skills add Acendas/shipyard --skill extracting-acceptance-criteria --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Extracting Acceptance Criteria?

Add the live security badge to your README. It updates with every re-scan.

Security grade badge for Extracting Acceptance Criteria
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/acendas-extracting-acceptance-criteria/badge)](https://www.skillsdirectory.com/skills/acendas-extracting-acceptance-criteria)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
SKILL.md
---
name: extracting-acceptance-criteria
description: Extract atomic acceptance criteria from a feature.
disable-model-invocation: true
---

# Extracting Acceptance Criteria

A feature description is usually a paragraph: "users should be able to create accounts with email + password, get a verification email, and log in once verified." That description has three or four implicit acceptance criteria woven together. This skill pulls them out into a list a builder can implement against and a reviewer can check.

The output is the **input** to `authoring-acceptance-probe` (which probes each AC) and `dispatching-spec-review` (which verifies each AC was met).

## When to Invoke

| Caller | Trigger |
|---|---|
| `/ship-discuss` | Right after the user's feature pitch crystallizes — convert prose into ACs before edge-case discovery |
| `/ship-spec` | When auditing or rewriting a feature spec; pull ACs out of buried prose |
| `/ship-sprint` | When breaking a feature into tasks, each task gets a slice of the feature's ACs |
| `/ship-discuss` (bug lane) | Convert a bug report into a regression AC ("the system shall not <symptom>"; the first AC is a failing test) |

If the spec already has a clean numbered AC list with one observable per item, don't invoke this skill — there's nothing to extract. Read and follow `discovering-edge-cases` instead to find missing ACs.

## Inputs

- `feature_text` — the prose description, user request, or existing spec section.
- `parent_context` — optional pointer to the parent feature/epic for inheritance (a sub-feature inherits the parent's domain ACs unless overridden).
- `domain_hints` — `["payments", "auth", "external-api", ...]`, used to pre-load domain-specific AC patterns (idempotency, audit, etc.).

## What an Acceptance Criterion Is

An AC is a single, observable, testable statement about what the system does (or doesn't do) under specific conditions. The shape:

> **Given** \<context\>, **when** \<action\>, **then** \<observable outcome\>.

Literal Given/When/Then phrasing is optional. The shape enforces three properties: a starting condition, a triggering action, and an observable outcome that a probe can check.

What an AC is NOT:

- A goal: "Make signup easy." (Not testable. Goals belong in the feature's purpose section.)
- An implementation note: "Use bcrypt for password hashing." (Implementation leaks. ACs talk about *what*, not *how*.)
- A vague qualifier: "Errors should be handled gracefully." (What does "gracefully" mean? Make it observable.)
- A multi-AC bullet: "Users can sign up, log in, and reset their password." (That's three ACs; split.)

## Extraction Procedure

Walk the feature text and produce ACs in three passes:

### Pass 1 — Surface the obvious

For each sentence in the feature text, ask: *"What is this asserting the system will do?"* If the answer is a behavior, draft an AC. If the answer is a goal/intention, skip — that goes in the purpose section.

Don't fight the feature text's wording yet — capture as written, normalize later.

### Pass 2 — Split compounds

Any AC mentioning "and" linking two distinct outcomes is at least two ACs. Same for "or." Split until each AC is atomic.

> **Compound (bad):** "When a user signs up, the system creates a row AND sends a verification email AND returns the user's id."

> **Atomic (good):**
> 1. When a user signs up with valid input, the system creates a `User` row.
> 2. When a user signs up with valid input, the system sends a verification email.
> 3. When a user signs up with valid input, the system returns the user's `id` in the response.

The atomic version is verbose but each line maps 1:1 to a probe.

### Pass 3 — Add the negative ACs

For every "shall do X" AC, ask: *"What's the corresponding 'shall not Y'?"* These are the cases the spec usually misses:

- "Shall create a row" → "shall NOT create a row when input is invalid."
- "Shall return the user's id" → "shall NOT leak the user's password hash in the response."
- "Shall send the email to that address" → "shall NOT send to any other address."

Negative ACs are where security and correctness bugs hide. Surface them explicitly.

## Output Shape

Return a structured list. Each entry:

```
{
  "id": "AC-<N>",
  "ac": "<the criterion as a Given/When/Then-shaped sentence>",
  "polarity": "positive" | "negative",
  "observable": "<what changes / what's returned / what's logged — the thing a probe can check>",
  "owner_layer": "frontend" | "backend" | "db" | "infra" | "cross-cutting",
  "domain_tags": ["<from domain_hints, if applicable>"],
  "tier": "core" | "e2e",
  "e2e_category": "<taxonomy slug from e2e-taxonomy.md, e.g. 'timeout', 'idempotency'>" | null,
  "verification_type": "probe" | "tool" | "manual"
}
```

Numbering is sequential (`AC-1`, `AC-2`, ...). The calling skill renumbers if it merges ACs from multiple sources.

The `observable` field is the bridge to `authoring-acceptance-probe`: a clear `observable` is what makes a good probe possible. If you can't fill `observable` with something concrete, the AC is too vague — refine it.

## Quality Checklist

Before returning, run each AC through:

- [ ] **Atomic** — one observable outcome per line.
- [ ] **Observable** — `observable` field has a concrete artifact (HTTP response field, DB row state, file content, logged event).
- [ ] **Testable** — could be encoded as an automated test or a probe command.
- [ ] **What, not how** — no library names, no specific algorithms, no infrastructure choices.
- [ ] **No vague qualifiers** — replace "fast", "user-friendly", "secure" with measurable bounds.
- [ ] **Negative companion present** — every positive AC has a "shall not" partner where applicable.
- [ ] **Owner layer assigned** — knowing which layer owns it helps `/ship-sprint` distribute tasks.
- [ ] **Tier assigned** — `tier` is `"core"` or `"e2e"`; `e2e_category` populated if and only if `tier` is `"e2e"`.

Hard cases: turn performance into a numeric budget (no number means the AC is not ready; surface it to the user via the calling skill), and phrase security, UX and compatibility ACs as observable absences, DOM state or schema diffs.

## E2E Acceptance Criteria Tiers

AC are organized into two tiers:

- **`tier: "core"`** — happy-path and edge-case scenarios derived from the feature discussion. These cover the feature's own logic. Default for all AC produced by the three-pass extraction above.
- **`tier: "e2e"`** — outer-bound operational scenarios derived from the E2E taxonomy (see `${CLAUDE_PLUGIN_ROOT}/skills/discovering-edge-cases/references/e2e-taxonomy.md`). These cover what happens at system boundaries: timeouts, idempotency, graceful degradation, privilege escalation, etc. Added by the `validating-e2e-coverage` capability skill during `/ship-discuss` Phase 3.7.

The `e2e_category` field is `null` for core AC and populated with a taxonomy slug (e.g., `"timeout"`, `"idempotency"`, `"privilege-escalation"`) for e2e AC.

The `verification_type` field determines how the AC is verified during sprint review:
- `"probe"` (default) — a shell command that exits 0 on pass. Standard for most AC.
- `"tool"` — requires a specific testing tool (e.g., Playwright, k6, lighthouse). Still a shell command but invokes specialized tooling.
- `"manual"` — requires human judgment (e.g., "degraded mode messaging is user-friendly"). Presented as a checklist item during review.

### Backward Compatibility

When reading AC that lack `tier`, `e2e_category`, or `verification_type` fields (pre-existing features), apply these defaults:
- `tier`: `"core"`
- `e2e_category`: `null`
- `verification_type`: `"probe"`

These defaults preserve full backward compatibility — existing features work unchanged. New fields are only populated explicitly by the extraction or validation skills.

## Output Discipline

1. **No padding.** If the feature text is small (one sentence), the output may be three ACs. Don't generate ten.
2. **Match the feature's scope.** ACs that go beyond what the feature text says should surface as `discovering-edge-cases` findings, not as ACs invented here.
3. **Confidence: include only ACs you'd defend** — if it's a stretch interpretation of the feature text, flag it as ambiguous and ask the user.
4. **Don't overlap with the spec's purpose section.** Goals/intentions stay there; this skill produces *what the system does*.

## Read-Only Contract

This skill produces a structured list; it does NOT edit the feature draft. The calling command skill folds the ACs into the spec's `## Acceptance Criteria` section after presenting to the user for approval.

## Pairing With Other Skills

- **`discovering-edge-cases`** runs after this — extracts ACs first, then surfaces what's missing. Edge cases become new ACs in a follow-up extraction pass.
- **`authoring-acceptance-probe`** runs per-AC after extraction stabilizes — each AC's `observable` field guides probe authoring.
- **`dispatching-spec-review`** verifies each AC during review — the AC list is the reviewer's checklist.

Attribution

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

View all in development →

Comments

Loading comments…

Newsletter

Get the weekly list of safe new skills, and the ones we pulled.