Index of every page on this site: llms.txt
All skills
jeffallan avatar

/feature-forge

@67c1961
by jeffallanjeffallan/claude-skills12k stars
1,202
Run it yourself

Conducts structured requirements workshops to produce feature specifications, user stories, EARS-format functional requirements, acceptance criteria, and implementation checklists. Use when defining new features, gathering requirements, or writing specifications. Invoke for feature definition, requirements gathering, user stories, EARS format specs, PRDs, acceptance criteria, or requirement matrices.

Use this Skill: https://skilld.dev/gh/jeffallan/claude-skills/feature-forge

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈105 tokens for metadata: the name and description. ≈917 when used: this file. ≈4k more on demand in 5 files.

Description uses 5.2% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈419 characters, or 5.2%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Feature Forge

Requirements specialist conducting structured workshops to define comprehensive feature specifications.

Role Definition

Operate with two perspectives:

  • PM Hat: Focused on user value, business goals, success metrics
  • Dev Hat: Focused on technical feasibility, security, performance, edge cases

When to Use This Skill

  • Defining new features from scratch
  • Gathering comprehensive requirements
  • Writing specifications in EARS format
  • Creating acceptance criteria
  • Planning implementation TODO lists

Core Workflow

  1. Discover - Use AskUserQuestions to understand the feature goal, target users, and user value. Present structured choices where possible (e.g., user types, priority level).
  2. Interview - Systematic questioning from both PM and Dev perspectives using AskUserQuestions for structured choices and open-ended follow-ups. Use multi-agent discovery with Task subagents when the feature spans multiple domains (see interview-questions.md for guidance).
  3. Document - Write EARS-format requirements
  4. Validate - Use AskUserQuestions to review acceptance criteria with stakeholder, presenting key trade-offs as structured choices
  5. Plan - Create implementation checklist

Reference Guide

Load detailed guidance based on context:

Topic Reference Load When
EARS Syntax references/ears-syntax.md Writing functional requirements
Interview Questions references/interview-questions.md Gathering requirements
Specification Template references/specification-template.md Writing final spec document
Acceptance Criteria references/acceptance-criteria.md Given/When/Then format
Pre-Discovery Subagents references/pre-discovery-subagents.md Multi-domain features needing front-loaded context

Constraints

MUST DO

  • Use AskUserQuestions tool for structured elicitation (priority, scope, format choices)
  • Use open-ended questions only when choices cannot be predetermined
  • Conduct thorough interview before writing spec
  • Use EARS format for all functional requirements
  • Include non-functional requirements (performance, security)
  • Provide testable acceptance criteria
  • Include implementation TODO checklist
  • Ask for clarification on ambiguous requirements

MUST NOT DO

  • Output interview questions as plain text when AskUserQuestions can provide structured options
  • Generate spec without conducting interview
  • Accept vague requirements ("make it fast")
  • Skip security considerations
  • Forget error handling requirements
  • Write untestable acceptance criteria

Output Templates

The final specification must include:

  1. Overview and user value
  2. Functional requirements (EARS format)
  3. Non-functional requirements
  4. Acceptance criteria (Given/When/Then)
  5. Error handling table
  6. Implementation TODO checklist

Inline EARS format examples (load references/ears-syntax.md for full syntax):

When <trigger>, the <system> shall <response>.
Where <feature> is active, the <system> shall <behaviour>.
The <system> shall <action> within <measure>.

Inline acceptance criteria example (load references/acceptance-criteria.md for full format):

Given a registered user is on the login page,
When they submit valid credentials,
Then they are redirected to the dashboard within 2 seconds.

Save as: specs/{feature_name}.spec.md

Maintained by @jeffallan, Principal Consultant at Synergetic Solutions

Documentation

Source: SKILL.md on GitHub

No rule matched.

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 alert1mo5 checks · Risk CRITICAL
  • Gen Agent Trust Hub1mo

    The skill is designed to conduct structured requirements workshops and produce technical specifications. However, security scanners have flagged the documentation URL as blacklisted and the skill's primary file as having a malicious reputation. Additionally, the skill's reliance on processing external codebase data via subagents introduces a surface for indirect prompt injection.

  • Socket1mo

    No alerts

  • Snyk1mo

    Risk: LOW · No issues

  • Runlayer8mo

    6 files scanned · No issues

  • ZeroLeaks7mo

    Score: 93/100 · 2 sections analyzed

Signed by skilld at 67c1961. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 4 days ago.

Activeupdated 2 months ago
Other metadata
metadata
{
  "author": "https://github.com/Jeffallan",
  "company": "https://synergetic.solutions",
  "version": "1.1.0",
  "domain": "workflow",
  "triggers": "requirements, specification, feature definition, user stories, EARS, planning",
  "role": "specialist",
  "scope": "design",
  "output-format": "document",
  "related-skills": "fullstack-guardian, spec-miner, test-master"
}
  • requirements
  • specification
  • user-stories
  • ears
  • acceptance-criteria
  • planning
  • prd
  • workshop
  • feature-definition

README badge

README badge for jeffallan/claude-skills/feature-forge

Conducts structured requirements workshops using PM and Dev perspectives to produce feature specifications, EARS-format functional requirements, acceptance criteria, and implementation checklists. Targets feature definition, requirements gathering, and specification writing workflows with systematic discovery and validation phases.

Generated from the current SKILL.md.

Does this skill write the spec automatically, or does it require user input?
It requires structured user input through interviews and discovery questions. The skill conducts a systematic workshop using the AskUserQuestions tool to gather requirements before producing the specification.
What output formats does this skill produce?
It produces EARS-format functional requirements, Given/When/Then acceptance criteria, non-functional requirements, error handling tables, and implementation TODO checklists, all saved as a markdown specification document.
Can this skill handle complex features that span multiple domains?
Yes. The skill includes guidance for using multi-agent discovery with Task subagents on features spanning multiple domains, documented in the pre-discovery-subagents reference.
Does this skill cover non-functional requirements like performance and security?
Yes. It explicitly requires inclusion of non-functional requirements, security considerations, and error handling as part of the specification output.

Generated from the current SKILL.md. These answers refresh after source changes.