writing-plans

Generate implementation plans as Claude Code Tasks with file paths and verification commands.

Updated Jan 23, 2026
One-click install
npx skills add https://github.com/joshsymonds/gambit --skill writing-plans-joshsymonds
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/joshsymonds/gambit/tree/main/skills/writing-plans
Command: npx skills add https://github.com/joshsymonds/gambit --skill writing-plans-joshsymonds

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

This Skill transforms high-level requirements into detailed, actionable implementation plans, breaking down complex work into manageable, trackable tasks with clear dependencies and verification steps.

Core Features & Use Cases

  • Task Decomposition: Breaks down large features into small, self-contained subtasks.
  • Dependency Management: Explicitly defines task order and prerequisites.
  • Verification Integration: Ensures each task includes a clear command to verify its completion.
  • Use Case: When developing a new user authentication system, this skill can generate a plan with tasks for creating the database schema, building the API endpoints, implementing the frontend forms, and setting up tests, all linked in the correct order.

Quick Start

Use the writing-plans skill to create an implementation plan for adding a user profile page.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down complex software development tasks into trackable units?

Breaking down complex software development tasks involves generating actionable implementation plans with explicit file paths, dependencies, and verification commands. This process creates small, self-contained subtasks suitable for multi-session execution and structured development workflows.

How do I manage dependencies when planning multi-session feature development?

Managing dependencies in multi-session feature development requires explicitly defining task order and prerequisites within the implementation plan. This ensures each subtask executes sequentially, verifying completion through integrated commands before proceeding to dependent steps.

What is the best way to verify codebase changes during task decomposition?

Verifying codebase changes during task decomposition involves ensuring each task includes a specific verification command. The planning process checks the codebase before defining definitive steps, guaranteeing that every actionable unit has a clear, executable validation method.

Can I generate implementation plans with explicit file paths for new authentication systems?

Generating implementation plans with explicit file paths for new authentication systems is fully supported. The plan creates sequentially linked tasks for database schemas, API endpoints, frontend forms, and tests, ensuring all components are correctly ordered and verifiable.

Why should I avoid conditional logic in task descriptions for workflow automation?

Avoiding conditional logic in task descriptions for workflow automation prevents ambiguous execution paths and ensures definitive steps. The planning mechanism strictly prohibits branching conditions, guaranteeing each subtask remains self-contained, trackable, and executable across multiple sessions.

Does writing-plans support codebase verification before defining implementation steps?

Codebase verification before defining implementation steps is a core requirement of the writing-plans process. It ensures the generated plan is grounded in the actual state of the codebase, preventing inaccurate or unexecutable task definitions.