plan-and-build

Convert feature requests and bug reports into test-driven implementation plans and code changes.

14|5|Updated Apr 19, 2026
One-click install
npx skills add https://github.com/jattanjie21/plan-and-build --skill plan-and-build
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan-and-build
Source: https://github.com/jattanjie21/plan-and-build/tree/main
Command: npx skills add https://github.com/jattanjie21/plan-and-build --skill plan-and-build

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill transforms vague feature requests and bug reports into structured, test-driven implementation workflows, preventing rushed coding, skipped tests, and undocumented changes.

Core Features & Use Cases

  • Structured Feature Planning: Explores the codebase, extracts existing patterns, asks focused questions, and proposes implementation approaches before coding begins.
  • Test-Driven Development Workflow: Breaks work into small features, creates failing tests first, implements changes, and tracks progress through task files.
  • Recovery and Documentation: Detects test frameworks, handles blocked debugging scenarios, supports optional Git workflows, and creates manual testing guides for completed work.

Quick Start

Ask the skill to add a new feature or fix a bug in your codebase and guide the implementation from planning through tested completion.

Frequently Asked Questions about plan-and-build

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

FAQPage Schema
How do I turn a vague feature request into tested code?

To turn a vague feature request into tested code, the skill analyzes your project, extracts existing patterns, proposes an implementation approach, and creates a test-driven development workflow with incremental tracking.

How do I plan a bug fix using test-driven development?

You can plan a bug fix using test-driven development by having the skill detect your test framework, write a failing test that reproduces the bug, implement the code changes, and track the progress in task files.

What is the best way to structure code planning for new software features?

The best way to structure code planning for new features is to explore the codebase first, ask focused questions about requirements, break work into small features, and document changes alongside manual testing guides upon completion.

Does this approach work for recovering from blocked debugging scenarios?

Yes, this approach works for recovering from blocked debugging scenarios by applying built-in failure recovery procedures, detecting existing test frameworks, and supporting optional Git workflows to isolate and resolve issues incrementally.

Can I use this for incremental implementation tracking in my codebase?

You can use this for incremental implementation tracking by decomposing tasks into small features, generating task files to monitor progress, and ensuring changes are tested and documented before completion.