expand-task

Expand a BR task into a grounded implementation plan with file paths and verification commands.

Updated Mar 6, 2026
One-click install
npx skills add https://github.com/sQVe/cape --skill expand-task
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: expand-task
Source: https://github.com/sQVe/cape/tree/main/skills/expand-task
Command: npx skills add https://github.com/sQVe/cape --skill expand-task

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Automates the transformation of vague implementation tasks into concrete, grounded expansion plans with explicit file references, line numbers, and verification commands, preventing ambiguity and guesswork.

Core Features & Use Cases

  • Investigates the current BR task and related epic/context to extract goals, hints, and success criteria.
  • Locates real, existing codebase files to reference in the expansion plan and ensures all steps map to actual artifacts.
  • Produces a step-by-step plan where each step is a TDD cycle, with explicit file paths, changes, and verification commands.
  • Provides a final, machine-checkable verification for the complete plan using cape check.
  • Advises on splitting large tasks when 10 steps would be exceeded.

Quick Start

Provide a BR task to be expanded into a grounded, step-by-step plan ready for execution.

Frequently Asked Questions about expand-task

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

FAQPage Schema
How do I turn vague implementation tasks into concrete development plans with exact file paths?

To turn vague tasks into concrete development plans, you can automate task expansion by investigating your codebase to locate real files, patterns, and references. This grounds each step in actual artifacts with explicit file paths and verification commands, preventing ambiguity.

How do I generate a TDD workflow plan that maps directly to my existing codebase?

Generating a TDD workflow plan involves expanding your task into a step-by-step sequence where each step represents a TDD cycle. The process maps changes to actual codebase files and includes explicit verification commands to ensure every step is executable and testable.

What is the best way to create an implementation plan that includes machine-checkable verification?

Creating an implementation plan with machine-checkable verification requires grounding your steps in the codebase and appending a final cape check. This provides a final, machine-checkable verification for the complete plan to ensure successful integration.

When should I split a large implementation task to avoid exceeding workflow limits?

You should split a large implementation task when expanding it would exceed 10 steps. The task expansion process advises splitting large tasks at this threshold to maintain manageable, verifiable, and focused development cycles.

Can I use codebase investigation to ensure my implementation steps map to real existing files?

Yes, you can use codebase investigation to ensure implementation steps map to real existing files. The expansion process locates actual codebase artifacts and references, following existing templates and utilities to ground the plan in your project's reality.

Why does my implementation plan lack specific line numbers and verifiable execution steps?

Implementation plans lack specific line numbers and verifiable steps when they are not grounded in the actual codebase. By investigating real files and extracting task goals, you can produce an executable plan with explicit file references and verification commands.