The capabilities section describes additional capabilities that you can refer to.
When you need specific examples to understand how to apply the implementation planning approach, load the relevant example file from the examples folder:
- Adding a New Export Feature: When implementing a new feature that involves both backend logic and UI components, read
examples/adding-new-export-feature.md
- Simple UI Enhancement: When implementing straightforward UI improvements without complex business logic, read
examples/simple-ui-enhancement.md
- Complex Business Logic: When implementing sophisticated algorithms or complex business rules requiring rigorous testing, read
examples/complex-business-logic.md
Only load example files when they are directly relevant to the current implementation task to minimize context size.
The rules section outlines decision criteria that determine which capabilities to apply based on the current context and user inputs.
If the user submits a requirement, apply the defining-requirement capability to clarify and structure it.
After defining the requirement, apply the adapting-tdd-approach capability to evaluate whether to adapt TDD approach based on the implementation type and complexity.
Apply the implementation-planning capability to generate a detailed implementation plan, incorporating baseline validation and step consolidation strategies.
Converted and distributed by TomeVault — claim your Tome and manage your conversions.
1---2name: feature-implementation-planner3description: Clarify and structure the requirement first, then generate an implementation plan for the requirement; Use this skill when user submits a requirement to add new functionalities. Use when this capability is needed.4---56<when-to-use-this-skill>7- User submits a requirement to add new functionalities.8</when-to-use-this-skill>910<capabilities>1112The capabilities section describes additional capabilities that you can refer to.1314<defining-requirement>15- Gather relevant information from the codebase, knowledge base, and user input to clearly define the software requirement.16- Identify and clarify any ambiguous terms or implicit assumptions to ensure proper understanding.17- Ask questions to the user to refine and narrow down the focus of the software requirement as needed.18- Present a structured summary of the requirement to the user and request confirmation or refinements.19</defining-requirement>2021<adapting-tdd-approach>22- Recognize when the full TDD cycle may be adapted or streamlined based on the implementation type:23 - **Simple features** (small UI additions, basic form fields): May consolidate test and implementation steps when logic is straightforward24 - **Pure presentational components**: Focus on rendering and prop validation tests with minimal logic testing25 - **Type-only additions** (adding new types/interfaces without behavior): Focus on type-checking validation rather than test-first approach26 - **Configuration changes** (adding constants, config options): Minimal testing may suffice if changes don't affect behavior27 - **Complex business logic**: Always follow full TDD cycle for safety and clarity28- When adapting the approach, always ensure existing tests pass before and after changes29- Document the rationale for adapting the TDD approach in the plan30</adapting-tdd-approach>3132<implementation-planning>33- **Validate Baseline**: Run existing tests, linting, and type-checking to ensure the codebase is in a clean state before implementation begins.34- Break down high-level software requirements into specific, independently testable functionalities.35- Map out dependencies between functionalities to establish an efficient implementation sequence.36- **Consolidate Steps**: Group related functionalities together when they share context or can be tested together, reducing the total step count while maintaining clarity.37- Create a detailed step-by-step implementation plan for the functionalities following the TDD approach. For each functionality, the steps should include:38 - **Write Focused Tests**: Create precise unit tests for a single functionality, task or requirement, ensuring coverage of all possible scenarios, edge cases, and invalid inputs. 39 - **Confirm Test Failure**: Execute the tests to verify they fail initially, confirming their validity before implementation begins. 40 - **Implement Minimal Code**: Write the simplest code required to pass the tests, avoiding over-engineering or adding features not directly related to the current test cases. 41 - **Verify Implementation**: Re-run the tests to confirm that the implemented code passes all test cases successfully. Debug and refine as necessary. 42 - **Refactor**: Improve the code’s structure, readability, and performance while maintaining functionality, ensuring no tests break during the process. 43 - **Validate Refactoring**: Run the tests again after refactoring to ensure the updated code still passes all test cases without introducing regressions.44 - **Clean Up Unused Code**: Remove any obsolete or redundant code that is no longer needed after implementation.45 - **Clean Up Tests**: Update or remove tests that are no longer relevant, ensuring the test suite remains accurate and effective.46 - **Verify Cleanup**: Re-run all tests to ensure that the cleanup process has not introduced any regressions or issues.47 - **Validate Linting, Formatting and Type Checking**: Run linting, formatting and type checking tools to ensure code quality and adherence to coding standards.48- Ensure the total number of steps in the plan is manageable and does not exceed 20 steps.49- Summarize the complete plan to the user. For example:50 """51 To implement the requirement of [requirement summary], the plan is as follows:52 - Step 1: Validate Baseline (run existing tests, lint, type-check)53 - Step 2: Write Focused Tests for functionality A54 - Step 3: Confirm Test Failure for functionality A55 - Step 4: Implement Minimal Code for functionality A56 - Step 5: Verify Implementation for functionality A57 - Step 6: Refactor code related to functionality A58 - Step 7: Validate Refactoring for functionality A59 - Step 8: Clean Up Unused Code for functionality A60 - Step 9: Clean Up Tests for functionality A61 - Step 10: Verify Cleanup for functionality A62 - Step 11: Validate Linting, Formatting and Type Checking for functionality A63 - Step 12: Write Focused Tests for functionality B64 - Step 13: Confirm Test Failure for functionality B65 - Step 14: Implement Minimal Code for functionality B66 - Step 15: Verify Implementation for functionality B67 - Step 16: Refactor code related to functionality B68 - Step 17: Validate Refactoring for functionality B69 - Step 18: Clean Up Unused Code for functionality B70 - Step 19: Clean Up Tests for functionality B71 - Step 20: Verify Cleanup for functionality B72 - Step 21: Validate Linting, Formatting and Type Checking for functionality B73 - ...74 I will apply **plan-executor** skill to implement the requirement step by step as outlined.75 """76</implementation-planning>777879<implementation-planning-examples>8081When you need specific examples to understand how to apply the implementation planning approach, load the relevant example file from the examples folder:8283- **Adding a New Export Feature**: When implementing a new feature that involves both backend logic and UI components, read `examples/adding-new-export-feature.md`84- **Simple UI Enhancement**: When implementing straightforward UI improvements without complex business logic, read `examples/simple-ui-enhancement.md`85- **Complex Business Logic**: When implementing sophisticated algorithms or complex business rules requiring rigorous testing, read `examples/complex-business-logic.md`8687Only load example files when they are directly relevant to the current implementation task to minimize context size.8889</implementation-planning-examples>9091</capabilities>9293<rules>9495The rules section outlines decision criteria that determine which capabilities to apply based on the current context and user inputs.9697<rule> If the user submits a requirement, apply the **defining-requirement** capability to clarify and structure it. </rule>98<rule> After defining the requirement, apply the **adapting-tdd-approach** capability to evaluate whether to adapt TDD approach based on the implementation type and complexity. </rule>99<rule> Apply the **implementation-planning** capability to generate a detailed implementation plan, incorporating baseline validation and step consolidation strategies. </rule>100</rules>101102---103> Converted and distributed by [TomeVault](https://tomevault.io/claim/sjmyuan) — claim your Tome and manage your conversions.104<!-- tomevault:4.0:skill_md:2026-04-14 -->