require-kit Command Usage Guide¶

Version: 2.0.0 Last Updated: 2026-02-20

Table of Contents¶

Quick Command Reference
Requirements Management Commands
Epic Management Commands
Feature Management Commands
Hierarchy Commands
Sync Commands
Export and Integration Commands
Complete Workflow Examples

Quick Command Reference¶

Requirements Commands¶

Command	Purpose	Example
`/gather-requirements`	Interactive requirements gathering	`/gather-requirements user-auth`
`/formalize-ears`	Convert to EARS notation	`/formalize-ears draft/auth.md`
`/generate-bdd`	Create Gherkin scenarios	`/generate-bdd REQ-001`

Epic Management Commands¶

Command	Purpose	Example
`/epic-create`	Create strategic epic	`/epic-create "User Management"`
`/epic-status`	View epic progress	`/epic-status EPIC-001`
`/epic-refine`	Interactively refine epic	`/epic-refine EPIC-001`
`/epic-sync`	Sync with PM tools	`/epic-sync EPIC-001 --jira`

Feature Management Commands¶

Command	Purpose	Example
`/feature-create`	Create feature with epic linkage	`/feature-create "Auth" epic:EPIC-001`
`/feature-status`	View feature progress	`/feature-status FEAT-001`
`/feature-refine`	Interactively refine feature	`/feature-refine FEAT-001`
`/feature-sync`	Sync feature with PM tools	`/feature-sync FEAT-001 --jira`
`/feature-generate-tasks`	Generate task specifications	`/feature-generate-tasks FEAT-001`

Hierarchy Commands¶

Command	Purpose	Example
`/hierarchy-view`	View project hierarchy	`/hierarchy-view EPIC-001`

Sync Commands¶

Command	Purpose	Example
`/requirekit-sync`	Sync to Graphiti knowledge graph	`/requirekit-sync --all`

Requirements Management Commands¶

`/gather-requirements` - Interactive Requirements Gathering¶

Purpose: Conduct guided Q&A sessions to capture complete requirements.

Basic Usage:

/gather-requirements

With Feature Name:

/gather-requirements user-authentication

With Context:

/gather-requirements user-authentication --context="Web application for healthcare"

Output:

✅ Requirements Gathering Complete

Captured Requirements:
- Functional: 12 items
- Non-Functional: 5 items
- Security: 4 items
- Performance: 3 items

Output File: docs/requirements/draft/user-authentication.md

Next Steps:
1. Review captured requirements
2. Formalize with /formalize-ears
3. Generate BDD with /generate-bdd

Question Categories: - Problem Definition - User Roles and Personas - Functional Behavior - Error Handling - Performance Requirements - Security Constraints - Compliance Needs - Integration Points - Future Considerations

`/formalize-ears` - Convert to EARS Notation¶

Purpose: Transform natural language requirements into structured EARS notation.

Basic Usage:

/formalize-ears

From Specific File:

/formalize-ears docs/requirements/draft/user-authentication.md

With Validation:

/formalize-ears --validate --strict

Output:

✅ EARS Formalization Complete

Generated Requirements:
- Ubiquitous: 3 requirements
- Event-Driven: 5 requirements
- State-Driven: 4 requirements
- Unwanted Behavior: 3 requirements
- Optional Feature: 2 requirements

Total: 17 EARS requirements

Files Created:
- docs/requirements/REQ-001.md through REQ-017.md

Validation Results:
✅ All requirements are atomic
✅ All requirements are testable
✅ All requirements have measurable criteria
✅ No conflicts detected
✅ Coverage complete

Next Steps:
1. Review generated EARS requirements
2. Generate BDD scenarios: /generate-bdd

EARS Patterns:

Ubiquitous: The [system] shall [behavior]

REQ-001: The system shall encrypt all passwords using bcrypt with cost factor 12.

Event-Driven: When [trigger], the [system] shall [response]

REQ-002: When a user submits valid credentials, the system shall authenticate
         within 1 second and redirect to the dashboard.

State-Driven: While [state], the [system] shall [behavior]

REQ-003: While a user session is active, the system shall validate the session
         token on each request.

Unwanted Behavior: If [error], then the [system] shall [recovery]

REQ-004: If authentication fails 3 times within 5 minutes, then the system shall
         lock the account for 15 minutes and send a security alert email.

Optional Feature: Where [feature], the [system] shall [behavior]

REQ-005: Where the user has selected "Remember Me", the system shall maintain
         the session for 30 days with automatic token refresh.

`/generate-bdd` - Create BDD/Gherkin Scenarios¶

Purpose: Generate testable Gherkin scenarios from EARS requirements.

Basic Usage:

/generate-bdd

For Specific Requirement:

/generate-bdd REQ-001

For Feature:

/generate-bdd --feature FEAT-001

For Epic:

/generate-bdd --epic EPIC-001

Output:

✅ BDD Generation Complete

Generated Scenarios:
- Feature: User Authentication
  - 8 scenarios (6 positive, 2 negative)
  - Coverage: REQ-001 through REQ-005

Files Created:
- docs/bdd/BDD-001-user-authentication.feature

Scenario Types:
✅ Happy Path: 4 scenarios
✅ Error Handling: 2 scenarios
✅ Performance: 1 scenario
✅ Security: 1 scenario

Tags Applied:
@requirement-REQ-XXX (links to requirements)
@epic-EPIC-001 (links to epic)
@feature-FEAT-001 (links to feature)
@smoke, @critical (test priority)

Next Steps:
1. Review generated scenarios with stakeholders
2. Export to test framework
3. Link to features: /feature-create with bdd:[BDD-001]

Example Generated Scenario:

@epic-EPIC-001 @feature-FEAT-001 @requirement-REQ-002
Scenario: Successful user login
  Given a registered user with email "user@example.com"
  And the user's password is "Valid123!"
  When the user submits the login form
  Then the user should be authenticated
  And the user should be redirected to "/dashboard"
  And a session cookie should be created
  And the authentication should complete within 1 second

Epic Management Commands¶

`/epic-create` - Create Strategic Epic¶

Purpose: Create a new epic representing a strategic initiative or major feature area.

Basic Usage:

/epic-create "User Management System"

With Organisation Pattern:

# Standard pattern (default): Epic → Feature → Task
/epic-create "E-Commerce Platform" --pattern standard

# Direct pattern: Epic → Task (skip feature layer for small focused epics)
/epic-create "Config Refactor" --pattern direct

# Mixed pattern: Epic → Feature + Task (transitional use only)
/epic-create "API Integration Layer" --pattern mixed

With Metadata:

/epic-create "User Management System" \
  priority:high \
  business_value:8 \
  effort_estimate:21 \
  stakeholders:[pm@company.com,lead@company.com]

With PM Tool Integration:

/epic-create "User Management System" \
  priority:high \
  export:[jira,linear]

Organisation Patterns:

Pattern	Structure	Best For
`standard`	Epic → Feature → Task	Large epics with 8+ tasks across distinct capabilities
`direct`	Epic → Task	Small, focused epics with 3–5 closely related tasks
`mixed`	Epic → Feature + Task	Transitional epics; avoid as a permanent structure

Output:

✅ Epic Created: EPIC-001

📋 Epic Details
Title: User Management System
Priority: high
Business Value: 8/10
Effort Estimate: 21 story points
Status: active

👥 Stakeholders
Product Owner: pm@company.com
Tech Lead: lead@company.com

🔗 External Integration
Jira Epic: PROJ-123 (created)
Linear Initiative: PROJECT-456 (created)

📁 File Location
docs/epics/EPIC-001-user-management-system.md

Next Steps:
1. Create features: /feature-create "Feature Name" epic:EPIC-001
2. Monitor progress: /epic-status EPIC-001
3. View hierarchy: /hierarchy-view EPIC-001

`/epic-status` - View Epic Progress¶

Purpose: Monitor epic progress including feature rollup and completion metrics.

Basic Status:

/epic-status EPIC-001

With Hierarchy:

/epic-status EPIC-001 --hierarchy

With Detailed Metrics:

/epic-status EPIC-001 --detailed --include-bdd

Output:

📊 Epic Status: EPIC-001 - User Management System

🎯 Overview
Status: active
Organisation Pattern: standard (Epic → Feature → Task)
Progress: 63% complete (5/8 features completed)
Timeline: On track (3 days ahead of schedule)

📐 Completeness Score: 74/100
  Business Objective: ████████░░ 80%
  Scope:              ███████░░░ 70%
  Success Criteria:   ████████░░ 80%
  Acceptance Criteria:███████░░░ 75%
  Risk:               █████░░░░░ 50%
  Constraints:        ██████░░░░ 60%
  Dependencies:       ████████░░ 80%
  Stakeholders:       ████████░░ 85%
  Organisation:       ████████░░ 80%

🔧 Features Progress
✅ FEAT-001: User Authentication (100% - 5/5 requirements)
✅ FEAT-002: Password Reset (100% - 3/3 requirements)
🔄 FEAT-003: Role Management (75% - 3/4 requirements)
⏳ FEAT-004: Admin Dashboard (0% - 0/6 requirements)

📋 Requirements Summary
Total: 18 requirements
Completed: 11 (61%)
In Progress: 3 (17%)
Not Started: 4 (22%)

🧪 BDD Scenarios
Total: 25 scenarios
Linked to Features: 20
Ready for Testing: 18

🔗 External Tool Status
Jira Epic PROJ-123: In Progress (synced 2 hours ago)
Linear Initiative PROJECT-456: Active (synced 1 hour ago)

🚀 Next Actions
1. Complete FEAT-003 remaining requirements
2. Start FEAT-004 requirements gathering
3. Review BDD scenarios for FEAT-003
4. Improve completeness: run /epic-refine EPIC-001 --focus risks

`/epic-sync` - Sync with PM Tools¶

Purpose: Bidirectional sync of epic data with external project management tools.

Bidirectional Sync:

/epic-sync EPIC-001

Force Push Local Changes:

/epic-sync EPIC-001 --force-push

Pull Remote Changes:

/epic-sync EPIC-001 --pull-first

Sync to Specific Tool:

/epic-sync EPIC-001 --jira-only
/epic-sync EPIC-001 --linear-only

Output:

🔄 Syncing EPIC-001 with External Tools

📤 Pushing to Jira (PROJ-123)
✅ Updated epic status: In Progress
✅ Updated progress: 63%
✅ Synced 4 features
✅ Updated stakeholder assignments

📤 Pushing to Linear (PROJECT-456)
✅ Updated initiative status: Active
✅ Updated completion: 63%
✅ Synced feature links

✅ Sync Complete
Last Sync: 2025-11-03T14:30:00Z
Next Sync: 2025-11-03T15:30:00Z (auto)

`/epic-refine` - Interactively Refine Epic¶

Purpose: Iteratively improve an existing epic through completeness scoring, targeted questions, and change summaries.

Basic Usage:

/epic-refine EPIC-001

With Focus Flag:

/epic-refine EPIC-001 --focus scope
/epic-refine EPIC-001 --focus risks
/epic-refine EPIC-001 --focus criteria

Quick Mode (AI-suggested improvements applied automatically):

/epic-refine EPIC-001 --quick

Options:

Flag	Description
`--focus <category>`	Restrict refinement to a single category: `scope`, `criteria`, `acceptance`, `dependencies`, `risks`, `constraints`, or `organisation`
`--quick`	Skip interactive prompts and apply AI-suggested improvements automatically

Three-Phase Flow:

Current State Display — Loads the epic, calculates a 9-dimension completeness score, and displays the assessment with visual indicators.
Targeted Questions — Presents questions one at a time starting from the weakest categories, with options to skip or finish early.
Change Summary and Commit — Displays a summary of proposed changes, offers apply options (Yes / No / Edit), updates the markdown file, and appends a refinement_history entry to the frontmatter.

Completeness Dimensions:

Dimension	Weight
Business Objective	15%
Scope	15%
Success Criteria	20%
Acceptance Criteria	15%
Risk	10%
Constraints	10%
Dependencies	5%
Stakeholders	5%
Organisation	5%

Organisation Pattern Awareness:

The command detects organisation patterns and provides targeted suggestions:

Large direct-pattern epics (8+ tasks without features) — suggests grouping tasks into features
Single-feature epics — suggests flattening to simplify hierarchy
Mixed patterns — suggests consolidation for consistency

Example Output:

📐 Epic Completeness: EPIC-001 - User Management System
Overall Score: 74/100

Dimensions:
  Business Objective  ████████░░  80%  ✅
  Success Criteria    ████████░░  80%  ✅
  Acceptance Criteria ███████░░░  75%  ✅
  Scope               ███████░░░  70%  ⚠️
  Dependencies        ████████░░  80%  ✅
  Constraints         ██████░░░░  60%  ⚠️
  Risk                █████░░░░░  50%  ❌
  Stakeholders        ████████░░  85%  ✅
  Organisation        ████████░░  80%  ✅

Weakest category: Risk (50%) — starting there.

Q1: What are the main risks for this epic?
> ...

Feature Management Commands¶

`/feature-create` - Create Feature with Epic Linkage¶

Purpose: Create a feature specification linked to an epic with requirements and BDD.

Basic Usage:

/feature-create "User Authentication" epic:EPIC-001

With Requirements:

/feature-create "User Authentication" \
  epic:EPIC-001 \
  requirements:[REQ-001,REQ-002,REQ-003] \
  priority:high

With Full Specification:

/feature-create "User Authentication" \
  epic:EPIC-001 \
  requirements:[REQ-001,REQ-002,REQ-003] \
  bdd:[BDD-001] \
  export:jira \
  priority:high

Output:

✅ Feature Created: FEAT-001

📋 Feature Details
Title: User Authentication
Epic: EPIC-001 (User Management System)
Priority: high
Status: active

📑 Linked Specifications
Requirements: REQ-001, REQ-002, REQ-003
BDD Scenarios: BDD-001 (8 scenarios)

🔄 PM Tool Integration
Jira Story: PROJ-124 (created)
- User Story: From feature description
- Acceptance Criteria: From BDD scenarios
- Linked to Epic: PROJ-123

📁 File Location
docs/features/FEAT-001-user-authentication.md

Next Steps:
1. Review generated feature specification
2. Generate task specs: /feature-generate-tasks FEAT-001
3. Export to additional tools: /feature-sync FEAT-001 --linear

`/feature-status` - View Feature Progress¶

Purpose: Monitor feature progress including requirements and BDD scenario completion.

Basic Status:

/feature-status FEAT-001

With Requirements Breakdown:

/feature-status FEAT-001 --breakdown

With BDD Coverage:

/feature-status FEAT-001 --bdd-coverage

Output:

📋 Feature Status: FEAT-001 - User Authentication

🎯 Feature Details
Epic: EPIC-001 - User Management System
Status: in_progress
Progress: 75% complete

📋 Requirements Progress
✅ REQ-001: Password Encryption [Ubiquitous] (complete)
✅ REQ-002: Successful Login [Event-Driven] (complete)
🔄 REQ-003: Session Management [State-Driven] (in progress)
⏳ REQ-004: Account Lockout [Unwanted Behavior] (not started)

🧪 BDD Scenario Coverage
Total Scenarios: 8
✅ Implemented: 6 (75%)
🔄 In Progress: 1 (13%)
⏳ Not Started: 1 (12%)

Scenarios by Type:
- Happy Path: 4/4 complete
- Error Handling: 1/2 complete
- Security: 1/1 complete
- Performance: 0/1 complete

🔗 Traceability
Epic → Feature → Requirements → BDD: Complete
External Links: Jira PROJ-124, Linear ISS-456

⏭️ Next Steps
1. Complete REQ-003 specification
2. Start REQ-004 implementation planning
3. Implement remaining BDD scenario

`/feature-refine` - Interactively Refine Feature¶

Purpose: Iteratively improve an existing feature specification with focus on acceptance criteria specificity, requirements traceability, and BDD scenario coverage.

Basic Usage:

/feature-refine FEAT-001

With Focus Flag:

/feature-refine FEAT-001 --focus acceptance
/feature-refine FEAT-001 --focus bdd
/feature-refine FEAT-001 --focus traceability

Quick Mode (AI-suggested improvements applied automatically):

/feature-refine FEAT-001 --quick

Options:

Flag	Description
`--focus <category>`	Restrict refinement to a single category: `acceptance`, `traceability`, `bdd`, `technical`, `dependencies`, or `scope`
`--quick`	Skip interactive prompts and apply AI-suggested improvements automatically

Three-Phase Flow:

Current State Display — Loads the feature, parses content, calculates a 7-dimension completeness score, and shows linked epic context.
Targeted Questions — Presents feature-specific questions one at a time from the weakest categories first.
Change Summary and Commit — Displays proposed changes, updates the markdown file, and appends a refinement_history entry.

Completeness Dimensions:

Dimension	Weight
Scope Within Epic	10%
Acceptance Criteria	25%
Requirements Traceability	20%
BDD Coverage	15%
Technical Considerations	15%
Dependencies	10%
Test Strategy	5%

Cross-Command Integration:

Suggests /formalize-ears when linked EARS requirements are missing
Suggests /generate-bdd when BDD scenario coverage is low
Displays parent epic completeness score for context

Example Output:

📐 Feature Completeness: FEAT-001 - User Authentication
Overall Score: 68/100
Parent Epic: EPIC-001 (74/100)

Dimensions:
  Acceptance Criteria      █████░░░░░  55%  ❌
  Requirements Traceability████████░░  80%  ✅
  BDD Coverage             ███████░░░  70%  ⚠️
  Technical Considerations ████████░░  80%  ✅
  Scope Within Epic        █████████░  90%  ✅
  Dependencies             ███████░░░  70%  ⚠️
  Test Strategy            ██████░░░░  60%  ⚠️

Weakest category: Acceptance Criteria (55%) — starting there.

Q1: Can you provide specific pass/fail criteria for the login flow?
> ...

💡 Tip: BDD coverage is low — consider running /generate-bdd FEAT-001 after refining.

`/feature-sync` - Sync with PM Tools¶

Purpose: Sync feature and requirements with external project management tools.

Basic Sync:

/feature-sync FEAT-001

With Progress Rollup:

/feature-sync FEAT-001 --rollup-progress

To Specific Tool:

/feature-sync FEAT-001 --jira
/feature-sync FEAT-001 --linear
/feature-sync FEAT-001 --github

Output:

🔄 Syncing FEAT-001 with PM Tools

📤 Exporting to Jira
✅ Updated story: PROJ-124
✅ Status: In Progress
✅ Progress: 75%
✅ Updated acceptance criteria from BDD-001
✅ Linked 4 requirements as subtasks

📤 Exporting to Linear
✅ Updated issue: ISS-456
✅ Status: In Progress
✅ Progress: 75%

📈 Rolling up to Epic
✅ Updated EPIC-001 progress
✅ Recalculated epic completion: 58% → 63%

✅ Sync Complete

`/feature-generate-tasks` - Generate Task Specifications¶

Purpose: Auto-generate task specifications from feature requirements and BDD scenarios.

Basic Generation:

/feature-generate-tasks FEAT-001

With Parameters:

/feature-generate-tasks FEAT-001 \
  --max-tasks=8 \
  --include-tests \
  --epic-context

Interactive Mode:

/feature-generate-tasks FEAT-001 --interactive

Output:

✅ Task Specifications Generated

Generated 5 tasks from FEAT-001:

📋 TASK-001: Implement login endpoint
- Requirements: REQ-002
- BDD Scenarios: BDD-001 (scenarios 1-3)
- Estimated Effort: 3 story points

📋 TASK-002: Create user registration
- Requirements: REQ-006, REQ-007
- BDD Scenarios: BDD-001 (scenarios 4-5)
- Estimated Effort: 5 story points

📋 TASK-003: Add session management
- Requirements: REQ-003
- BDD Scenarios: BDD-001 (scenario 6)
- Estimated Effort: 3 story points

📋 TASK-004: Build login UI components
- Requirements: REQ-002
- BDD Scenarios: BDD-001 (scenarios 1-2)
- Estimated Effort: 2 story points

📋 TASK-005: Integration tests
- Requirements: All
- BDD Scenarios: BDD-001 (all)
- Estimated Effort: 2 story points

Total Effort: 15 story points

📁 Files Created
tasks/backlog/TASK-001.md through TASK-005.md

Next Steps:
1. Review generated task specifications
2. For task execution: Install guardkit
3. See Integration Guide for workflow

Hierarchy Commands¶

`/hierarchy-view` - View Project Hierarchy¶

Purpose: Visualize complete project structure showing epics, features, requirements, and BDD.

Overview Mode:

/hierarchy-view

For Specific Epic:

/hierarchy-view EPIC-001

Detailed Mode:

/hierarchy-view EPIC-001 --mode=detailed

With BDD:

/hierarchy-view EPIC-001 --include-bdd

Filter by Organisation Pattern:

/hierarchy-view --pattern standard
/hierarchy-view --pattern direct
/hierarchy-view --pattern mixed

Filter by Graphiti Sync Status:

/hierarchy-view --graphiti-status synced
/hierarchy-view --graphiti-status pending
/hierarchy-view --graphiti-status unsynced

Output:

📊 Project Hierarchy - User Management System

├── 🎯 EPIC-001: User Management System (63% complete) [pattern: standard]
│   │
│   ├── 🔧 FEAT-001: User Authentication (100% complete)
│   │   ├── 📋 REQ-001: Password Encryption [Ubiquitous] ✅
│   │   ├── 📋 REQ-002: Successful Login [Event-Driven] ✅
│   │   ├── 📋 REQ-003: Session Management [State-Driven] ✅
│   │   ├── 📋 REQ-004: Account Lockout [Unwanted Behavior] ✅
│   │   ├── 📋 REQ-005: Remember Me [Optional Feature] ✅
│   │   └── 🧪 BDD-001: User Authentication (8 scenarios) ✅
│   │
│   ├── 🔧 FEAT-002: Password Reset (100% complete)
│   │   ├── 📋 REQ-006: Reset Request [Event-Driven] ✅
│   │   ├── 📋 REQ-007: Email Validation [Ubiquitous] ✅
│   │   ├── 📋 REQ-008: Token Expiry [Unwanted Behavior] ✅
│   │   └── 🧪 BDD-002: Password Reset (5 scenarios) ✅
│   │
│   ├── 🔧 FEAT-003: Role Management (75% complete)
│   │   ├── 📋 REQ-009: Role Assignment [Event-Driven] ✅
│   │   ├── 📋 REQ-010: Permission Check [State-Driven] ✅
│   │   ├── 📋 REQ-011: Role Hierarchy [Ubiquitous] 🔄
│   │   ├── 📋 REQ-012: Invalid Role [Unwanted Behavior] ⏳
│   │   └── 🧪 BDD-003: Role Management (6 scenarios) 🔄
│   │
│   └── 🔧 FEAT-004: Admin Dashboard (0% complete)
│       ├── 📋 REQ-013: Dashboard Layout [Ubiquitous] ⏳
│       ├── 📋 REQ-014: User List View [State-Driven] ⏳
│       ├── 📋 REQ-015: User Actions [Event-Driven] ⏳
│       ├── 📋 REQ-016: Audit Log [Ubiquitous] ⏳
│       ├── 📋 REQ-017: Access Control [State-Driven] ⏳
│       ├── 📋 REQ-018: Error Display [Unwanted Behavior] ⏳
│       └── 🧪 BDD-004: Admin Dashboard (planning)

🎯 Summary
Epics: 1 active
Features: 4 (2 completed, 1 in progress, 1 not started)
Requirements: 18 total (11 complete, 3 in progress, 4 not started)
BDD Scenarios: 25 total (20 complete, 3 in progress, 2 planned)
Overall Progress: 63% complete

📈 Progress Trend
Last 7 days: +15% completion
Velocity: 2.1 requirements/day
Projected Completion: 5 days

🔗 External Links
Jira Epic: PROJ-123
Linear Initiative: PROJECT-456

Sync Commands¶

`/requirekit-sync` - Sync to Graphiti Knowledge Graph¶

Purpose: Re-read markdown files and push the current state to Graphiti. Markdown is the authoritative source of truth — this command rebuilds the Graphiti knowledge graph from local files.

Basic Usage:

/requirekit-sync EPIC-001

Sync a Feature:

/requirekit-sync FEAT-002

Sync Everything:

/requirekit-sync --all

Preview Without Writing:

/requirekit-sync --dry-run
/requirekit-sync EPIC-001 --dry-run

Verbose Output:

/requirekit-sync --all --verbose

Options:

Flag	Description
`--all`	Sync all epics and features found in `docs/epics/` and `docs/features/`
`--dry-run`	Preview what would be synced without writing to Graphiti
`--verbose`	Show detailed sync output for each entity

How It Works:

Checks that Graphiti is enabled in configuration
Scans docs/epics/ and docs/features/ for markdown files
Parses frontmatter and content from each file
Constructs episode objects following the epic/feature schema
Upserts episodes to Graphiti using the configured group ID
Displays a summary with sync results

Markdown-Authoritative Design:

One-way sync from markdown to Graphiti (markdown always wins)
No conflict detection or bidirectional merge
Graphiti serves as a queryable index rebuilt from markdown

When to Use:

Scenario	Command
Rebuild Graphiti after data loss	`/requirekit-sync --all`
Populate a fresh Graphiti instance	`/requirekit-sync --all`
Manual sync when auto-sync is disabled	`/requirekit-sync EPIC-001`
Verify what Graphiti would contain	`/requirekit-sync --all --dry-run`

Error Handling:

Graphiti not configured — Shows a helpful setup message
Connection failure — Shows error with retry suggestion
Partial failure — Continues with valid files, reports failures at end
Invalid markdown — Skips with warning, continues with valid files

Relationship to Other Commands:

The following commands auto-sync to Graphiti when configured:

/epic-create — auto-syncs if sync_on_create: true
/feature-create — auto-syncs if sync_on_create: true
/epic-refine — auto-syncs if sync_on_refine: true
/feature-refine — auto-syncs if sync_on_refine: true

Use /requirekit-sync for manual or full sync operations.

Output:

🔄 RequireKit Sync

Scanning docs/epics/ ... 3 files found
Scanning docs/features/ ... 8 files found

Syncing to Graphiti:
  ✅ EPIC-001: User Management System
  ✅ EPIC-002: E-Commerce Platform
  ✅ EPIC-003: Reporting System
  ✅ FEAT-001: User Authentication
  ✅ FEAT-002: Password Reset
  ✅ FEAT-003: Role Management
  ⚠️  FEAT-004: Admin Dashboard — skipped (invalid frontmatter)
  ✅ FEAT-005: Shopping Cart
  ✅ FEAT-006: Checkout Process
  ✅ FEAT-007: Product Catalog
  ✅ FEAT-008: Sales Reports

Sync Complete: 10 synced, 1 skipped, 0 failed

Export and Integration Commands¶

Export to Jira¶

# Export epic
/epic-sync EPIC-001 --jira

# Export feature
/feature-sync FEAT-001 --jira

# Export with force
/feature-sync FEAT-001 --jira --force-push

Creates in Jira: - Epic with business value and timeline - User Stories from features - Acceptance criteria from BDD scenarios - Requirements as subtasks - Full traceability links

Export to Linear¶

# Export epic
/epic-sync EPIC-001 --linear

# Export feature
/feature-sync FEAT-001 --linear

Creates in Linear: - Initiative from epic - Issues from features - Requirements context - BDD acceptance criteria - Traceability metadata

Export to GitHub Projects¶

# Export feature
/feature-sync FEAT-001 --github

# Creates GitHub issue with:
# - Feature description
# - Requirements checklist
# - BDD scenarios
# - Labels from tags

Export to Azure DevOps¶

# Export epic
/epic-sync EPIC-001 --azure

# Export feature
/feature-sync FEAT-001 --azure

Complete Workflow Examples¶

Example 1: New Feature from Scratch¶

# Step 1: Gather requirements
/gather-requirements shopping-cart
# Interactive Q&A captures complete requirements

# Step 2: Formalize to EARS
/formalize-ears
# Output: docs/requirements/REQ-020.md through REQ-028.md

# Step 3: Create epic
/epic-create "E-Commerce Platform"
# Output: docs/epics/EPIC-002.md

# Step 4: Create feature
/feature-create "Shopping Cart" \
  epic:EPIC-002 \
  requirements:[REQ-020,REQ-021,REQ-022] \
  priority:high
# Output: docs/features/FEAT-004.md

# Step 5: Generate BDD scenarios
/generate-bdd FEAT-004
# Output: docs/bdd/BDD-004-shopping-cart.feature

# Step 6: View complete hierarchy
/hierarchy-view EPIC-002

# Step 7: Export to Jira
/feature-sync FEAT-004 --jira

# Step 8: Generate task specifications (optional)
/feature-generate-tasks FEAT-004
# Output: tasks/backlog/TASK-*.md

Result: Complete feature specification ready for implementation or export.

Example 2: Epic with Multiple Features¶

# Create epic
/epic-create "User Management System" \
  priority:high \
  business_value:9 \
  export:[jira,linear]
# Output: EPIC-001

# Create features
/feature-create "Login" epic:EPIC-001
/feature-create "Registration" epic:EPIC-001
/feature-create "Password Reset" epic:EPIC-001
/feature-create "User Profiles" epic:EPIC-001

# For each feature, gather and formalize
/gather-requirements login
/formalize-ears
/generate-bdd
# Link to FEAT-001

/gather-requirements registration
/formalize-ears
/generate-bdd
# Link to FEAT-002

# Continue for remaining features...

# View complete epic
/hierarchy-view EPIC-001

# Export epic with all features
/epic-sync EPIC-001 --jira

Example 3: Requirements Review and Iteration¶

# Step 1: Draft initial requirements
/gather-requirements reporting-system
# Output: docs/requirements/draft/reporting-system.md

# Step 2: Formalize for review
/formalize-ears docs/requirements/draft/reporting-system.md
# Output: REQ-030 through REQ-040

# Step 3: Share with stakeholders
# Team reviews docs/requirements/REQ-*.md files

# Step 4: Iterate based on feedback
# Edit requirement files to incorporate feedback

# Step 5: Re-validate
/formalize-ears --validate docs/requirements/REQ-030.md

# Step 6: Generate BDD for validation
/generate-bdd --feature reporting-system
# Output: docs/bdd/BDD-005-reporting.feature

# Step 7: Review BDD with stakeholders
# BDD scenarios serve as acceptance criteria

# Step 8: Finalize and organize
/epic-create "Reporting System"
/feature-create "Sales Reports" \
  epic:EPIC-003 \
  requirements:[REQ-030,REQ-031,REQ-032]
/feature-create "Analytics Dashboard" \
  epic:EPIC-003 \
  requirements:[REQ-033,REQ-034]

# Step 9: Export to PM tools
/epic-sync EPIC-003 --jira --linear

Example 4: Adding Requirements to Existing Code¶

# You have existing code, need to add requirements retroactively

# Step 1: Document what exists
/gather-requirements existing-payment-system
# Describe current functionality

# Step 2: Formalize
/formalize-ears
# Output: REQ-050 through REQ-058

# Step 3: Create structure
/epic-create "Payment Processing"
/feature-create "Credit Card Payments" \
  epic:EPIC-004 \
  requirements:[REQ-050,REQ-051,REQ-052]

# Step 4: Generate BDD for regression testing
/generate-bdd FEAT-010

# Step 5: Link to existing code
# Edit feature file to add implementation references

# Step 6: Export for tracking
/feature-sync FEAT-010 --jira

Use the refinement commands to progressively improve epics and features after their initial creation.

# Step 1: Create the epic (using direct pattern for a small focused scope)
/epic-create "Config Refactor" --pattern direct
# Output: EPIC-005

# Step 2: Check initial completeness
/epic-status EPIC-005
# Completeness score shows weak areas (e.g. risks, constraints)

# Step 3: Refine the epic — start with weakest dimensions
/epic-refine EPIC-005
# Three-phase flow: score → targeted questions → apply changes
# Repeat until score is satisfactory (e.g. 80+)

# Step 4: Focus on a specific dimension if needed
/epic-refine EPIC-005 --focus risks
/epic-refine EPIC-005 --focus constraints

# Step 5: Create features and gather requirements
/feature-create "Environment Variable Support" epic:EPIC-005
/gather-requirements environment-variables
/formalize-ears
# Output: REQ-060 through REQ-064

# Step 6: Check feature completeness
/feature-status FEAT-010
# Completeness score highlights missing acceptance criteria and BDD coverage

# Step 7: Refine the feature
/feature-refine FEAT-010
# Suggestions: acceptance criteria need specificity, BDD coverage is low

# Step 8: Generate BDD based on refinement output
/generate-bdd FEAT-010
# Output: docs/bdd/BDD-010-environment-variable-support.feature

# Step 9: Final refinement pass for BDD traceability
/feature-refine FEAT-010 --focus bdd
# Confirms scenarios linked and traceability complete

# Step 10: Sync to Graphiti for knowledge graph queryability
/requirekit-sync EPIC-005

Result: A fully refined epic and feature with high completeness scores, clear acceptance criteria, BDD scenarios, and Graphiti knowledge graph updated.

Task Execution (Optional Integration)¶

For task execution workflow, install guardkit.

See Integration Guide for: - Installing guardkit alongside require-kit - Using /task-work for implementation - Complete requirements-to-implementation traceability - TDD workflow with quality gates

Tips and Best Practices¶

Requirements Gathering¶

Be Specific: Use concrete numbers ("1 second", "1000 users") not vague terms ("fast", "many")
Include Error Cases: Don't forget what happens when things go wrong
Ask "Why": Understand the problem before prescribing solutions
Capture Context: Document assumptions and constraints

EARS Formalization¶

One Behavior Per Requirement: Keep requirements atomic and focused
Choose Right Pattern: Match the requirement type to the EARS pattern
Measurable Criteria: Include specific, testable thresholds
Avoid Ambiguity: Use clear, unambiguous language

BDD Scenarios¶

User Perspective: Write from the user's point of view ("I", "user")
Independent Scenarios: Each should run standalone
Concrete Examples: Use specific data, not abstract variables
Complete Coverage: Include happy paths, error cases, edge cases

Project Organization¶

Meaningful Epics: Group related features by business capability
Focused Features: One feature = one user-facing capability
Clear Hierarchy: Maintain Epic → Feature → Requirement → BDD links
Regular Sync: Keep PM tools synchronized

Additional Resources¶

Documentation¶

Getting Started - Quick start guide
User Guide - Comprehensive feature documentation
Integration Guide - Using with guardkit
README - Overview and quick reference

Support¶

GitHub Issues: require-kit issues
Examples: See docs/requirements/, docs/bdd/, docs/epics/, docs/features/

Version: 2.0.0 | Last Updated: 2026-02-20 | require-kit

require-kit Command Usage Guide¶

Table of Contents¶

Quick Command Reference¶

Requirements Commands¶

Epic Management Commands¶

Feature Management Commands¶

Hierarchy Commands¶

Sync Commands¶

Requirements Management Commands¶

/gather-requirements - Interactive Requirements Gathering¶

/formalize-ears - Convert to EARS Notation¶

/generate-bdd - Create BDD/Gherkin Scenarios¶

Epic Management Commands¶

/epic-create - Create Strategic Epic¶

/epic-status - View Epic Progress¶

/epic-sync - Sync with PM Tools¶

/epic-refine - Interactively Refine Epic¶

Feature Management Commands¶

/feature-create - Create Feature with Epic Linkage¶

/feature-status - View Feature Progress¶

/feature-refine - Interactively Refine Feature¶

/feature-sync - Sync with PM Tools¶

/feature-generate-tasks - Generate Task Specifications¶

Hierarchy Commands¶

/hierarchy-view - View Project Hierarchy¶

Sync Commands¶

/requirekit-sync - Sync to Graphiti Knowledge Graph¶

Export and Integration Commands¶

Export to Jira¶

Export to Linear¶

Export to GitHub Projects¶

Export to Azure DevOps¶

Complete Workflow Examples¶

Example 1: New Feature from Scratch¶

Example 2: Epic with Multiple Features¶

Example 3: Requirements Review and Iteration¶

Example 4: Adding Requirements to Existing Code¶

Example 5: Iterative Refinement Workflow¶

Task Execution (Optional Integration)¶

Tips and Best Practices¶

Requirements Gathering¶

EARS Formalization¶

BDD Scenarios¶

Project Organization¶

Additional Resources¶

Documentation¶

Support¶

`/gather-requirements` - Interactive Requirements Gathering¶

`/formalize-ears` - Convert to EARS Notation¶

`/generate-bdd` - Create BDD/Gherkin Scenarios¶

`/epic-create` - Create Strategic Epic¶

`/epic-status` - View Epic Progress¶

`/epic-sync` - Sync with PM Tools¶

`/epic-refine` - Interactively Refine Epic¶

`/feature-create` - Create Feature with Epic Linkage¶

`/feature-status` - View Feature Progress¶

`/feature-refine` - Interactively Refine Feature¶

`/feature-sync` - Sync with PM Tools¶

`/feature-generate-tasks` - Generate Task Specifications¶

`/hierarchy-view` - View Project Hierarchy¶

`/requirekit-sync` - Sync to Graphiti Knowledge Graph¶