Skip to main content Implementation strategy selection framework with meta-cognitive approach, verification levels, and integration point definitions. Use when planning implementation strategy, selecting development approach, or defining verification criteria.
npx skills add shinpr/claude-code-workflows --skill implementation-approach claude-code code-quality productivity claude-code-plugin ai-agents skills
Implementation Strategy Selection Framework (Meta-cognitive Approach)
Meta-cognitive Strategy Selection Process
Phase 1: Comprehensive Current State Analysis
Core Question : "What does the existing implementation look like?"
Analysis Framework
Architecture Analysis: Responsibility separation, data flow, dependencies, technical debt
Implementation Quality Assessment: Code quality, test coverage, performance, security
Historical Context Understanding: Current form rationale, past decision validity, constraint changes, requirement evolution
Meta-cognitive Question List
What is the true responsibility of this implementation?
Which parts are business essence and which derive from technical constraints?
What dependencies or implicit preconditions are unclear from the code?
What benefits and constraints does the current design bring?
Phase 2: Strategy Exploration and Creation
Core Question : "When determining before → after, what implementation patterns or strategies should be referenced?"
Strategy Discovery Process
Research and Exploration: Tech stack examples (WebSearch), similar projects, OSS references, literature/blogs
Creative Thinking: Strategy combinations, constraint-based design, phase division, extension point design
Reference Strategy Patterns (Creative Combinations Encouraged)
Legacy Handling Strategies :
Strangler Pattern: Gradual migration through phased replacement
Facade Pattern: Complexity hiding through unified interface
Adapter Pattern: Bridge with existing systems
New Development Strategies :
Feature-driven Development: Vertical implementation prioritizing user value
Foundation-driven Development: Foundation-first construction prioritizing stability
Risk-driven Development: Prioritize addressing maximum risk elements
Integration/Migration Strategies :
Proxy Pattern: Transparent feature extension
Decorator Pattern: Phased enhancement of existing features
Bridge Pattern: Flexibility through abstraction
Important : The optimal solution is discovered through creative thinking according to each project's context.
Phase 3: Risk Assessment and Control Core Question : "What risks arise when applying this to existing implementation, and what's the best way to control them?"
Risk Analysis Matrix Technical Risks: System impact, data consistency, performance degradation, integration complexity
Operational Risks: Service availability, deployment downtime, process changes, rollback procedures
Project Risks: Schedule delays, learning costs, quality achievement, team coordination
Risk Control Strategies Preventive Measures: Phased migration, parallel operation verification, integration/regression tests, monitoring setup
Incident Response: Rollback procedures, log/metrics preparation, communication system, service continuation procedures
Phase 4: Constraint Compatibility Verification Core Question : "What are this project's constraints?"
Constraint Checklist Technical Constraints: Library compatibility, resource capacity, mandatory requirements, numerical targets
Temporal Constraints: Deadlines/priorities, dependencies, milestones, learning periods
Resource Constraints: Team/skills, work hours/systems, budget, external contracts
Business Constraints: Market launch timing, customer impact, regulatory compliance
Phase 5: Implementation Approach Decision Select optimal solution from basic implementation approaches (creative combinations encouraged):
Vertical Slice (Feature-driven) Characteristics : Vertical implementation across all layers by feature unit
Application Conditions : Features share fewer than 2 data models, each feature is independently deliverable, changes touch 3+ architecture layers
Verification Method : End-user value delivery at each feature completion
Horizontal Slice (Foundation-driven) Characteristics : Phased construction by architecture layer
Application Conditions : 3+ features depend on a common foundation layer, foundation changes require stability verification before consumers can proceed
Verification Method : Integrated operation verification when all foundation layers complete
Hybrid (Creative Combination) Characteristics : Flexible combination according to project characteristics
Application Conditions : Unclear requirements, need to change approach per phase, transition from prototyping to full implementation
Verification Method : Verify at appropriate L1/L2/L3 levels according to each phase's goals
Phase 6: Decision Rationale Documentation Design Doc Documentation : Record in the Design Doc's implementation approach section:
Selected strategy name and characteristics
Alternatives considered and reason for rejection
Risk mitigation plan (from Phase 3)
Constraint compliance summary (from Phase 4)
Verification level (L1/L2/L3) and integration point definition
Verification Level Definitions Priority for completion verification of each task:
L1: Functional Operation Verification - Operates as end-user feature (e.g., search executable)
L2: Test Operation Verification - New tests added and passing
L3: Build Success Verification - Code builds/runs without errors
Priority : L1 > L2 > L3 in order of verifiability importance
Integration Point Definitions Define integration points according to selected strategy:
Strangler-based : When switching between old and new systems for each feature
Feature-driven : When users can actually use the feature
Foundation-driven : When all architecture layers are ready and E2E tests pass
Hybrid : When individual goals defined for each phase are achieved
Quality Checks
Verify at least one strategy combination beyond listed patterns was considered
Confirm Phase 1 analysis framework is complete before selecting strategy
Confirm Phase 3 risk analysis matrix is populated before implementation starts
Confirm Phase 4 constraint checklist is reviewed before strategy decision
Confirm Phase 6 documentation template is filled with selection rationale
Guidelines for Meta-cognitive Execution
Leverage Known Patterns : Use as starting point, explore creative combinations
Active WebSearch Use : Research implementation examples from similar tech stacks
Apply 5 Whys : Pursue root causes to grasp essence
Multi-perspective Evaluation : Comprehensively evaluate from each Phase 1-4 perspective
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Create or update AgentSkills. Use when designing, structuring, or packaging skills with scripts, references, and assets.
Set up and use 1Password CLI (op). Use when installing the CLI, enabling desktop app integration, signing in (single or multi-account), or reading/injecting/running secrets via op.
CLI to manage emails via IMAP/SMTP. Use `himalaya` to list, read, write, reply, forward, search, and organize emails from the terminal. Supports multiple accounts and message composition with MML (MIME Meta Language).