execution/implement

Execute targeted tests and refactor code within defined scope boundaries.

118|10|Updated Mar 15, 2026
One-click install
npx skills add https://github.com/heyallencao/KeyStore --skill execution-implement
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: execution/implement
Source: https://github.com/heyallencao/KeyStore/tree/main/execution/implement
Command: npx skills add https://github.com/heyallencao/KeyStore --skill execution-implement

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

It automates the process of translating test scenarios and plans into functional code, ensuring consistent scope adherence and reducing manual errors during implementation.

Core Features & Use Cases

  • Test-Driven Implementation: Runs targeted test scenarios, converts failures into passing code, and refactors to improve structure.
  • Scope Discipline: Detects and prevents scope creep, recording out-of-scope discoveries for review.
  • Use Case: Developers implementing a new feature can use this Skill to reliably write code that passes all relevant tests, while ensuring scope boundaries are respected.

Quick Start

Use the implementation skill to complete the current code block after verifying the plan and tests are ready.

Frequently Asked Questions about execution/implement

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I automate code implementation while strictly following test-driven development?

Automating code implementation with test-driven development involves executing targeted test scenarios, converting failures into passing code, and refactoring within scope boundaries. This ensures development follows prescribed plans while maintaining disciplined workflows.

What is the best way to prevent scope creep during feature implementation?

Preventing scope creep during feature implementation requires detecting and recording out-of-scope discoveries for later review. Scope discipline ensures boundaries are respected by preventing out-of-scope changes during targeted test execution and code refactoring.

How do I convert failing test scenarios into functional code automatically?

Converting failing test scenarios into functional code involves running targeted tests and translating those failures into passing implementations. This test-driven approach automates code generation while ensuring consistent scope adherence and reducing manual errors.

Do I need a predefined plan before starting test-driven implementation?

Yes, you need a predefined plan and ready tests before starting test-driven implementation. The implementation skill completes the current code block after verifying the plan and tests are ready, ensuring development follows the prescribed structure.

Why does my automated refactoring keep breaking unrelated functionality?

Automated refactoring breaks unrelated functionality when scope boundaries are not properly controlled. Maintaining scope discipline and recording out-of-scope discoveries ensures refactoring stays within targeted test scenarios and prescribed plan limits.

Can I use scope control to manage out-of-scope discoveries during coding?

Yes, scope control manages out-of-scope discoveries during coding by detecting and recording them for review. This prevents scope creep while allowing developers to acknowledge unexpected findings without derailing the current implementation plan.