LI

lisa-acceptance-criteria

Defines testable acceptance criteria from a user perspective using Gherkin syntax and empirical verification.

Install

mkdir -p .claude/skills/lisa-acceptance-criteria && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/17274" && unzip -o skill.zip -d .claude/skills/lisa-acceptance-criteria && rm skill.zip

Installs to .claude/skills/lisa-acceptance-criteria

Activation

This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.

Acceptance criteria definition. Gherkin user flows (Given/When/Then), error states, UX concerns, and empirical verification from the user perspective.
150 chars✓ has a “when” trigger
Intermediate

Key capabilities

  • Understand the user goal for a feature.
  • Define step-by-step user flows, including happy and error paths.
  • Write testable acceptance criteria from the user's perspective.
  • Identify UX concerns like confusing interactions or missing feedback.
  • Map error states and user-facing behavior.
  • Empirically verify features by executing scripts or calling APIs.

How it works

The skill analyzes feature requirements to define user goals, create Gherkin user flows, write acceptance criteria, identify UX concerns, map error states, and then empirically verifies the feature against these criteria.

Inputs & outputs

You give it
Feature requirements or change description
You get back
Structured product analysis including user goal, Gherkin flows, acceptance criteria, UX concerns, error handling requirements, and verification results

When to use lisa-acceptance-criteria

  • Writing Gherkin acceptance criteria
  • Defining error handling requirements
  • Empirical testing of user flows
  • Identifying missing UX feedback

About this skill

Acceptance Criteria

Evaluate changes from a non-technical user's perspective. Define acceptance criteria and verify behavior matches requirements.

Analysis Process

  1. Understand the user goal -- what problem does this solve for the end user?
  2. Define user flows -- step-by-step paths through the feature, including happy path and error paths
  3. Write acceptance criteria -- testable conditions from the user's perspective
  4. Identify UX concerns -- confusing interactions, missing feedback, accessibility issues
  5. Map error states -- what happens when things go wrong, and what the user sees
  6. Run the feature -- execute scripts, call APIs, or trigger the described behavior to verify empirically
  7. Compare output to requirements -- does actual behavior match expectations?

Output Format

Structure findings as:

## Product Analysis

### User Goal
[1-2 sentence summary of what the user wants to accomplish]

### User Flows (Gherkin)

#### Happy Path
Given [precondition]
When [action]
Then [expected outcome]

#### Error Path: [description]
Given [precondition]
When [action that fails]
Then [error handling behavior]

### Acceptance Criteria
- [ ] [criterion from user perspective]

### UX Concerns
- [concern] -- impact on user experience

### Error Handling Requirements
| Error Condition | User Sees | User Can Do |
|----------------|-----------|-------------|

### Verification Results
For each acceptance criterion:
- **Criterion:** [what was expected]
- **Result:** Pass / Fail / Not Yet Testable
- **Evidence:** [what was observed]

### Out of Scope
- [thing that might be expected but is not part of this work]

Rules

  • Write acceptance criteria from the user's perspective, not the developer's
  • Every user flow must include at least one error path
  • Use Gherkin format (Given/When/Then) for user flows to enable direct translation into test cases
  • When verifying, always run the feature -- never review by only reading code
  • If you cannot run the feature (missing dependencies, services unavailable), report as a blocker -- do not guess
  • If the changes are purely internal (refactoring, config, tooling), report "No user-facing impact" and explain why
  • Do not propose UX changes beyond what was described -- flag scope concerns instead
  • Assume the reviewer has no technical background

When not to use it

  • When the changes are purely internal (refactoring, config, tooling) with no user-facing impact.
  • When the task involves proposing UX changes beyond what was described in the requirements.
  • When the feature cannot be run due to missing dependencies or unavailable services.

Limitations

  • The skill requires the ability to run the feature to perform empirical verification.
  • It does not propose UX changes beyond the described scope.
  • Acceptance criteria must be written from the user's perspective, not the developer's.

How it compares

This skill provides a structured, user-centric approach to defining and verifying acceptance criteria using Gherkin format and empirical testing, which is more rigorous than informal testing or code-only reviews.

Compared to similar skills

lisa-acceptance-criteria side by side with the closest alternatives in the catalog.

SkillInstallsUpdatedSafetyDifficulty
lisa-acceptance-criteria (this skill)021dNo flagsIntermediate
fmea-analysis05moReviewAdvanced
code-review-checklist39dNo flagsBeginner
openspec-verify-change35moReviewAdvanced

Try saying

Example prompts that trigger this skill in your AI assistant.

More by CodySwannGT

View all by CodySwannGT

lisa-setup-atlassian

CodySwannGT

Set up Atlassian (cloudId + acli profile) for this project. Writes the `atlassian` section of `.lisa.config.json` and enables the Atlassian MCP and/or installs acli as needed. Prerequisite for /lisa:setup:jira and /lisa:setup:confluence.

00

lisa-lint

CodySwannGT

Health-check the LLM Wiki: orphan pages, contradictions, stale claims, broken internal links, missing index/log coverage, structure violations, and secret/tenant leaks. Read-only — reports findings, does not fix them.

00

lisa-parity-code-review

CodySwannGT

Lisa-native code review of the current git diff. Walks every changed hunk and reports correctness bugs, security issues, and obvious defects as severity-ranked findings with file:line references. Vendor-neutral — the cross-agent equivalent of the upstream code-review command, runnable on Codex, agy,

00

lisa-prd-backlink

CodySwannGT

Update a source PRD with an always-written, machine-readable `## Tickets` (alias `## Generated Work`) section linking back to every work item created from it. Each entry carries a parseable ref + URL + type + parent token so the generated child set is readable without scraping prose. Vendor-aware on

00

lisa-epic-triage

CodySwannGT

9-step epic triage and 5-step implementation workflow. Ensures epics are fully scoped, broken down, and ordered before execution begins.

00

lisa-atlassian-access

CodySwannGT

Vendor-neutral access layer for Atlassian (JIRA + Confluence). Every jira-* and confluence-* skill MUST delegate through this skill rather than calling Atlassian directly. Resolves a substrate per operation, binding JIRA writes to the configured cloudId via Atlassian REST whenever token auth is avai

00

Search skills

Search the agent skills registry