Agent-Skills.md

Agent Skills: Implementation Strategy Selection Framework (Meta-cognitive Approach)

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.

UncategorizedID: shinpr/claude-code-workflows/implementation-approach

Repository

shinpr/claude-code-workflows
shinprLicense: MIT
11828

Install this agent skill to your local

pnpm dlx add-skill https://github.com/shinpr/claude-code-workflows/tree/HEAD/skills/implementation-approach

Skill Files

Browse the full folder contents for implementation-approach.

Download Skill

Loading file tree…

skills/implementation-approach/SKILL.md

Skill Metadata

Name
implementation-approach
Description
Implementation strategy selection framework. Use when planning implementation strategy, selecting development approach, or defining verification criteria.

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:

  1. Selected strategy name and characteristics
  2. Alternatives considered and reason for rejection
  3. Risk mitigation plan (from Phase 3)
  4. Constraint compliance summary (from Phase 4)
  5. 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

  1. Verify at least one strategy combination beyond listed patterns was considered
  2. Confirm Phase 1 analysis framework is complete before selecting strategy
  3. Confirm Phase 3 risk analysis matrix is populated before implementation starts
  4. Confirm Phase 4 constraint checklist is reviewed before strategy decision
  5. Confirm Phase 6 documentation template is filled with selection rationale

Guidelines for Meta-cognitive Execution

  1. Leverage Known Patterns: Use as starting point, explore creative combinations
  2. Active WebSearch Use: Research implementation examples from similar tech stacks
  3. Apply 5 Whys: Pursue root causes to grasp essence
  4. Multi-perspective Evaluation: Comprehensively evaluate from each Phase 1-4 perspective