plan-change

Create ADR and Gherkin specification documents for software changes.

Updated Jun 3, 2026
One-click install
npx skills add https://github.com/0xdeafcafe/skills --skill plan-change-0xdeafcafe
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan-change
Source: https://github.com/0xdeafcafe/skills/tree/main/skills/plan-change
Command: npx skills add https://github.com/0xdeafcafe/skills --skill plan-change-0xdeafcafe

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams turn vague change ideas into concrete, reviewable planning artifacts before implementation begins. It prevents under-specified work by guiding an interactive discussion that produces an architecture decision record and a behavioural Gherkin spec when they are actually needed.

Core Features & Use Cases

  • Interactive change discovery: Clarifies scope, user flows, edge cases, alternatives, and out-of-scope boundaries through structured follow-up questions.
  • Dual-document planning: Creates an ADR for architectural decisions and a .feature spec for behavioural expectations, with cross-links to keep rationale and behaviour aligned.
  • Convention matching: Inspects the repository for existing ADR and spec patterns, then follows local naming, formatting, and commit conventions.
  • Right-sized output: Writes both documents when warranted, or only one when the change is purely architectural or purely behavioural.
  • Use case: Use it when starting a new feature, a meaningful refactor, or a bug fix that changes design assumptions and should be documented before code is written.

Quick Start

Ask the agent to use plan-change to design your upcoming feature or refactor and produce the right ADR and Gherkin spec for the repository.

Frequently Asked Questions about plan-change

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

FAQPage Schema
How do I create an ADR and Gherkin specification before starting a feature implementation?

To create an ADR and Gherkin specification, you can use a structured planning workflow that drives interactive discussion to produce architecture decision records and behavioural feature files. This ensures technical rationale and acceptance scenarios are documented before code is written.

What is the best way to plan a software refactor that changes design assumptions?

The best way to plan a software refactor is to clarify scope, edge cases, and alternatives through interactive discovery, resulting in right-sized planning artifacts. This approach produces an ADR for architectural changes or a Gherkin spec for behavioural shifts to prevent under-specified work.

When do I need an architecture decision record versus a Gherkin feature file?

You need an architecture decision record for architectural choices and a Gherkin feature file for behavioural expectations. A dual-document approach writes both when warranted, but produces only one if the change is purely architectural or purely behavioural.

Can I automatically match existing repository conventions when writing ADRs and feature specs?

Yes, you can match existing repository conventions by inspecting the codebase for current ADR and spec patterns. The planning process follows local naming, formatting, and commit conventions to ensure new documents align with your established repository workflows.

How do I document scope boundaries and out-of-scope items for a new feature kickoff?

To document scope boundaries for a feature kickoff, engage in an interactive change discovery process that clarifies user flows and explicitly defines out-of-scope boundaries. This yields reviewable planning artifacts that cross-link decision rationale with behavioural specifications.

Does this planning approach work for significant bug fixes that alter system behaviour?

Yes, this planning approach works for significant bug fixes that alter system behaviour by generating Gherkin specifications to capture the expected new behaviour. It also creates an ADR if the fix changes underlying design assumptions or architecture.