Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
pixel-process-ug avatar

Acceptance Testing

  • 71 installs
  • 1 repo stars
  • Updated March 16, 2026
  • pixel-process-ug/superkit-agents

Helps with testing & qa tasks.

About

acceptance-testing is a Claude Code skill for testing & qa. It helps solo builders move faster with AI-assisted development.

  • acceptance-testing
  • Testing & QA
  • AI-coding skill

Acceptance Testing by the numbers

  • 71 all-time installs (skills.sh)
  • +3 installs in the week ending Aug 4, 2026 (Skillselion tracking)
  • Ranked #1,094 of 2,153 Testing & QA skills by installs in the Skillselion catalog
  • Data as of Aug 4, 2026 (Skillselion catalog sync)
npx skills add https://github.com/pixel-process-ug/superkit-agents --skill acceptance-testing

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs71
repo stars1
Last updatedMarch 16, 2026
Repositorypixel-process-ug/superkit-agents

What it does

Helps with testing & qa tasks.

Files

SKILL.mdMarkdownGitHub ↗

Acceptance Testing

Overview

Acceptance-driven backpressure connects specification acceptance criteria directly to test requirements, creating a validation chain that prevents premature completion claims. The system cannot cheat — you cannot claim a feature is done unless tests derived from spec acceptance criteria actually pass.

Announce at start: "I'm using the acceptance-testing skill to validate against specification criteria."

---

The Backpressure Chain

+------------+     derives      +------------+     validates    +------------+
|   SPECS    |---------------->|   TESTS    |---------------->|   CODE     |
|            |                  |            |                  |            |
| Acceptance |                  | Test cases |                  | Must pass  |
| Criteria   |                  | from AC    |                  | all tests  |
+------------+                  +------------+                  +------------+
      ^                                                              |
      |                    backpressure                               |
      +--------------------------------------------------------------+
      If tests fail, implementation must change (not the spec or test)

---

Phase 1: Extract Acceptance Criteria

Goal: From each specification file, extract all Given/When/Then acceptance criteria.

Actions

1. Locate all specification files (specs/*.md) 2. Extract every acceptance criterion with its ID 3. Document in structured format

Example Extraction

## From spec: 01-color-extraction.md

### AC-1: Extract dominant colors
- Given an uploaded image (PNG, JPG, or WebP)
- When color extraction is triggered
- Then 5-10 dominant colors are returned
- And each color includes hex, RGB, and HSL representations

### AC-2: Handle invalid images
- Given a corrupted or unsupported file
- When color extraction is attempted
- Then an appropriate error is returned
- And no partial results are produced

STOP — HARD-GATE: Do NOT proceed to Phase 2 until:

  • [ ] All spec files are located and read
  • [ ] Every acceptance criterion is extracted with an ID
  • [ ] Criteria are in Given/When/Then format
  • [ ] No criteria are ambiguous (if ambiguous, clarify with spec author)

---

Phase 2: Derive Test Cases

Goal: Map every acceptance criterion to at least one test case.

┌─────────────────────────────────────────────────────────────────┐
│  HARD-GATE: Every acceptance criterion must have at least one   │
│  corresponding test. No exceptions. If a criterion has no       │
│  test, the feature is NOT complete.                             │
└─────────────────────────────────────────────────────────────────┘

Traceability Table

Acceptance CriterionTest TypeTest DescriptionTest File:Line
AC-1: Extract dominant colorsIntegrationUpload valid image, verify 5-10 colors with hex/RGB/HSLtest/color.test.js:15
AC-2: Handle invalid imagesIntegrationUpload corrupted file, verify error, verify no partial datatest/color.test.js:42

Decision Table: Test Type for Acceptance Criteria

Criterion TypeTest TypeRationale
Data input/output behaviorIntegrationTests real data flow
Error handling behaviorIntegrationTests error paths end-to-end
Performance requirementLoad testRequires measurement under load
UI behaviorE2E (Playwright)Tests real browser interaction
Subjective qualityLLM-as-judgeCannot be deterministically tested
Security requirementIntegration + security testTests authorization and input validation

STOP — HARD-GATE: Do NOT proceed to Phase 3 until:

  • [ ] Every acceptance criterion has at least one test mapped
  • [ ] Test types are appropriate for the criterion type
  • [ ] Test file locations are identified

---

Phase 3: Write Tests Before Implementation

Goal: Write acceptance tests that will fail until the feature is correctly implemented.

Actions

This phase integrates with test-driven-development:

1. Write test from acceptance criterion (RED) 2. Implement feature to pass test (GREEN) 3. Refactor while keeping test green (REFACTOR)

Behavioral Outcome Focus

Verify This (Behavioral)NOT This (Implementation)
"5-10 colors are returned""K-means runs with k=8"
"Response time < 200ms""Cache is hit on second call"
"Error message is user-friendly""CustomError class is thrown"
"Data persists across sessions""PostgreSQL INSERT executes"
"UI updates within 500ms""WebSocket message is received"

STOP — HARD-GATE: Do NOT proceed to Phase 4 until:

  • [ ] All acceptance tests are written
  • [ ] Tests fail before implementation (RED confirmed)
  • [ ] Tests verify behavioral outcomes, not implementation details

---

Phase 4: Validation Gates

Goal: Before claiming any task complete, ALL gates must pass.

GateCheckToolRequired
Unit testsAll passTest runnerAlways
Integration testsAll passTest runnerAlways
Acceptance testsAll AC-derived tests passTest runnerAlways
BuildCompiles without errorsBuild toolAlways
LintNo violationsLinterAlways
TypecheckNo type errorsType checkerWhen applicable
┌─────────────────────────────────────────────────────────────────┐
│  HARD-GATE: ACCEPTANCE                                         │
│                                                                 │
│  Cannot claim completion without ALL acceptance tests passing.  │
│  If any acceptance test fails, the feature is NOT done.        │
│  Fix the implementation, not the spec or the test.             │
└─────────────────────────────────────────────────────────────────┘

STOP — HARD-GATE: Do NOT proceed to Phase 5 until:

  • [ ] All validation gates pass
  • [ ] Acceptance tests pass with green status
  • [ ] No gates are skipped or marked as "will fix later"

---

Phase 5: Traceability Report

Goal: Produce a report linking every spec criterion to its test and result.

Report Template

## Acceptance Test Report

| Spec | Criterion | Test | Status |
|------|-----------|------|--------|
| 01-color-extraction.md | AC-1: Extract dominant colors | test/color.test.js:15 | PASS |
| 01-color-extraction.md | AC-2: Handle invalid images | test/color.test.js:42 | PASS |
| 02-palette-rendering.md | AC-1: Render palette grid | test/palette.test.js:8 | PASS |

### Summary
- Total criteria: N
- Tested: N
- Passing: N
- Failing: 0
- Coverage: 100%

---

Anti-Patterns / Common Mistakes

Anti-PatternWhy It Is WrongCorrect Approach
Changing specs to match implementationDefeats the purpose of specificationFix the implementation, not the spec
Skipping edge case criteriaEdge cases cause production bugsALL acceptance criteria get tests
Testing implementation detailsBrittle tests that break on refactorTest observable behavioral outcomes
Claiming "tests pass" without acceptance testsUnit tests alone are insufficientAcceptance tests are a separate, required category
Writing acceptance tests after implementationTests shaped to pass, not to specifyWrite BEFORE implementation (TDD)
Deferring acceptance tests to "later"Later never comesWrite them in Phase 2, before coding
Marking failing tests as "known issues"Hides incomplete implementationFix the code until tests pass

---

Rationalization Prevention

ExcuseReality
"The unit tests cover this"Unit tests test components in isolation; acceptance tests verify integrated behavior
"The spec is obvious, no need for formal tests"Obvious specs still need verifiable tests
"We can manually verify this"Manual verification is not repeatable or trustworthy
"The acceptance criteria are too vague to test"Clarify the criteria; vague specs produce vague code
"This is just a cosmetic change"Cosmetic changes can break layout, accessibility, and UX

---

Integration Points

SkillRelationship
spec-writingAcceptance criteria come from specs
test-driven-developmentTDD cycle uses acceptance-derived tests
llm-as-judgeFor subjective criteria that cannot be deterministically tested
verification-before-completionFinal verification includes acceptance test check
autonomous-loopExit gate requires acceptance tests passing
code-reviewReview checks acceptance test coverage
planningPlan includes acceptance test writing as explicit tasks

---

Skill Type

RIGID — The backpressure chain must not be bypassed. Every acceptance criterion must have a test. No completion without passing acceptance tests. Fix the implementation, not the spec or the test.

Related skills

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.