discover-acs

Discover feature acceptance criteria in domain language and write acs.md.

134|9|Updated Feb 16, 2026
One-click install
npx skills add https://github.com/swingerman/disciplined-agentic-engineering --skill discover-acs
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: discover-acs
Source: https://github.com/swingerman/disciplined-agentic-engineering/tree/main/engineer/skills/discover-acs
Command: npx skills add https://github.com/swingerman/disciplined-agentic-engineering --skill discover-acs

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps teams clarify what behaviors a feature must deliver in domain language, before the details get locked into Given/When/Then specifications.

Core Features & Use Cases

  • AC discovery (Checkpoint 2): Generates a feature's acceptance criteria and writes them to acs.md using a structured four-pass interview.
  • Greenfield vs reverse-engineer modes: Creates ACs from scratch for new work or extracts candidate ACs from existing specs/design/code to fill gaps.
  • Deterministic handoff with guardrails: Enforces checkpoint gating and produces a handoff summary that directs the next skill to formalize specs or reconcile consistency.

Quick Start

Run the command to have your AI team discover acceptance criteria for the current feature and produce acs.md for later spec formalization.

Frequently Asked Questions about discover-acs

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I discover acceptance criteria for a feature before writing Gherkin specs?

Discovering acceptance criteria involves a structured four-pass interview to clarify required behaviors in domain language before formalizing Given/When/Then specifications. This approach generates an acs.md file with numbered AC sections to guide subsequent spec creation.

How do I reverse-engineer acceptance criteria from existing code and specs?

Reverse-engineering acceptance criteria from existing code extracts candidate ACs from current specs, design documents, and implementations to identify gaps. It uses gap interviews to fill missing behaviors and produces a complete set of acceptance criteria for existing features.

When do I need to formalize acceptance criteria using domain language?

You need to formalize acceptance criteria using domain language when a feature requires clear behavior definitions before locking in detailed Given/When/Then specifications. This prevents misalignment by capturing business rules in shared terminology before technical spec writing.

Does this acceptance criteria discovery process support greenfield features?

Yes, the acceptance criteria discovery process supports greenfield features by creating ACs from scratch through a structured interview. It also handles in-progress or completed features by reverse-engineering existing work to find missing criteria.

What guardrails are needed for acceptance criteria discovery and handoff?

Acceptance criteria discovery requires checkpoint gating via dae_handoff.py and branch validation via dae_branch.py to enforce process consistency. These guardrails produce a deterministic handoff summary directing the next phase to formalize specs or reconcile consistency.

Why extract acceptance criteria before creating Given/When/Then specifications?

Extracting acceptance criteria before Given/When/Then specifications ensures teams clarify exact feature behaviors in domain language first. This prevents premature technical locking and produces verified exit criteria evidence for a smoother formal spec handoff.