bdd-with-approvals

Create executable BDD specifications using approval files with domain-specific language.

3|Updated Mar 4, 2026
One-click install
npx skills add https://github.com/scute-sh/scute --skill bdd-with-approvals-scute-sh
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: bdd-with-approvals
Source: https://github.com/scute-sh/scute/tree/main/.claude/skills/bdd-with-approvals
Command: npx skills add https://github.com/scute-sh/scute --skill bdd-with-approvals-scute-sh

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of specifications drifting from reality and tests being too noisy to validate quickly. It provides a way to create executable artifacts that serve as both specifications and tests, ensuring they stay in sync and are easily human-validatable.

Core Features & Use Cases

  • Executable Specifications: Write specifications before implementation, driven by creating approval files that describe expected behavior.
  • Human-Validatable Artifacts: Use domain-specific language and formats (like ASCII art for spatial problems or before/after for transformations) that allow for quick visual validation.
  • Use Case: When designing a new feature, create approval files outlining user scenarios and expected outcomes. The implementation then focuses on making these specifications pass, ensuring the code directly reflects the intended behavior.

Quick Start

Use the bdd-with-approvals skill to create a new executable specification for the user login flow.

Frequently Asked Questions about bdd-with-approvals

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

FAQPage Schema
How do I prevent test specifications from drifting from the actual implementation?

Executable specifications prevent drifting by acting as both human-readable specifications and tests. You create approval files using domain-specific language before implementation, ensuring the code directly reflects the intended behavior and stays in sync.

What is the best way to write executable specifications for complex process modeling?

The best way to write executable specifications for complex processes is using approval testing with human-validatable artifacts. You model scenarios in domain-specific language formats like ASCII art for spatial problems, allowing quick visual validation of input-output transformations.

How does approval testing work with behavior-driven development?

Approval testing facilitates behavior-driven development by allowing you to write specifications before implementation. You generate fixture files describing expected behavior in domain language, which then drive the implementation to ensure the code validates against these human-readable artifacts.

Can I use approval testing for visual algorithm testing and input-output validation?

Yes, approval testing supports scenarios requiring input-output validation, complex process modeling, and visual algorithm testing. You use domain-specific language in human-readable fixture files to model expected transformations and spatial problems for quick visual validation.

Why are my behavior-driven development tests too noisy to validate quickly?

Tests become noisy when they lack human-validatable artifacts. By using approval testing techniques with domain-specific language in fixture files, you create scannable specifications that serve as both documentation and validation, reducing noise and enabling rapid visual verification.

Do I need test-driven development experience to create executable specifications?

While test-driven development knowledge helps, executable specifications focus on writing approval files in domain-specific language before implementation. The approach emphasizes creating human-readable artifacts that drive implementation, making it accessible for defining clear user scenarios and expected outcomes.