task-planning

Decomposes task_spec and architecture documents into an ordered sequence of development tasks.

Updated Aug 4, 2026
One-click install
npx skills add https://github.com/rombel00/game-processes --skill task-planning-rombel00
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: task-planning
Source: https://github.com/rombel00/game-processes/tree/main/plugins/delivery/skills/task-planning
Command: npx skills add https://github.com/rombel00/game-processes --skill task-planning-rombel00

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Turning an approved task specification and architecture into concrete, executable development work is error-prone: tasks get invented without traceability, acceptance criteria get lost, and developers end up re-designing architecture mid-implementation. This Skill produces a structured plan where every task traces back to the spec. ## Core Features & Use Cases - Top-down planning: First tasks create stub implementations wired into the main flow with an end-to-end test, so the whole system runs from the start; later tasks replace stubs with real logic. - Traceability coverage table: Every unit of the task_spec maps to at least one task, and acceptance criteria are explicitly bound to the tasks that prove them. - Concrete task definitions: Exact file paths, class and method names with parameters and types, plus e2e, unit, and regression test expectations — no code, no vague descriptions. - Use Case: After an architecture review passes, ask for a development plan and receive a sequenced task list with a coverage table, per-task test strategy, and open questions, ready to hand to implementation. ## Quick Start Use the task-planning skill to break down the approved task_spec and architecture into an ordered development plan with tests for each task.

Frequently Asked Questions about task-planning

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

FAQPage Schema
How do I break down a task specification into development tasks?▼

Map each unit of the task_spec to at least one task, then order tasks top-down: first create stub implementations wired into the main flow with an end-to-end test, then replace stubs with real logic one at a time. Each task lists exact files, classes, methods, and tests.

What is a top-down stub-first approach to task planning?▼

The first tasks add all new classes and methods as stubs returning placeholder values, integrate them into the main flow, and add an end-to-end test that runs start to finish. Later tasks replace stubs with real implementations, surfacing integration mismatches early.

Can I plan development tasks without an architecture document?▼

Yes. When no architecture gate exists, tasks are derived directly from the task_spec. Architectural decisions made during planning should be simple and reversible, avoiding major choices like database selection.

Should acceptance criteria requiring manual playtesting be covered by automated tests?▼

No. Criteria proven by playtesting or manual verification in a real environment are closed by a launch check, not by a plan task. A task may only ensure the observable signal exists, such as displaying the required hint.

Why is mock-only testing insufficient for external system integrations?▼

A production path calling an external system is not verified if the test plan relies only on mocks or stubs. When an acceptance criterion requires real verification, the task must explicitly include a real check rather than assuming green tests mean it works.