Skip to content
Skills Library
AI & agents · Automation

run

/run

Run a multi-stage plan as a thin, long-lived orchestrator that delegates tasks, keeps context small, and tells the user when to /clear. Use when the user runs /orchestrate:run or asks to execute or resume a multi-stage plan.

Licence
MIT
Last repository change
06.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 06.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run a multi-stage plan as a thin, long-lived orchestrator that delegates tasks, keeps context small, and tells the user when to /clear. Use when the user runs /orchestrate:run or asks to execute or resume a multi-stage plan.

Arguments

/run [plan-file]
Original author description

Run a multi-stage plan as a thin, long-lived orchestrator that delegates tasks, keeps context small, and tells the user when to /clear. Use when the user runs /orchestrate:run or asks to execute or resume a multi-stage plan.

How it works

  1. 1. Start or resume
  2. 2. For each task
  3. 3. Keep your own context small
  4. 4. When to tell the user to /clear
  5. Plan file format
Original SKILL.md headings · 76 lines, 577 words
SKILL.md preview
---
name: run
description: Run a multi-stage plan as a thin, long-lived orchestrator that delegates tasks, keeps context small, and tells the user when to /clear. Use when the user runs /orchestrate:run or asks to execute or resume a multi-stage plan.
argument-hint: "[plan-file]"
---

# Orchestrator protocol

You are a thin orchestrator. Your job is to move a plan forward, not to hold it in your head.
The plan file is the single source of truth. Plan file: $ARGUMENTS (default: `docs/plan.md`).

## 1. Start or resume

1. Read the plan file. Find the first unchecked task.
2. If `docs/progress/` exists, read only the last few lines of the log.
3. Tell the user where things stand in 5 lines or fewer: current stage, next task, blockers.
4. No plan file? Stop and ask the user to write one in plan mode first, using the format below.

## 2. For each task

**Choose inline or a worker:**
- **Inline:** a small edit, roughly 3 files or fewer, that needs no big reads.
- **Worker:** a self-contained task, or noisy work such as test runs, wide searches or log reading.
- **Batching:** group tiny related tasks into one worker.
- **Parallel:** only for independent tasks, and at most 3 at once.

**Worker rules:**
- Use a fresh, named subagent (`implementer`, `reviewer`, `Explore`) if one exists. Otherwise use `general-purpose`.
- Never use a forked subagent for plan tasks: a fork inherits your whole context, which defeats the purpose.
- Pass a pointer, not pasted context. Use this template:

```
Do task <ID> from <plan file>. Read only the files that task needs.
Run tests with failures-only output. Put any notes in docs/progress/<ID>.md.
Reply in 10 lines or fewer: status (done/blocked), files changed, test result, open questions.
Do not paste diffs, file contents or full logs.
```

**After each task:**
1. Tick its checkbox in the plan file.
2. Append one line to `docs/progress/log.md`: `<ID> · done/blocked · one-line note`.
3. Commit if the task left the tests green, unless the user said not to commit.

State must live in files, never only in chat.

## 3. Keep your own context small

- Read files narrowly: grep first, then read with offset and limit. Don't re-read a file you already summarized.
- Never ask a worker for a detailed report. Summaries only.
- Don't switch plan mode or models mid-stage. A switch (for example with the opusplan alias) invalidates the prompt cache, so the whole conversation is re-read at full price.

## 4. When to tell the user to /clear

You cannot run /clear yourself, so remind the user at these moments:

1. **A stage is done:** all its tasks are ticked and committed.
2. **A plan was just approved:** clear before execution starts.
3. **The user changes topic** to unrelated work.
4. **The context-size warning appeared** (🧹 from the hook). Wait for the next task boundary.
5. **The user is stepping away for more than an hour.** The cache goes cold anyway, and /clear is free.
6. **A long debugging detour just ended** and its fix is committed.

**Rules:**
- Never remind mid-task.
- Before reminding, make sure the plan file and progress log are up to date and the work is committed.
- Use this exact format, as the last thing in your message:

> 🧹 **Good time to /clear** — <reason, e.g. "Stage 1 done">. State is saved in `<plan file>`.
> After clearing, run: `/orchestrate:run <plan file>`

## Plan file format

```markdown
# Plan: <project>

## Stage 1 — <goal>
- [x] 1.A1 <task> · files: <paths> · test: <command>
- [ ] 1.B1 <task> · files: <paths> · test: <command>
- [ ] 1.B2 <task> · depends on 1.B1
```

Versions

RepositoryScoreLicence
This page · mmgghh/claude-orchestrate100MIT
phnx-labs/agi-cli100Apache-2.0
Insilico-org/plsi100MIT
jtsternberg/claude-plugins100MIT
jameskomo/config-drift-checker100Apache-2.0
lucastamoios/skills100MIT
andriiklymiuk/corgi100MIT
lucastamoios/skills100MIT
Dinusha-Ekanayake/specsteward100MIT

Database snapshot: 13.11.2026 · package version 007ecd7129ea (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100orchestrator
    Use when a job is too big for one session to do itself - a plan index, a many-file migration, a batch of fixes, a broad audit. Runs the work as an orchestrator that delegates every unit to subagents and keeps its own context for coordination only
  • 96orchestrate
    Use when the orchestrator should work through the tasks in today's daily note.
  • 100plan-orchestrate
    Read a plan document, decompose it into steps, design a per-step agent chain from the ECC catalogue, and emit ready-to-paste /orchestrate custom prompts. Generative only — never invokes /orchestrate itself. Use when the user has a multi-step plan and wants to drive it through…
  • 86run-stage
    Launch one stage of a run as a role session with its stored assignment. Use when the manager starts the next stage or an ad-hoc one.
  • 90agent-orchestrator
    Coordinate a multi-agent run: plan, delegate, debate, and verify combined results. Use when asked to act as agent-orchestrator, manage agents, or pick up an earlier agent run and finish it; resume from its durable record.
  • 95plan-orchestrate
    Execute implementation plans with parallel TDD workers. Use when ready to run, execute, or start a plan. Triggers on "run the plan", "execute the plan", "implement the plan", "start the plan", "start implementation", "orchestrate", "begin autonomous execution". Requires a plan…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.