- name
SKILL.md
The skill file stays in the publisher's repository.
Paste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add rizqinrr/viserys-agent --skill get-tasks -a cursor -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add rizqinrr/viserys-agent --skill get-tasks -a claude-code -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add rizqinrr/viserys-agent --skill get-tasks -a codex -yPaste the copied command in a terminal. It installs this SKILL.md into that agent.
npx skills add rizqinrr/viserys-agent --skill get-tasks -a grok -ySend the copied message in a Grok Bot chat. The Bot fetches this SKILL.md from GitHub and adds it to the skills all your Bots share.
Install this skill: https://github.com/rizqinrr/viserys-agent/tree/HEAD/skills/get-tasksFrom the publisher
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:
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.
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:
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.
Use this skill when:
When NOT to use:
get-prd first, then come backtasks/ and you are ready to implement — proceed directly to executing the tasks in sequenceget-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
task-01.md, branch, commit, TDD).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.Planning is read-only. Phases 0 through 7 produce documents and questions, not code. Do not create, edit, or delete any source file during those phases. Writing task files under tasks/ is the only filesystem change allowed before the user approves. If you find yourself fixing a bug or adding a function while breaking down work, stop: that belongs to post-approval implementation, and it belongs to a task you have not written yet.
Find the source document before doing anything else.
get-prd saves to docs/prd/<name>.md. Look there first.docs/prd/ is empty, look for a PRD the user names. Accept an issue body or a pasted requirements document — the skill is not format-bound, only the extraction in Phase 1 assumes the PRD section names.get-prd for a full interview-to-PRD pass.Record the exact path you are working from. Every later phase references it.
For a multi-module initiative where the PRD is split by module id (docs/prd/identity.md, docs/prd/billing.md), confirm which module this breakdown covers. One breakdown per module, in the build order the capability map declared.
Exit condition: a single source document is identified, and its path is on the record.
Read the PRD in full. Then extract, explicitly, the material that drives decomposition:
Rules:
Exit condition: the extraction table is populated, and any gap has been raised with the user.
Before writing a single task, map what depends on what. This is the phase that determines the order and prevents the most expensive class of mistake: building a consumer before its producer exists.
Draw the graph. Concrete, not abstract:
Database schema
|
+-- API models and types
| |
| +-- API endpoints
| | |
| | +-- Frontend API client
| | |
| | +-- UI components
| |
| +-- Validation logic
|
+-- Seed data and migrations
Rules:
Exit condition: a dependency graph exists, with a clear frontier, and no cycles.
Cut the work into tracer bullets: narrow but complete paths through every layer the feature needs.
Horizontal slicing is the default mistake. It looks tidy and produces nothing runnable until the last task:
Bad (horizontal):
Task 1: Build the entire database schema
Task 2: Build all API endpoints
Task 3: Build all UI components
Task 4: Connect everything
At the end of Task 3, nothing works. Nobody can demo anything. A wrong assumption in Task 1 is discovered in Task 4.
Vertical slicing produces working software at every step:
Good (vertical):
Task 1: A user can create an account (schema + API + UI for registration)
Task 2: A user can log in (auth schema + API + UI for login)
Task 3: A user can create a task (task schema + API + UI for creation)
Task 4: A user can view the task list (query + API + UI for list view)
Rules for a good slice:
Wide refactors are the exception. A wide refactor is one mechanical change (rename a column, retype a shared symbol) whose blast radius fans across the whole codebase, so no vertical slice can land green. Do not force it into a tracer bullet. Sequence it as expand, migrate, contract:
When even the batches cannot stay green alone, keep the same sequence but let them share an integration branch that all block a final integrate-and-verify task, where green is promised.
Exit condition: every piece of work belongs to exactly one task, and every task is a vertical slice or a declared wide-refactor step.
Write each task as its own file. One task per file, always — never a single combined document with all tasks inside.
Output path: tasks/<name>/task-NN.md, where <name> matches the PRD's name (so a PRD at docs/prd/billing.md produces tasks/billing/task-01.md). Number from 01, in dependency order — blockers get the low numbers.
Task file template:
# Task NN: <Short descriptive title>
**Source:** docs/prd/<name>.md — <PRD section this task implements>
**What to build:** The end-to-end behaviour this task makes work, from the
user's perspective. Not a layer-by-layer implementation list. If you cannot
describe it as behaviour a user or caller can observe, reshape the task.
## Acceptance criteria
- [ ] <specific, testable condition>
- [ ] <specific, testable condition>
Every criterion must be checkable by someone who did not write the task.
"Works correctly" is not a criterion. "A user can register with an email and
password and is redirected to the dashboard" is.
## Verification
- [ ] Tests pass: <the repository's focused-test command or new test to write first>
- [ ] Build succeeds: <the repository's build command>
- [ ] Output matches: <expected pattern or artifact that must exist>
- [ ] No regressions: <the full suite or the relevant subset>
- [ ] Quality & Security: <input validation, auth boundaries, follows ../../references/definition-of-done.md>
- [ ] Manual check: <what a human confirms by looking or clicking>
Run these in order. Do not mark the task complete on a partial pass.
## Blocked by
<Task numbers that must be complete first, or "None — can start immediately">
## Files likely touched
- `path/to/file`
- `path/to/test`
This list is an estimate, not a boundary. Discovering a file outside it is
expected; silently editing an unrelated one is not.
## Estimated scope
<XS: 1 file | S: 1-2 files | M: 3-5 files | L: 5-8 files | XL: too large, split>
## Rollback
<How to undo this task if it turns out wrong: the revert command, the feature
flag to disable, or the migration's down direction. If there is no rollback,
say so explicitly — that is a risk worth surfacing.>
## Notes
<Optional. Decisions taken during breakdown, open questions, links to the PRD
sections that constrain this task.>
Rules for filling it:
../../references/definition-of-done.md answers "is it done to our standard?". Both apply.Task 03) so a rename does not break the chain.Exit condition: every task from Phase 3 has a complete file, with no blank template sections.
Arrange the tasks so the sequence is correct and the risk is early.
Ordering rules:
Sizing rules:
An agent performs best on S and M. Break any task that is L or larger.
When to split a task further:
Checkpoints. Insert a checkpoint after every two to three tasks. A checkpoint is not a task; it is a gate. Write it as its own file tasks/<name>/checkpoint-NN.md:
# Checkpoint NN: after Tasks <a>-<b>
- [ ] All tests pass
- [ ] The build succeeds with no errors
- [ ] The core flow works end-to-end
- [ ] No task left half-done
- [ ] Human review before proceeding
If any item fails, stop and fix before continuing. Checkpoints exist so a wrong
assumption costs one checkpoint instead of the whole plan.
Place a final checkpoint that verifies the PRD's Success Criteria directly, section by section.
Exit condition: every task has a number, a size, and a place in the sequence; checkpoints are placed; the final checkpoint maps to the PRD's success criteria.
Before writing the plan document, classify the tasks by how they may run. Agents and humans both parallelize badly by default, so make the classification explicit rather than leaving it to whoever picks up the work.
Rules:
The task files are the executable units. The plan document is the human-readable summary that indexes them and records what the task files deliberately omit: design decisions, risks, and unresolved questions.
Write tasks/<name>/plan.md:
# Implementation Plan: <Project or Feature Name>
## Overview
One paragraph. What this breakdown covers, and which PRD it came from
(`docs/prd/<name>.md`).
## Architecture Decisions
- <Decision and the reasoning that produced it>
- <Decision and the reasoning that produced it>
These are the decisions taken during breakdown that the PRD left open or that
only became visible once the work was sliced. Anything already settled in the
PRD's Technical Decisions section is not repeated here.
## Phases
### Phase 1: <Foundation | Core | Polish | ...>
- [ ] Task 01: <title>
- [ ] Task 02: <title>
**Checkpoint:** <what must be true before Phase 2 starts>
### Phase 2: <...>
- [ ] Task 03: <title>
**Checkpoint:** <what must be true before Phase 3 starts>
### Phase 3: <...>
- [ ] Task NN: <title>
**Final checkpoint:** every Success Criterion from the PRD is verified.
## Parallelization
| Task | Category | Notes |
|---|---|---|
| 01 | Must be sequential | Defines the schema everything else reads |
| 02 | Safe to parallelize | Independent slice |
| 03 | Needs coordination | Shares the billing contract with 04 - freeze it first |
## Risks and Mitigations
| Risk | Impact | Mitigation |
|---|---|---|
| <What could go wrong> | <High/Med/Low> | <How we reduce or detect it> |
## Open Questions
- <Question that still needs human input, and which task it blocks>
## Task Index
| # | Task | Size | Blocked by | Category | File |
|---|---|---|---|---|---|
| 01 | <title> | M | — | sequential | `task-01.md` |
| 02 | <title> | S | 01 | parallel | `task-02.md` |
Rules:
Exit condition: tasks/<name>/plan.md exists with all seven sections populated, and it agrees with the task files.
Present the proposed breakdown before writing the files. Show a compact table, not the full task bodies:
| # | Task | Size | Blocked by | Category | What it delivers |
|---|---|---|---|---|---|
| 01 | User registration | M | — | sequential | A user can create an account |
| 02 | Login and session | M | 01 | needs coordination | A user can log in and stay logged in |
| 03 | Password reset | S | 02 | parallel | A user can recover access |
Then ask:
Iterate until the user approves. Do not write the task files before approval — the table is cheap to change, the files are not. Writing tasks/<name>/plan.md before approval is allowed and often helps: it gives the user something concrete to object to.
Exit condition: the user has approved the breakdown, explicitly.
Write the approved files.
tasks/<name>/ and write one file per task, numbered from 01 in dependency order. Write checkpoints as their own files (checkpoint-01.md, ...).tasks/<name>/plan.md per Phase 6. Keep its Task Index in step with the files on disk.todowrite, one item per task, in order. Mark the first task and any blocking tasks high, parallel tasks medium, and optional tasks low. Keep the todo list and the task files in step; drift between them is a red flag.tasks/<name>/ already exists with unchecked tasks:
<name>.Blocked by value names a task that exists, or says None01 and are contiguousExit condition: files written, todos synced, verification checks all pass, and the user knows the next step.
get-tasks produces tasks, not code. After approval, hand off explicitly:
docs/design.md produced by get-design for design tokens and component states.Name the first task to start with, and say which task is blocked by it.
Breakdown is a living document. When a task fails during execution, follow this procedure rather than pushing through.
todowrite.Never silently reorder tasks or drop one. A dropped task is a dropped requirement.
The task list target is where tasks are recorded. It is defined once, here; every reference in this skill defers to it.
tasks/<name>/. One file per task, plus tasks/<name>/plan.md. This is the convention get-prd feeds into and the one downstream skills expect.AGENTS.md, CLAUDE.md) or the user designates an issue tracker (GitHub Issues, Jira, Linear, bd/beads), publish one item per task instead of, or in addition to, the files. Map the task template onto the tracker's fields:
Blocked by -> the tracker's native linking mechanism (bd dep add, "blocked by", sub-issue)tasks/<name>/plan.md if the tracker has no equivalentRules that apply to both targets:
tasks/<name>/ and tracker items, then updating only one, is how task lists rot. If both exist, the plan document names the tracker as the source of truth for status.tasks/<name>/plan.md (for example "Status tracked in Linear project FOO") so a later session knows where to look. Keep the plan document's Task Index as an index of item ids or links, never a duplicate checklist.Blocked by value naming a task that does not existtasks/<name>/ directory that still has unchecked tasks, without askingtasks/<name>/plan.md, or a plan document whose Task Index disagrees with the files on diskBefore declaring get-tasks complete:
tasks/<name>/, numbered from 01Blocked by value names an existing task or says Nonetasks/<name>/plan.md exists with Overview, Architecture Decisions, Phases, Parallelization, Risks and Mitigations, Open Questions, and Task Indextasks/<name>/plan.md, and only one target is in active useA PRD for an "experiment tracker" exists at docs/prd/experiment-tracker.md. Its Technical Decisions section names three modules: storage, list view, signal capture. Its User Stories include "as a user, I want to see all my running experiments in one place" and "as a user, I want to record an early signal against an experiment".
Phase 2 dependency graph:
Storage and schema
|
+-- Experiment list query
| |
| +-- List view UI
|
+-- Signal model
|
+-- Signal capture UI
|
+-- Signal display in list
Phase 3 slices: four vertical cuts. Note the third slice is not "build the signal UI" (horizontal) but "a user can record a signal against an experiment" (vertical).
Phase 4, the second task file, in full:
# Task 02: A user can see all running experiments
**Source:** docs/prd/experiment-tracker.md — User Stories, Objective
**What to build:** A user opens the app and sees a list of every experiment
currently running, with its name and its latest signal. The list is populated
from stored data, not fixtures.
## Acceptance criteria
- [ ] Opening the app shows every stored experiment with status "running"
- [ ] Each row shows the experiment name and its most recent signal value
- [ ] An experiment with no signals yet still appears, showing "no signal"
- [ ] The list is empty-state aware: with no experiments, it says so
## Verification
- [ ] Tests pass: npm test -- experiments/list
- [ ] Build succeeds: npm run build
- [ ] Output matches: rendered list contains one row per running experiment
- [ ] No regressions: npm test
- [ ] Manual check: create two experiments, one with a signal, confirm both appear
## Blocked by
Task 01 — storage and schema
## Files likely touched
- `src/experiments/list.ts`
- `src/experiments/list.test.ts`
- `src/ui/ExperimentList.tsx`
## Estimated scope
M — 3 files
## Rollback
Revert the commit. The list view is additive; no data is written.
## Notes
Empty-state behaviour is not specified in the PRD. Defaulting to an explicit
"no experiments yet" message; flagged as a PRD gap.
Phase 5: Task 02 is M, blocked by Task 01, ordered second. A checkpoint is placed after Task 03.
Parallelization classification: Task 01 is "must be sequential" (it defines the schema every other task reads). Tasks 02 and 03 are "safe to parallelize" once 01 lands. Task 04 is "needs coordination" — it reads both the list query from 02 and the signal model from 03, so it waits for both.
Phase 6, an excerpt from tasks/experiment-tracker/plan.md:
# Implementation Plan: Experiment Tracker
## Overview
Breakdown of docs/prd/experiment-tracker.md into four tasks across two phases.
## Architecture Decisions
- Signals are stored as append-only rows rather than a mutable field on the
experiment, so history survives and "latest signal" is a query, not a write.
- The list view reads from the same query layer as the detail view, rather than
maintaining its own projection.
## Phases
### Phase 1: Foundation
- [ ] Task 01: Storage and schema
- [ ] Task 02: Experiment list view
**Checkpoint:** an experiment can be stored and listed end to end.
### Phase 2: Signals
- [ ] Task 03: Signal capture
- [ ] Task 04: Signal display in list
**Final checkpoint:** every Success Criterion in the PRD is verified.
## Risks and Mitigations
| Risk | Impact | Mitigation |
|---|---|---|
| Signal volume grows unbounded | Med | Cap retention per experiment; revisit if the list query slows |
| Empty-state copy unspecified in the PRD | Low | Chose explicit copy; recorded as an open question |
## Open Questions
- Should finished experiments be hidden by default or shown greyed out?
Blocks Task 02's empty-state behaviour.
Phase 7 table shown to the user:
| # | Task | Size | Blocked by | Category | What it delivers |
|---|---|---|---|---|---|
| 01 | Storage and schema | M | — | sequential | Experiments can be stored and read |
| 02 | Experiment list view | M | 01 | parallel | A user can see all running experiments |
| 03 | Signal capture | M | 01 | parallel | A user can record a signal |
| 04 | Signal display in list | S | 02, 03 | needs coordination | The list shows each experiment's latest signal |
Only after the user approves this table do the task files get written.
get-prd: upstream and the normal source. Its output at docs/PRD.md (or docs/prd/<name>.md) is this skill's default input.get-design: companion for frontend and user-facing workflows. When tasks involve UI or layout, consult docs/design.md for tokens, component states, and visual direction.../../references/definition-of-done.md: complements this skill. Per-task acceptance criteria answer "did we build the right thing"; the Definition of Done answers "does it meet our standing bar". Both apply to every task.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
---name: get-tasksdescription: Turns an approved PRD into a tracked set of task files. Use when a PRD exists at docs/prd/ and needs…---# skills/get-tasks/SKILL.mdOverview
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.
FAQ
Download skills/get-tasks/SKILL.md from the publisher, or copy the path and open the repository. PlugMCP lists the skill and does not host the file.
The publisher keeps it at https://github.com/rizqinrr/viserys-agent.
Claude, Cursor, Codex, and Grok Build can read a SKILL.md you add from the publisher's repository. Grok Bot installs it when you send the skill's GitHub folder link in a chat.
| "Everything can be parallel" | Only if nothing shares state or a contract. If two tasks both touch the billing contract, they are sequential until it is frozen. |
| "I'll set up the tracker and the files, keep both in sync manually" | You will update one and forget the other. Pick one target and declare it in tasks/<name>/plan.md. |
| "Design decisions can go in the task they affect" | Then no one can find them without reading every task. Decisions that span tasks belong in the plan document. |
| "The user said go, so I can start implementing while I write the tasks" | Planning is read-only. Starting implementation during breakdown produces tasks describing code that already exists — the breakdown stops being a plan and becomes a changelog. |
todowrite is synced with the task files