Approve & Implement Skills

Decisions

• Pending: Should /approve allow skipping stages (e.g., new → in-progress directly)?
• Pending: Should /reject move to a rejected/ folder or back to ideas/?
• Pending: Should /implement auto-start work or just generate a plan for review?
• Pending: How does /implement interact with complexity routing (FR-045)?

User Tasks

---

Summary

Build /approve, /reject, and /implement skills that make the feature lifecycle actionable — moving FRs between stages, updating frontmatter, logging history, and triggering implementation workflows.

Problem / Motivation

The feature lifecycle (ideas → new → planned → in-progress → done) currently requires manual file moves, manual frontmatter edits, and manual history logging. This means:

• Moving an FR from “new” to “planned” requires editing the file, changing the status field, moving it to the right folder, and adding a history entry — tedious and error-prone
• There is no standard way to reject an FR with feedback
• Starting implementation of an FR has no structured workflow — the user just starts coding
• The lifecycle looks good on paper but is not backed by actual commands that enforce it

These skills are the missing commands that make the feature lifecycle functional. Without them, the lifecycle is just a filing system, not a workflow.

Proposed Solution

Three skills that serve as the primary lifecycle commands:

/approve FR-XXX

• Moves FR to the next lifecycle stage: new → planned, or planned → in-progress
• Updates status field in frontmatter
• Moves file to the correct folder (new/ → planned/, planned/ → in-progress/)
• Adds history entry: | <date> | Approved | Moved from <old-status> to <new-status> |
• Validates prerequisites: if FR has blockers, warn before approving
• Optional: --skip flag to jump stages (e.g., new → in-progress)

/reject FR-XXX [reason]

• Marks FR as rejected with a reason
• Updates status to rejected in frontmatter
• Moves file to ideas/ (demoted) or a rejected/ folder
• Adds history entry with rejection reason
• Preserves the FR content — rejection is not deletion

/implement FR-XXX

• Reads the FR spec and prepares for implementation
• Generates an implementation plan based on the phase overview and file/feature tables
• Presents the plan for user review before starting work
• Optionally routes by complexity (integrates with FR-045)
• Updates FR status to in-progress if not already
• Adds history entry: | <date> | Implementation started | Phase X |

---

Open Questions

1. Stage Skipping

Question: Should /approve allow skipping lifecycle stages?

Option	Description
A) Allow with —skip flag	Explicit opt-in to skip stages. Default follows normal progression
B) Always sequential	Must go new → planned → in-progress, no skipping
C) Smart routing	Auto-detect if FR is ready to skip (e.g., already has detailed phases = skip planned)

Recommendation: Option A — default is sequential, but --skip allows power users to fast-track when appropriate.

Decision:

2. Rejection Destination

Question: Where should rejected FRs go?

Option	Description
A) rejected/ folder	Clear separation. Easy to review rejected items later
B) Back to ideas/	Rejected ideas can be revisited. Less folder overhead
C) Archive with rejected status	Keep in current folder, just change status. No file movement

Recommendation: Option B — most rejected FRs are “not now” rather than “never.” Moving to ideas allows revisiting without a separate rejected folder.

Decision:

3. /implement Behavior

Question: Should /implement auto-start work or present a plan first?

Option	Description
A) Plan first, implement on confirm	Generates plan, shows to user, user says “go” to start. Safe
B) Auto-start immediately	Reads spec and starts building. Fast but risky
C) Depends on complexity	Simple FRs auto-start, complex ones show plan first

Recommendation: Option A for Phase 2 — always show the plan first. Phase 3 can introduce auto-start for simple FRs via complexity routing.

Decision:

---

Phase Overview

Phase	Description	Status
Phase 1	/approve and /reject skills	—
Phase 2	/implement skill (plan + review)	—
Phase 3	/implement with complexity routing	—

---

Phase 1: /approve and /reject Skills —

Goal: Build skills that move FRs between lifecycle stages with proper frontmatter updates and history logging.

File / Feature	Details	Owner	Status
.claude/skills/approve/SKILL.md	Skill definition for /approve FR-XXX	opus	—
.claude/skills/reject/SKILL.md	Skill definition for /reject FR-XXX [reason]	opus	—
Frontmatter update	Parse and update status, updated fields in FR file	opus	—
File move	Move FR file to correct lifecycle folder	opus	—
History logging	Append row to FR history table with date, event, details	opus	—
Prerequisite check	Warn if approved FR has unmet dependencies	opus	—
Validation	Verify FR-XXX exists, is in valid state for the operation	opus	—
Edge cases	Handle: FR already in target status, FR not found, invalid status transition	opus	—

---

Phase 2: /implement Skill —

Goal: Build a skill that reads an FR, generates an implementation plan, and presents it for review.

File / Feature	Details	Owner	Status
.claude/skills/implement/SKILL.md	Skill definition for /implement FR-XXX	opus	—
FR reader	Parse FR file — extract phases, file/feature tables, prerequisites	opus	—
Plan generator	Generate implementation plan from FR spec — ordered steps, file changes, dependencies	opus	—
Plan review flow	Present plan to user, wait for approval before proceeding	mv	—
Status update	Move FR to in-progress if not already, update frontmatter	opus	—
History logging	Log implementation start with phase details	opus	—

---

Phase 3: /implement with Complexity Routing —

Goal: Integrate /implement with complexity routing (FR-045) to auto-select the right execution strategy.

File / Feature	Details	Owner	Status
Complexity scoring integration	Call FR-045 scoring when /implement is invoked	opus	—
Strategy selection	Auto-select single agent, pipeline, or team based on score	opus	—
Override flags	--team, --specialist, --phases 1,2 to force specific strategies	opus	—
Pipeline execution	Plan → Review (quality gate) → Implement flow for medium complexity	mv	—
Team execution	Multi-agent coordination for high complexity FRs	opus	—

---

Prerequisites / Gap Analysis

Requirements

Requirement	Description
REQ-1	Skill system must support arguments (FR-XXX parameter) — already works
REQ-2	Complexity routing (FR-045) — needed for Phase 3 only
REQ-3	Custom agents (FR-043) — needed for Phase 3 team execution

Current State

Component	Status	Details
Skill system	done	.claude/skills/ works, skills can accept arguments
FR lifecycle folders	done	new/, planned/, in-progress/, done/ exist
FR frontmatter	done	Standard format with status, updated, history
Complexity routing	—	FR-045 not started
Custom agents	—	FR-043 not started

Gap (What’s missing?)

Gap	Effort	Blocker?
Skill implementation for /approve and /reject	Low	No
Frontmatter parsing in skill context	Low	No — skills can read/edit files
Complexity routing (FR-045)	High	Only for Phase 3
Custom agents (FR-043)	High	Only for Phase 3

---

Test

Manual tests

Test	Expected	Actual	Last
/approve FR-XXX moves FR from new to planned	File moved, status updated, history logged	pending	-
/approve FR-XXX on planned FR moves to in-progress	File moved, status updated, history logged	pending	-
/approve FR-XXX warns about unmet prerequisites	Warning displayed with dependency list	pending	-
/reject FR-XXX "not needed" moves FR to ideas	File moved, status set to rejected, reason in history	pending	-
/approve on non-existent FR shows error	Error message with valid FR list	pending	-
/implement FR-XXX generates implementation plan	Plan displayed with phases, files, and steps	pending	-
/implement FR-XXX updates status to in-progress	Frontmatter updated, history logged	pending	-
/implement --team FR-XXX forces team strategy	Team execution dispatched regardless of score	pending	-

AI-verified tests

Scenario	Expected behavior	Verification method
…	…	…

E2E tests

Scenario	Assertion
…	…

Integration tests

Component	Coverage
…	…

Unit tests

Component	Tests	Coverage
…	…	…

---

History

Date	Event	Details
2026-03-04	Created	Key workflow skills to make the feature lifecycle actionable

---

References

• FR-028 (Feature Workflow Automation) — broader workflow automation; these skills are the core commands
• FR-031 (Workflow State Machine) — state machine defines valid transitions; these skills execute them
• FR-045 (Complexity-Based Routing) — /implement routes by complexity in Phase 3
• FR-043 (Custom Agents) — agents are execution targets for /implement team mode
• FR-040 (Stale Detection) — stale FRs may be surfaced as candidates for /reject
• Nexie (Sven Hennig) — original inspiration for approve/implement workflow commands