Skip to content
Skills Library
Management & product · Automation

run-plan

/run-plan

Execute a written plan. Use when handed a plan file, or resuming one mid-flight. Not for writing the plan (write-plan) or reviewing a suspect one (plan-hunt).

Licence
MIT
Last repository change
27.10.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 27.10.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

Execute a written plan. Use when handed a plan file, or resuming one mid-flight. Not for writing the plan (write-plan) or reviewing a suspect one (plan-hunt).

Original author description

Execute a written plan. Use when handed a plan file, or resuming one mid-flight. Not for writing the plan (write-plan) or reviewing a suspect one (plan-hunt).

How it works

  1. Steps
  2. Referencing
  3. Stopping
Original SKILL.md headings · 67 lines, 594 words
SKILL.md preview
---
name: run-plan
description: Execute a written plan. Use when handed a plan file, or resuming one mid-flight. Not for writing the plan (write-plan) or reviewing a suspect one (plan-hunt).
---

# Run Plan

You are the **cold executor** [write-plan](../write-plan/SKILL.md) wrote for.

The plan carries its own contract — Executor rules, Verify lines, Scope, Done, STOP. This skill covers only what the file cannot: where you are in it, and what happens when it breaks.

## Steps

### 1. Orient

Read the whole plan. Establish that it still describes the repo: run its **Drift check** first — its file list is what narrows the excerpt match — then match each **Current state** excerpt in a file it flags. Read the run log beside the plan if one exists; the first unlogged step is where you start.

**Done when** the drift command has run, every Current state excerpt in a flagged file has been matched against that file (a mismatch is a STOP), and the starting step is named.

### 2. Work one step

Do exactly what this step says; the next step starts once this one's Verify has matched. Where the step adds behavior, work it as [tdd](../tdd/SKILL.md): the seams are the step's.

A step carrying no Verify line closes on the **Commands** table instead — every command in it runs and hits its Expected-on-success cell.

**Done when** the step's Verify command has run and matched its expected result.

### 3. Log, then take the next step

Append one line to the run log before starting the next step. The plan itself is never edited — it was written against a commit, and execution state is not part of it.

```markdown
# Run: <plan title>

Executing [`<name>.plan.md`](<name>.plan.md), started <YYYY-MM-DD> at `<short SHA>`.

- **1** 2026-08-13 — done. `pnpm typecheck` → exit 0.
- **2** 2026-08-13 — done. `pnpm test` → 41 passed.
- **3** 2026-08-13 — STOP: `db.ts:40-60` no longer matches Current state.
```

Repeat 2–3 until the steps run out or a step logs STOP. A STOP ends the run there: skip Close and report under [Stopping](#stopping).

**Done when** every step in the plan carries a run log line reading done, or the log's last line reads STOP and every line before it reads done.

### 4. Close

Run the **Done** checklist as commands and record each result under `## Done` at the foot of the run log. Report those results to the user, with the plan's Notes review points and every deviation the log holds. Then hand the landed change to the reviewers its risk earns, each on its own axis: [bug-hunt](../bug-hunt/SKILL.md) for correctness and security, [qc](../qc/SKILL.md) for structure, and — where the Goal cites requirement IDs — [verify-specs](../verify-specs/SKILL.md) for behavior. The plan's Done proves the steps ran, not that the code is correct, the structure held, or the behavior arrived.

**Done when** every Done box has a command result behind it, the user has the list, and bug-hunt and qc have been handed the change (verify-specs too, where the Goal cites requirement IDs).

## Referencing

The run log lives beside the plan it executes as `<name>.run.md`, under the [referencing convention](../write-specs/SKILL.md#referencing) — dated by the plan's directory rather than the day of the run. One log per plan: a retry after a STOP appends to the same file.

```markdown
plan [`<name>.plan.md`](<name>.plan.md)
step [`step 3`](<name>.plan.md#3-<step-slug>)
evidence [`db.ts:42`](../../../src/lib/db.ts#L42)
```

## Stopping

STOP is a report. Name the condition, the step, and the evidence, then hand off:

| What tripped it                          | Hands to                                                      |
| :--------------------------------------- | :------------------------------------------------------------ |
| Behavior the spec got wrong              | [write-specs](../write-specs/SKILL.md#spec-delta), as a delta |
| A decision only the user makes           | [grilling](../grilling/SKILL.md)                              |
| Drift, failed verification, foreign file | the user, with the log line                                   |

Versions

RepositoryScoreLicence
This page · j0hanz/j0hanz-marketplace100MIT
tojim00d/Orbit-skills100MIT

Database snapshot: 13.11.2026 · package version a1f119260280 (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

  • 90plan-session
    Use when starting or resuming a structured multi-step task that involves PLAN.md and EXECUTION.md
  • 100execute-plan
    <EXTREMELY_IMPORTANT>You MUST use execute-plan immediately when you have a finalized plan file and are ready to begin implementation. Always use this skill before starting to write code based on a plan.</EXTREMELY_IMPORTANT>
  • 90execute-plan
    Use when carrying out an implementation plan the person has already approved, whether starting it or resuming it in a later session, and the tracker in it has to stay true while the work happens. Not for producing the plan (write-plan) and not for reviewing the result.
  • 90finalize-plan
    Review a plan for completeness before accepting it. Use when in plan mode, before approving the plan and clearing context, to confirm that key decisions, file names, commands, and constraints from the conversation are captured in the plan file so a fresh context can execute it.
  • 98exec
    Execute plan tasks sequentially using subagents. Use when user says 'exec', 'execute plan', 'run plan', or wants to implement a plan file task by task with isolated subagents.
  • 100plan-review
    Use when reviewing a plan document for quality, completeness, and sprint-readiness — after plan-docs generation, when the user mentions plan review, review my plan, document review, or invokes /plan-review.

Feedback and reports

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