跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
其他技能

get-tasks

Turns an approved PRD into a tracked set of task files. Use when a PRD exists at docs/prd/ and needs executable tasks before implementation. Use when the user says "get tasks", "breakdown PRD", "pecah jadi task", or "bikin task list". Produces one detailed file per task with acceptance criteria, five-way verification, blocking edges, rollback, a plan document indexing them, and a parallelization classification.

rizqinrr · 已有静态检查记录

安装与使用

运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。

npx skills add rizqinrr/viserys-agent --skill get-tasks

技能说明


name: get-tasks description: Turns an approved PRD into a tracked set of task files. Use when a PRD exists at docs/prd/ and needs executable tasks before implementation. Use when the user says "get tasks", "breakdown PRD", "pecah jadi task", or "bikin task list". Produces one detailed file per task with acceptance criteria, five-way verification, blocking edges, rollback, a plan document indexing them, and a parallelization classification.

Get Tasks

Overview

get-tasks converts an approved PRD into an executable set of tasks. Each task is written to its own file, sized to fit a single focused session, ordered by dependency, and shipped with acceptance criteria, validation steps, a blocking list, and a rollback procedure.

The reason this exists as its own skill: a PRD is not a plan. A PRD states what the system does and why. It says nothing about the order of work, what can be built in parallel, where the risky parts are, or how to prove a slice is done. Turning a PRD straight into code produces either a heroic single-pass change or an arbitrary order that breaks halfway.

get-tasks supplies the missing layer. It reads the PRD, maps the real dependency structure, cuts the work into vertical slices, and writes each slice as a standalone artifact that an agent (or a human) can pick up without re-reading the whole PRD.

This skill draws from three sources:

  1. Dependency-first decomposition and vertical slicing — build a dependency graph, slice vertically rather than horizontally, size each task, and place checkpoints. This is what makes the order correct.
  2. Validation-driven execution — every task declares how it will be verified across multiple validation types, not just "tests pass", and carries a replan procedure for when a step fails.
  3. Blocking edges and tracer bullets — each task states explicitly what blocks it, so any task whose blockers are done can start immediately.

The output is a directory of task files: tasks/<name>/task-01.md, task-02.md, and so on, numbered in dependency order, plus tasks/<name>/plan.md indexing them. Blocker tasks get the low numbers.

Scope of This Skill

get-tasks is deliberately comprehensive. It absorbs what several narrower skills each did partially, so that a user only needs one skill to go from an approved PRD to a tracked, executable plan. Everything in here is relevant to that single job:

ConcernWhere it is handled
Reading the PRD and extracting commitmentsPhase 1
Dependency structure and orderingPhase 2
Vertical slicing and tracer bulletsPhase 3
Wide refactors (expand, migrate, contract)Phase 3
Per-task specificationPhase 4
Sizing and splitting rulesPhase 5
Checkpoints and gatesPhase 5
Parallelization classificationParallelization Taxonomy
Human-readable plan summary, risks, decisionsPhase 6
Tracker vs. file targetTask List Target
User approval before writingPhase 7
Writing, syncing, and verifying artifactsPhase 8
Handling failure and replanningReplanning When a Task Fails

It is long by design. The length is the point: a breakdown that leaves any of these implicit produces tasks that look finished and are not. If you are tempted to skim to the template, read Phases 2, 3, and 5 instead — those are where breakdowns actually fail.

What this skill does not do: it does not write code, does not run the tasks, and does not replace the PRD. It converts one document into a set of documents.

When to Use

Use this skill when:

  • A PRD, spec, or requirement document exists and the work needs to become executable tasks
  • The user says "get tasks", "breakdown PRD", "pecah jadi task", "bikin task list", or "turn this into tasks"
  • A task feels too large to start and needs decomposing
  • You need to estimate scope, order the work, or find what can run in parallel
  • You are about to implement something that touches more than a handful of files and no task list exists

When NOT to use:

  • No PRD exists yet — run get-prd first, then come back
  • The change is a single task by any measure (one file, one obvious edit) — just do it
  • A complete task breakdown already exists in tasks/ and you are ready to implement — proceed directly to executing the tasks in sequence

The Process

get-tasks runs in nine phases. Each phase has an exit condition. Do not advance past a phase whose exit condition is unmet.

0. Locate the PRD       -> which document is the source?
1. Read and extract     -> what does the PRD commit us to?
2. Dependency graph     -> what depends on what?
3. Vertical slices      -> tracer bullets, not horizontal layers
4. Write each task      -> one file per task, fully specified
5. Order, size, checkpoint -> sequence, size, and verification gates
6. Write the plan doc   -> the human-readable summary that indexes the tasks
7. Quiz the user        -> granularity, blocking edges, merge or split
8. Write and verify     -> files on disk, todos synced, validators green

Universal Principles for Task Breakdown

  1. Natural Language Pacing: Present the breakdown and conversational summaries in the language the user speaks (Indonesian or English), while keeping file names, git terms, and code tokens standard (task-01.md, branch, commit, TDD).
  2. Autonomous Execution Ready: Each generated task file in tasks/<feature>/task-*.md must be completely self-contained. Any coding agent should be able to read just that single task file, know what files to edit, what tests to run, and what definition of done must be satisfied without guessing.
  3. Vertical Slices over Horizontal Layers: Never create tasks that are purely "setup backend" or "setup frontend" in isolation if they cannot be verified end-to-end. Slice vertically (e.g. "Store & Query SKU endpoint with UI trigger") so each task delivers testable value.

Planning is read-only. Phases 0 through 7 produce do

阅读完整来源 ↗