ak-plan — Claude Code skill: plan and track multi-task projects
ak-plan — a skill that breaks down a large project into manageable tasks and tracks them through Agent Kanban. Use it when you want an agent to coordinate work across a task board with clear dependencies.
Apache-2.0 139 installs ★ 506 updated 2026-10-02
npx skills add saltbo/agent-kanban --skill ak-plan -a claude-codeWhat ak-plan does
ak-plan reads existing Agent Kanban boards and repositories, then splits a project into independent work items with clear ownership boundaries and dependency relationships. Instead of chronological steps, it divides work by modules or behavior, allowing tasks to run in parallel and be reviewed separately.
Once you approve the plan, the skill creates tasks in Kanban, assigns them to available agents (marked schedulable: true), and monitors their progress. When a task reaches review, it verifies the output and either approves it or sends it back with feedback about what needs fixing.
The skill requires realmroot toolbox utilities and access to the Agent Kanban API. It checks whether resources already exist before creating new ones.
What it helps with
- split a large project into independent work items
- assign tasks to different agents and track completion
- review results and send work back for changes if needed
- manage dependencies and prevent parallel edits to the same files
Example prompts for the agent
- Plan a project: split it into API, tests, and docs tasks, then create a board
- Create tasks for Stripe integration including payment verification
- Execute through Agent Kanban: distribute work, wait for results, review each task
How to install ak-plan
1Skills CLI (Vercel)
npx skills add saltbo/agent-kanban --skill ak-plan -a claude-code2Manually: put the files in place
~/.claude/skills/ak-plan/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/ak-plan/
1Skills CLI (Vercel)
npx skills add saltbo/agent-kanban --skill ak-plan -a codex2Manually: put the files in place
.agents/skills/ak-plan/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add saltbo/agent-kanban --skill ak-plan -a cursor2Manually: put the files in place
.cursor/skills/ak-plan/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install saltbo/agent-kanban skills/ak-plan2Manually: put the files in place
.github/skills/ak-plan/SKILL.md1Skills CLI (Vercel)
npx skills add saltbo/agent-kanban --skill ak-plan -a gemini-cli2Platform CLI
gemini skills install https://github.com/saltbo/agent-kanban --path skills/ak-planManually: put the files in place
.devin/skills/ak-plan/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add saltbo/agent-kanban --skill ak-plan -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about ak-plan
How do I install ak-plan in Claude Code?
Run npx skills add saltbo/agent-kanban --skill ak-plan -a claude-code, then check ~/.claude/skills/ak-plan/SKILL.md.
What does ak-plan do?
It helps an agent plan a project, break it into tasks with proper dependencies, create a board in Agent Kanban, and track each task from start through review and completion.
What tools does ak-plan need?
You need realmroot toolbox to interact with the Agent Kanban API, and access to boards and repositories in Kanban itself. The skill checks for available agents before assigning work.
Source text
SKILL.md · Apache-2.0
---
name: ak-plan
description: Plan and execute a multi-Task project through Agent Kanban resources and Realmroot Toolbox. Use only when the user explicitly asks for AK Plan, an Agent Kanban project plan, or execution of a project through an AK board.
---
# AK Plan
## Plan before creating
Read the repository and existing AK resources before decomposition:
```bash
realmroot toolbox get agent-kanban/boards --json
realmroot toolbox get agent-kanban/repositories --json
realmroot toolbox get 'agent-kanban/tasks?boardId=<board-id>' --json
```
Define the architecture direction, shared contracts, ownership boundaries, and
dependency graph. Split work by independently reviewable behavior or module
boundary, not by chronological steps or job titles. Avoid a final catch-all QA
Task; each Task owns its implementation and proof.
Show the user the complete Board/Task preview and get confirmation before any
creation. Include every Task's goal, assignee, repository, dependencies, and
acceptance checks.
## Create resources
Create a Board or Repository only when it does not already exist:
```bash
realmroot toolbox post agent-kanban/boards --content-type application/json @board.json --json
realmroot toolbox post agent-kanban/repositories --content-type application/json @repository.json --json
```
Select an available Agent that reports `schedulable: true`:
```bash
realmroot toolbox get 'agent-kanban/agents?schedulable=true' --json
```
Use the selected Agent's `subject` as `assignedTo`. If no suitable
Agent exists and the caller is authorized to provision one, create it through
`agent-kanban/agents`.
For each approved work item, create an unassigned Task, then patch its
`assignedTo` field:
```bash
realmroot toolbox post agent-kanban/tasks --content-type application/json @task.json --json
realmroot toolbox patch agent-kanban/tasks/<task-id> \
--content-type application/merge-patch+json \
'{"assignedTo":"<realmroot-agent-actor-id>"}' --json
```
Realmroot Toolbox generates the required idempotency key and
reuses it across transient retries of this invocation. Supply an explicit
`Idempotency-Key` only when recovering with the known key from an earlier
invocation whose outcome remained unknown.
Encode real prerequisites in `dependsOn`. Tasks with overlapping files or
contracts should be combined or ordered; only independent Tasks should run in
parallel.
## Execute and review
After creation, continue until every Task is terminal unless the user asks to
stop. Use bounded waits with continuation cursors:
```bash
realmroot toolbox agent-kanban task wait <task-id> in-review --wait-seconds 25 --json
```
When the Task reaches `in-review`, verify the submitted work, then reread the
Task before making the review decision:
```bash
realmroot toolbox get agent-kanban/tasks/<task-id> --include --json
realmroot toolbox patch agent-kanban/tasks/<task-id> \
--content-type application/merge-patch+json \
'{"status":"in-progress","statusReason":"Describe the required correction"}' --json
realmroot toolbox patch agent-kanban/tasks/<task-id> \
--content-type application/merge-patch+json \
'{"status":"done"}' --json
```
Reject when acceptance evidence or implementation is insufficient, then wait
for a new `in-review` Task state. Complete only after the requested outcome is
proven. If the verified reviewer actor equals the Task's
`assignedTo`, do not attempt either decision; another authorized principal
must review.
When one prerequisite completes, reassess its dependent Tasks.
Report the final Task states, review outcomes, and unresolved external blockers.
© saltbo · Apache-2.0 · saltbo/agent-kanban