develop（develop 演示文稿）

Feature Development Workflow

Name

han-core:develop - Comprehensive 8-phase workflow for developing new features with quality enforcement

Synopsis

/develop [arguments]

Description

Comprehensive 8-phase workflow for developing new features with quality enforcement

Implementation

A comprehensive, structured 8-phase workflow for developing new features with quality enforcement and quality principles.

Overview

This command guides you through a systematic feature development process:

1. Discover - Understand requirements and context
2. Explore - Analyze existing codebase patterns
3. Clarify - Resolve ambiguities with user input
4. Design - Create architecture with specialized agents
5. Implement - Build with TDD and quality practices
6. Review - Multi-agent quality review with confidence scoring
7. Validate - Run all verification hooks and summarize
8. Document - Write blog post announcing the feature

Phase 1: Discover

Understand requirements and gather context

Objective: Establish clear understanding of what needs to be built and why.

1. Review the feature request:

- What is the user-facing goal? - What problem does this solve? - What are the acceptance criteria?

1. Identify impacted areas:

- Which parts of the codebase will change? - What existing features might be affected? - Are there related issues or PRs?

1. Check for similar features: # Search for similar implementations grep -r "similar_feature_name".
2. Review project documentation:

- Check CLAUDE.md, CONTRIBUTING.md for standards - Review architecture docs if available - Identify any constraints or requirements

Output: Clear problem statement and high-level approach.

Phase 2: Explore (Parallel Agent Execution)

Analyze codebase with specialized agents

Objective: Understand existing patterns and identify integration points.

Launch multiple Explore agents in PARALLEL (single message with multiple Task calls):

1. Code Explorer: Map existing features

- Find entry points and call chains - Identify data flow and transformations - Document current architecture

1. Pattern Analyzer: Identify conventions

- How are similar features implemented? - What testing patterns are used? - What naming conventions exist?

1. Dependency Mapper: Understand relationships

- What modules will be affected? - What are the integration points? - Are there circular dependencies to avoid?

Consolidation: Synthesize findings from all agents into a cohesive understanding.

Output: Comprehensive map of existing codebase patterns and integration points.

Phase 3: Clarify (Human Decision Point)

Resolve ambiguities before implementation

Objective: Get user input on unclear requirements and design choices.

Use AskUserQuestion tool to resolve:

1. Architecture decisions:

- Which approach should we take? (if multiple valid options) - What are the trade-offs? (performance vs. simplicity)

1. Scope clarifications:

- Should this include X feature? - What's the priority if time is limited?

1. Integration choices:

- Should we extend existing module or create new one? - How should this integrate with system Y?

IMPORTANT: Do not proceed with assumptions. Get explicit user answers.

Output: Clear, unambiguous requirements with user-approved approach.

Phase 4: Design (Parallel Agent Execution)

Create architecture with specialized agents

Objective: Design the implementation before coding.

Select appropriate specialized agent(s) based on feature type:

• Frontend feature? → frontend:presentation-engineer
• Backend API? → backend:api-designer
• Database changes? → databases:database-designer
• Complex system? → architecture:solution-architect

Launch agents in PARALLEL for multi-disciplinary features:

• Frontend + Backend agents simultaneously
• Include security:security-engineer for sensitive features
• Include performance:performance-engineer for high-traffic features

Agent responsibilities:

• Define module structure and file organization
• Specify interfaces and contracts
• Identify testing strategy
• Document key decisions and trade-offs

Consolidation: Review all design proposals, resolve conflicts, select final approach.

Output: Detailed implementation plan with module structure and interfaces.

Phase 5: Implement (TDD with Quality Enforcement)

Build the feature using test-driven development

Objective: Implement the designed solution with quality practices.

Apply TDD cycle (use tdd:test-driven-development skill):

For each component:
1. Write failing test (Red)
2. Implement minimum code to pass (Green)
3. Refactor for quality (Refactor)
4. Repeat

Implementation guidelines:

• ✅ Start with tests, not implementation
• ✅ Follow existing codebase patterns (from Phase 2)
• ✅ Apply SOLID principles (han-core:solid-principles skill)
• ✅ Keep it simple (KISS, YAGNI)
• ✅ Apply Boy Scout Rule - leave code better than found
• ❌ Don't over-engineer
• ❌ Don't skip tests
• ❌ Don't ignore linter/type errors

Integration:

• Integrate incrementally (don't build everything then integrate)
• Test integration points early
• Validate against acceptance criteria continuously

Output: Working implementation with comprehensive tests.

Phase 6: Review (Parallel Multi-Agent Review)

Quality review with confidence-based filtering

Objective: Identify high-confidence issues before final validation.

Launch review agents in PARALLEL (single message with multiple Task calls):

1. Code Reviewer (han-core:code-reviewer skill):

- General quality assessment - Confidence scoring ≥80% - False positive filtering

1. Security Engineer (security:security-engineer):

- Security vulnerability scan - Auth/authz pattern verification - Input validation review

1. Discipline-Specific Agent:

- Frontend: frontend:presentation-engineer (accessibility, UX) - Backend: backend:backend-architect (API design, scalability) - etc.

Review consolidation:

• Merge findings from all agents
• De-duplicate issues
• Filter for confidence ≥80%
• Organize by: Critical (≥90%) → Important (≥80%)

Present findings to user with options:

Found 3 critical and 5 important issues.

Options:
1. Fix all issues now (recommended)
2. Fix critical only, defer important
3. Review findings and decide per-issue

Output: Consolidated review with high-confidence issues only.

Phase 7: Validate & Summarize

Final verification and change summary

Objective: Ensure all quality gates pass and document the change.

Run all validation hooks:

# All validation plugins automatically run on Stop
# Verify: tests, linting, type checking, etc.

Validation checklist:

• All tests pass
• Linting passes
• Type checking passes
• No security vulnerabilities introduced
• Documentation updated
• No breaking changes (or properly coordinated)

Generate change summary:

1. What changed: Files modified and why
2. How to test: Steps to verify functionality
3. Breaking changes: None, or list with migration guide
4. Follow-up tasks: Any deferred work or tech debt

Create TODO list (using TaskCreate tool):

• Document any follow-up tasks
• Track deferred improvements
• Note any tech debt introduced

Output: Ready-to-commit feature with comprehensive documentation.

Phase 8: Document (Blog Post)

Write a blog post announcing the feature

Objective: Share the new feature with the community and explain its value.

Blog post creation:

1. Research context (optional):

- Use reddit to find related community discussions - Identify pain points the feature addresses - Understand how users talk about this problem

1. Write the blog post: Location: website/content/blog/{feature-slug}.md --- title: "{Feature Name}: {Compelling subtitle}" description: "{One-line description of what problem this solves}" date: "{YYYY-MM-DD}" author: "The Bushido Collective" tags: ["{relevant}", "{tags}"] category: "Feature" --- {Opening hook - what problem does this solve?} ## The Problem {Describe the pain point this feature addresses} ## The Solution {Explain how the feature works} ### Key Capabilities {List main features with examples} ## Getting Started {How to use the feature} ## What's Next {Future improvements or related features}
2. Writing guidelines:

- Technical but accessible - 500-1000 words for feature announcements - Include working code examples - Be honest about limitations - Make it actionable

IMPORTANT: Every significant feature should have a blog post. This is not optional.

Output: Published blog post in website/content/blog/.

Usage

Basic usage

/feature-dev

Then describe the feature you want to build.

With feature description

/feature-dev Add user authentication with JWT tokens

Best Practices

DO

• ✅ Follow all 8 phases in order
• ✅ Launch agents in parallel when independent
• ✅ Use AskUserQuestion to resolve ambiguities
• ✅ Apply confidence scoring to all reviews
• ✅ Run TDD cycle for all new code
• ✅ Pause for user input at decision points
• ✅ Write a blog post for every significant feature

DON'T

• ❌ Skip phases (especially Explore, Review, and Document)
• ❌ Start coding before design (Phases 1-4)
• ❌ Implement without tests
• ❌ Report low-confidence review findings
• ❌ Make architectural decisions without user input
• ❌ Commit without running validation hooks
• ❌ Ship features without documentation

Example Workflow

User: /feature-dev Add pagination to user list API

Phase 1: Discover
- Feature: Add pagination to GET /api/users
- Acceptance: Support page/limit query params, return total count
- Impact: Backend API, database queries

Phase 2: Explore (parallel agents)
- Found existing pagination in products API
- Pattern: Uses offset/limit with total count in response
- Testing: Integration tests verify pagination logic

Phase 3: Clarify
Q: Should we use cursor-based or offset-based pagination?
A: [User selects offset-based for consistency]

Phase 4: Design
- Agent: backend:api-designer
- Design: Extend existing UserService with pagination
- Interface: getUsersPaginated(page, limit) -> { users, total }

Phase 5: Implement
- Write test for pagination
- Implement pagination logic
- Test passes ✅

Phase 6: Review (parallel agents)
- Code reviewer: No issues (confidence N/A)
- Security engineer: No issues (confidence N/A)
- Backend architect: No issues (confidence N/A)

Phase 7: Validate
- Tests: ✅ Pass
- Linting: ✅ Pass
- Types: ✅ Pass
- Ready to commit

Phase 8: Document
- Blog post: website/content/blog/user-list-pagination.md
- Title: "Pagination: Handling Large Data Sets Gracefully"
- Tags: [api, pagination, performance]

Summary: Added pagination to user list API
Files: services/user.service.ts, tests/user.service.test.ts, website/content/blog/user-list-pagination.md
Testing: Run GET /api/users?page=1&limit=10

See Also

• /review - Run multi-agent review only
• /commit - Smart commit workflow
• /create-blog-post - Research and write blog posts
• tdd:test-driven-development - TDD skill
• han-core:code-reviewer - Review skill