# Verify Acceptance Criteria

> |

- **Type:** Skill
- **Install:** `agentstack add skill-felipecabargas-gambit-verify-acceptance-criteria`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [felipecabargas](https://agentstack.voostack.com/s/felipecabargas)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [felipecabargas](https://github.com/felipecabargas)
- **Source:** https://github.com/felipecabargas/gambit/tree/main/skills/verify-acceptance-criteria

## Install

```sh
agentstack add skill-felipecabargas-gambit-verify-acceptance-criteria
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Acceptance Criteria Verifier

## When to Use

Use this skill to evaluate acceptance criteria quality. It's most valuable when:
- Reviewing criteria before development starts (catch issues early)
- Auditing existing criteria that have caused confusion or rework
- Ensuring criteria align with product standards
- Converting vague requirements into precise, testable statements
- Preparing criteria for team handoff to engineering

## Input Format

The skill accepts acceptance criteria in multiple formats:
- **Plain text**: A list pasted directly into the message
- **Markdown**: Bullet points or numbered lists
- **CSV/Excel**: Uploaded spreadsheet files
- **JSON**: Structured data
- **Mixed**: Any combination of the above

Example inputs:
```
Given the user is logged in
When they navigate to the dashboard
Then they should see a list of their recent items
```

Or:
```
- Display loads within 2 seconds
- All product images render correctly
- User can filter by category
```

## Evaluation Framework

Each acceptance criterion is evaluated against **five dimensions of quality**:

### 1. Clarity & Conciseness
- Is the language plain and unambiguous?
- Can all stakeholders interpret it the same way?
- Is it free of jargon or unexplained terms?
- Does it say exactly one thing, clearly?

**Critical Issues**: Ambiguous terms with multiple interpretations  
**Major Issues**: Vague language; jargon without definition  
**Minor Issues**: Wordy phrasing that could be tightened

### 2. Testability
- Can this criterion be objectively verified?
- Can it be mapped to one or more executable tests?
- Is there a clear pass/fail outcome?
- Would a QA engineer know exactly how to test it?

**Critical Issues**: No way to objectively verify the criterion  
**Major Issues**: Testability requires subjective judgment; unclear success state  
**Minor Issues**: Testable but the test path is not obvious

### 3. Outcome-Focused
- Does it describe the result, not the recipe?
- Does it focus on what the user experiences?
- Is it free of implementation details?
- Does it avoid prescribing the "how"?

**Critical Issues**: Criterion specifies technical implementation steps  
**Major Issues**: Mixes outcome with technical approach  
**Minor Issues**: Slight hints of implementation preference

### 4. Measurability
- Are expectations quantified where possible?
- Is there a definitive pass/fail threshold?
- Can success be objectively verified with data?
- Would different teams measure it the same way?

**Critical Issues**: No quantifiable metrics; purely subjective  
**Major Issues**: Quantification is vague ("fast", "many", "some")  
**Minor Issues**: Could be more precise (e.g., "300px" instead of "large")

### 5. Independence
- Does this criterion stand alone?
- Would it make sense without the others?
- Does it depend on other criteria to be meaningful?
- Can it be tested in isolation?

**Critical Issues**: Cannot be understood or tested without multiple other criteria  
**Major Issues**: Requires significant context from other criteria  
**Minor Issues**: Minor reference to another criterion for context

## Output Format

The skill generates a structured JSON report:

```json
{
  "summary": {
    "total_criteria": 5,
    "passed": 2,
    "failed": 3,
    "critical_issues": 2,
    "major_issues": 4,
    "minor_issues": 1,
    "overall_score": 65
  },
  "evaluations": [
    {
      "id": 1,
      "criterion": "The page should load fast",
      "status": "failed",
      "issues": [
        {
          "dimension": "Measurability",
          "severity": "critical",
          "description": "The term 'fast' is not quantified. What constitutes fast? 1 second? 5 seconds?"
        },
        {
          "dimension": "Testability",
          "severity": "major",
          "description": "Without a specific metric, QA cannot objectively verify this criterion."
        }
      ],
      "rewritten_option": "The page loads and displays all content within 2 seconds on a standard 4G connection"
    }
  ],
  "recommendations": [
    "Add specific metrics to 3 criteria that currently use vague descriptors",
    "Clarify technical dependencies between criteria 2 and 4",
    "Consider breaking criterion 5 into two independent criteria"
  ]
}
```

## How the Skill Works

### Step 1: Parse Input
The skill first identifies and extracts all acceptance criteria from the input, regardless of format.

### Step 2: Evaluate Against Five Dimensions
For each criterion, the skill evaluates it against:
- Clarity & Conciseness
- Testability
- Outcome-Focus
- Measurability
- Independence

### Step 3: Identify Issues
The skill identifies specific issues for each criterion and assigns a severity level:
- **Critical** (~45% of score): Issues that prevent testing or create ambiguity
- **Major** (~35% of score): Issues that make the criterion harder to interpret or test
- **Minor** (~20% of score): Issues that could be improved but don't block delivery

### Step 4: Calculate Scores
- Individual criterion score: (5 dimensions - issues) / 5 * 100
- Overall score: average of all criteria
- Pass threshold: 80+ is considered "good" quality

### Step 5: Suggest Improvements
For each failed criterion, the skill proposes a rewritten version that addresses the identified issues.

### Step 6: Generate Report
Output is structured JSON that can be:
- Reviewed directly in the chat
- Saved as a file for documentation
- Integrated into your workflow tools
- Used as the basis for discussions with your team

## Bonus: Rewrite to User Story Format

After generating the report, you can ask the skill to convert the improved acceptance criteria into full user story format:

```
As a [user type],
I want to [action],
So that [benefit].

Acceptance Criteria:
- [Criterion 1]
- [Criterion 2]
...
```

This provides context for engineering teams and helps them understand the "why" behind each criterion.

## Pro Tips

**1. Start with high-level scenarios**: If your input is very technical or vague, ask the skill to first help you write clear Given-When-Then scenarios.

**2. Review one criterion at a time**: For complex features, don't try to perfect all criteria at once. Review, implement, then move to the next.

**3. Use this before planning**: Run this evaluation during backlog refinement, not during sprint planning—catching issues early saves days of rework.

**4. Involve your QA team**: The testability dimension is often where QA engineers catch gaps. Use this report as a conversation starter.

**5. Iterate with stakeholders**: If the skill identifies ambiguity, use the report to drive a quick discussion with product and engineering about what you actually mean.

## Example: From Vague to Good

**Before (Failed):**
```
"The user should be able to search easily and find results quickly"
```

**Issues:**
- Measurability (critical): "easily" and "quickly" are subjective
- Testability (major): No clear way to verify  
- Clarity (minor): What is "search"? Database search, full-text, autocomplete?

**After (Passed):**
```
"The search results page displays at least 10 matching products within 1.5 seconds of the user typing their search query"
```

This version is measurable, testable, clear, and outcome-focused.

---

## How to Trigger This Skill

Ask your assistant to verify acceptance criteria by saying things like:
- "Review these acceptance criteria and tell me if they're good"
- "Check if these ACs will cause problems during testing"
- "Audit our user story criteria against quality standards"
- "Are these acceptance criteria testable?"
- "Rewrite these acceptance criteria to be clearer"
- "Do we have enough detail in these ACs for the team to start work?"

This skill will automatically and generate a structured evaluation report.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [felipecabargas](https://github.com/felipecabargas)
- **Source:** [felipecabargas/gambit](https://github.com/felipecabargas/gambit)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-felipecabargas-gambit-verify-acceptance-criteria
- Seller: https://agentstack.voostack.com/s/felipecabargas
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.