feature-development

Feature Development

Wrong skill? Bug fix → systematic-debugging. Design comparison → debate. Pre-commit checks → pre-commit-gate. Workflow

Purpose: Orchestrate the full rigorous development lifecycle so no phase is skipped. Pattern: This skill SEQUENCES existing skills — it does not replace them. Scope: This is the DEFAULT workflow for ANY code change. Opt out ONLY if the user explicitly says to skip it.

Announce at start: "I'm using the feature-development skill to orchestrate this workflow."

When to Use

• Implementing a new feature end-to-end (design → code → test → ship)
• When the task spans multiple files and requires coordination
• Multi-step implementation that needs a structured workflow

When to Use — DEFAULT for Code Changes

• Any code change — features, bug fixes, refactors, skill edits, config changes
• This fires AUTOMATICALLY. You do not need the user to say "use the full workflow."
• If you are about to write, edit, or generate code, this skill applies.

Opt-Out Conditions

• User explicitly says "skip the workflow", "just do it", "quick fix only"
• Pure documentation-only changes (no code files touched)
• Reading/exploring code with no intent to change it

The Workflow

Phase 1: BRAINSTORM → Phase 2: FRESH PERSPECTIVE → Phase 3: DESIGN →
Phase 4: HARSH REVIEW → Phase 5: PLAN & EXECUTE → Phase 6: HARSH REVIEW →
Phase 7: SHIP

Each phase has an exit gate — you cannot proceed until the gate passes.

Phase 1: Brainstorming

Invoke: brainstorming

1. Explore the user's intent, requirements, and constraints
2. Gather codebase context — read existing code, understand patterns
3. Surface assumptions, edge cases, and scope boundaries
4. Exit gate: Clear understanding of what needs to change and why.

Phase 2: Fresh Perspective

Invoke: think-twice

1. Dispatch a sub-agent with zero prior context to review the problem
2. The sub-agent should identify gaps, blind spots, and alternative framings
3. Integrate fresh insights back into the plan
4. Exit gate: Fresh perspective reviewed, no unaddressed blind spots.

Phase 3: Design

Invoke: debate

1. Generate ≥3 genuinely distinct design options
2. Build comparison matrix (≤5 criteria)
3. Evaluate options against requirements from Phase 1
4. Select winning design with documented rationale
5. Exit gate: Design selected, trade-offs documented, edge cases addressed.

Phase 4: Harsh Review (Design)

Invoke: progressive-code-review-gate

1. Red-team the selected design via hostile sub-agent reviewer
2. Reviewer should find issues the designer is blind to
3. Fix all BLOCKER and MAJOR findings before proceeding
4. Exit gate: All BLOCKER/MAJOR findings resolved. MINOR findings tracked.

Phase 5: Plan & Execute

Invoke: plan-and-execute

1. Break the design into ordered implementation phases with success criteria
2. Enroll each phase as a TODO via todo-management / todo-crud.sh, then mirror to MCP tasks
3. Execute each phase, running tests after each
4. For each phase: implement → test → self-review via adversarial-search
5. Run output-verification after generating any artifact
6. Exit gate: All phases complete, all tests pass, no regressions.

Phase 6: Harsh Review (Implementation)

Invoke: progressive-code-review-gate

1. Red-team the FULL implementation via hostile sub-agent reviewer
2. Reviewer reads ALL changed files, runs quality gates, checks for regressions
3. Fix all BLOCKER and MAJOR findings
4. Re-review after fixes (minimum 2 review rounds total)
5. Exit gate: Two review rounds passed, all findings resolved.

Phase 7: Ship

1. Run output-verification — read back all generated files
2. Run verification-before-completion — evidence before assertions
3. Run all validation tools (harsh-review, trigger-validator, tests)
4. Commit, push, create PR, merge (with user approval at each step)
5. Exit gate: All checks pass, PR merged, synced to all remotes.

Phase Skip Prevention

You MUST NOT skip phases. "I already know the approach" → think-twice catches blind spots. "Only one design option" → debate requires ≥3. "Too small" → the 2026-03-27 incident was "just a small script."

Opt-out is user-initiated ONLY. The agent never decides to skip.

Integration Map

Phase	Skill Invoked	Purpose
Brainstorm	brainstorming	Explore intent, gather context, surface assumptions
Fresh Perspective	think-twice	Sub-agent catches blind spots
Design	debate	≥3 options, comparison, selection
Harsh Review (Design)	progressive-code-review-gate	Red-team the design
Plan & Execute	plan-and-execute + adversarial-search	Structured implementation with self-review
Harsh Review (Impl)	progressive-code-review-gate	Red-team the implementation (min 2 rounds)
Ship	output-verification, verification-before-completion	Inspect output, verify completion, merge

Incident History

2026-03-27: Agent skipped brainstorming, think-twice, and harsh review. Confabulated summary without reading output. Required 2 hostile review rounds. Every issue would have been caught by the full workflow.

Example

# Pre-flight: verify branch, tests pass, no uncommitted changes
git status --short && npm test 2>&1 | tail -5
# Post-implementation: run full test suite + lint
npm run lint && npm test

Failure Modes

Failure	Recovery
Phase skipping (most common)	Every phase has an exit gate. No phase can be skipped without user opt-out.
Rushing through brainstorming in <2 exchanges	Brainstorming should explore ≥3 approaches with real trade-offs
Skipping harsh review after implementation	Phase 6 is mandatory. Fixes from review need their own review.
Not persisting phase state via TODO	Each phase must be enrolled as a TODO before starting

Companion Skills

• brainstorming: Generating options and alternatives
• debate: Evaluating design alternatives
• plan-and-execute: Structured planning workflow
• progressive-code-review-gate: Code review enforcement
• test-driven-development: TDD workflow
• subagent-driven-development: Multi-agent development
• autonomous-chain-controller: Full workflow orchestration