Implement a feature from a GitHub issue with intelligent planning and validation
Implements GitHub issue features with intelligent planning, validation, and user approval.
/plugin marketplace add L-Sypniewski/claude-code-toolkit/plugin install development-workflow@claude-code-toolkit<issue-number>Comprehensive workflow for implementing features from GitHub issues. Coordinates requirement analysis, intelligent planning, validation, and implementation with full user visibility and control.
/feature-from-issue 123
Where 123 is the GitHub issue number in the current repository.
Extract Repository Information
git remote get-url origin
Parse owner and repository name from the remote URL.
Delegate to feature-issue-analyzer Agent
Use the Task tool to invoke feature-issue-analyzer with:
The analyzer will:
Create TodoWrite for Progress Tracking Initialize todo list with workflow phases:
Calculate Complexity Score (0-8 points)
Analyze the requirements from Phase 1 and score across 4 dimensions:
File Scope (0-2 points):
Pattern Introduction (0-2 points):
Integration Complexity (0-2 points):
Breaking Changes (0-2 points):
Display to User:
Complexity Assessment:
- File Scope: X/2
- Pattern Introduction: X/2
- Integration Complexity: X/2
- Breaking Changes: X/2
- TOTAL: X/8
Architecture Advisor: [Will be involved | Not needed]
Update TodoWrite
Delegate to Planning Agents
Always invoke senior-engineer:
Use Task tool to invoke senior-engineer with prompt:
Create an implementation plan for this feature based on the following requirements:
[Include full requirements from Phase 1]
Complexity Score: X/8
Please provide:
1. High-level implementation strategy
2. Specific files to modify/create with paths
3. Implementation steps broken into logical phases
4. Recommended implementation agent
5. Validation criteria (specific, measurable)
Focus on architectural approach and strategy, not detailed code.
Conditionally invoke technical-architecture-advisor (if complexity ≥ 5):
Use Task tool to invoke technical-architecture-advisor with prompt:
Review this feature and provide architectural guidance:
[Include full requirements from Phase 1]
Complexity Score: X/8
Please evaluate:
1. Architectural approach and alternatives
2. Integration with existing systems
3. Potential risks and mitigations
4. Best practices and patterns to follow
5. What could go wrong and how to prevent it
Provide complete architectural guidance for the implementation.
The architecture advisor provides guidance BEFORE implementation begins (consultation pattern, no callbacks during implementation).
Update TodoWrite
Generate Plan File
Create file: plans/feature-[sanitized-title]-[timestamp].md
Where:
[sanitized-title] = Issue title, lowercase, spaces to hyphens, special chars removed[timestamp] = YYYYMMDD formatPlan Structure:
# Feature: [Issue Title]
**Status**: Planning
**Source**: GitHub Issue #$ARGUMENTS
**Complexity Score**: X/8 (Architecture Advisor: Yes/No)
**Recommended Agent**: [from senior-engineer response]
**Created**: [ISO timestamp]
**Last Updated**: [ISO timestamp]
## Requirements Analysis
[Full output from feature-issue-analyzer, including all sections:
FEATURE, EXAMPLES, DOCUMENTATION, OTHER CONSIDERATIONS]
## Implementation Plan
### Architecture Recommendations
[If architecture advisor was involved, include their full guidance]
[If not involved, note: "Not required (complexity < 5)"]
### Implementation Strategy
[High-level approach from senior-engineer]
### Files to Modify/Create
[List from senior-engineer with checkboxes:]
- [ ] `path/to/file1.ts` - Description of changes
- [ ] `path/to/file2.ts` - Description of changes
### Implementation Steps
[Phases from senior-engineer with checkboxes:]
- [ ] Phase 1: Foundation
- [ ] Step 1.1: Description
- [ ] Step 1.2: Description
- [ ] Phase 2: Enhancement
- [ ] Step 2.1: Description
- [ ] Phase 3: Integration & Validation
- [ ] Step 3.1: Description
### Validation Criteria
[Specific, testable criteria from senior-engineer:]
- [ ] Criterion 1: Measurable requirement
- [ ] Criterion 2: Measurable requirement
## Validation Results
[Will be filled by feature-plan-validator]
## Progress Tracking
**Current Phase**: Planning
### Completed Tasks
- [x] Requirements analysis completed by feature-issue-analyzer
- [x] Complexity assessment completed
- [x] Planning completed by senior-engineer
- [ ] Validation in progress...
### Implementation Notes
[Will be filled during implementation]
### Changes from Original Plan
[Will be documented as they occur]
## Metadata
**Plan File**: plans/feature-[name]-[timestamp].md
**Assigned Agent**: [To be confirmed after validation]
**Related Issue**: #$ARGUMENTS
**Related PR**: [Will be added when created]
Delegate to feature-plan-validator Agent
Use Task tool to invoke feature-plan-validator with:
The validator will return a validation report with:
Update Plan File with Validation Results
Append validation report to plan file in "Validation Results" section.
If validation status is NEEDS REVISION:
Update TodoWrite
Present Plan Summary to User
Plan Summary:
- Feature: [Title]
- Complexity: X/8 [with/without] architecture advisor input
- Files to modify: Y files
- Implementation phases: Z phases
- Recommended agent: [agent-name]
- Validation status: [APPROVED/APPROVED WITH NOTES]
Plan file: plans/feature-[name]-[timestamp].md
GitHub issue: #$ARGUMENTS
[If APPROVED WITH NOTES, show key recommendations]
Get User Approval
Use AskUserQuestion tool:
Question: "Ready to proceed with implementation?"
Options:
- "Yes, proceed with [recommended-agent]" (Recommended)
- "Yes, but use different agent" (specify which)
- "No, let me review the plan first"
- "No, the plan needs changes"
If user wants to review or make changes:
/resume-feature [plan-file] commandIf user chooses different agent:
Update TodoWrite
Update Plan File Status
Update plan file:
Delegate to Implementation Agent
Use Task tool to invoke the approved agent (typically senior-engineer) with:
Implement the feature according to this plan:
Plan file: plans/feature-[name]-[timestamp].md
GitHub issue: #$ARGUMENTS
CRITICAL INSTRUCTIONS:
1. Read the complete plan file first
2. Follow the implementation strategy and steps
3. Update the plan file IMMEDIATELY after EACH step (not batched)
4. Mark checkboxes as you complete them
5. Document any deviations in "Changes from Original Plan"
6. Add implementation notes as you progress
7. Run validation tests after each phase
8. Update status when complete
The plan file is the single source of truth. Keep it updated in real-time.
Run this in the background if possible (saves context for main thread to track progress).
Monitor Progress (if running in background)
Periodically:
If not running in background:
Verify Implementation Complete
Read plan file and verify:
Post-Implementation Options (Ask User)
Use AskUserQuestion:
Question: "Implementation complete! What would you like to do next?"
MultiSelect: true
Options:
- "Run code review" (invoke code-reviewer agent)
- "Create pull request" (invoke pull-request-creator agent)
- "Update GitHub issue" (post completion comment)
- "Nothing, I'll handle it manually"
Execute User Choices
Based on user selection:
code-reviewer with plan file and changed filespull-request-creator with plan file contextFinal TodoWrite Update
Final Summary to User
Feature Implementation Complete!
- Feature: [Title]
- Plan: plans/feature-[name]-[timestamp].md
- GitHub Issue: #$ARGUMENTS
- Implementation Agent: [agent-name]
- Status: [Completed/Ready for Review]
[If PR created: Pull Request: #XYZ]
[If code review done: Code review feedback in plan file]
Next steps: [Based on user choices]
This command follows the workflow-orchestration skill patterns:
GitHub API Failures:
Planning Failures:
Implementation Failures:
/resume-feature [plan-file] to continueUser Interruption:
/resume-feature [plan-file] to continue/feature-from-issue 42
This will:
All tracked in plans/feature-[name]-[date].md with real-time progress updates.