Skip to content
Skills Library
AI & agents · Planning

loop-planner

/loop-planner

The planner role in a /loop-driver. Turns a vague human goal into a gradable contract of testable assertions and never touches code. Use when the user assigns this session as the planner in a generator/evaluator loop, or runs /loop-planner.

Repository
terminal ↗
Licence
MIT
Last repository change
01.09.2026

Assessment and security

90/ 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.
Content25 / 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 01.09.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

The planner role in a /loop-driver. Turns a vague human goal into a gradable contract of testable assertions and never touches code. Use when the user assigns this session as the planner in a generator/evaluator loop, or runs /loop-planner.

Original author description

The planner role in a /loop-driver. Turns a vague human goal into a gradable contract of testable assertions and never touches code. Use when the user assigns this session as the planner in a generator/evaluator loop, or runs /loop-planner.

How it works

  1. Your job
  2. Discipline
  3. Output
Original SKILL.md headings · 45 lines, 293 words
SKILL.md preview
---
name: loop-planner
description: "The planner role in a /loop-driver. Turns a vague human goal into a gradable contract of testable assertions and never touches code. Use when the user assigns this session as the planner in a generator/evaluator loop, or runs /loop-planner."
---

# Loop Planner

You are the **planner** in a three-role loop (planner / generator / evaluator).
You turn a vague human sentence into a sprint spec and a gradable contract. You
**never touch code** — not one line. Shared context:
[../loop-driver/references/principles.md](../loop-driver/references/principles.md) (rules II–III),
[../loop-driver/references/state.md](../loop-driver/references/state.md),
[../loop-driver/references/roles.md](../loop-driver/references/roles.md).

## Your job

1. Read the human goal and the repo enough to be concrete (read-only).
2. Draft `$(tm-state-dir loops)/<loop-id>/contract.md`:
   - One-sentence **Goal** and an explicit **Boundary** (what's out of scope —
     the boundary is yours; the assertions get graded).
   - A checklist of **testable assertions** (10–30 for a small app; ten is too
     few and gets rubber-stamped). Each must be decidable by a command, a
     Playwright step, or an evaluator check. "Looks polished" is not testable;
     "no console errors on `/` and every interactive element has a visible focus
     ring" is.
   - If the work is taste-bearing, a `## Taste calibration` block: three good
     references and three slop ones (see
     [../loop-driver/references/taste.md](../loop-driver/references/taste.md)).
3. Seed `progress.md` (phase `negotiate`, first bottleneck, next step) and
   `## [date] init | goal` in `log.md`.
4. Hand the draft to the evaluator and **let it push back** (Handshake 1). Revise
   until the evaluator signs off. Then step out of the way.

## Discipline

- Right-size the plan to the goal. No speculative scope, no abstractions the
  contract doesn't need.
- Assertions are observable outcomes, not implementation steps.
- Prefer fewer, sharper assertions over many vague ones — but not so few they
  rubber-stamp.
- You do not implement, you do not grade, and you do not re-enter the loop unless
  the **contract** needs to change (a human-gate event).

## Output

A `contract.md` the evaluator agrees is fully gradable, plus seeded `progress.md`
and `log.md`. Emit `kind: status` on `events.jsonl`: `"contract drafted, N
assertions, awaiting evaluator"`.

Versions

RepositoryScoreLicence
This page · trevormil/terminal90MIT
ibrahim-3d/orchestrator-supaconductor100AGPL-3.0

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

  • 90loop-implementer
    The generator role in a /loop-driver. Writes all the code against the agreed contract and is forbidden from grading its own work. Use when the user assigns this session as the generator/implementer in a generator/evaluator loop, or runs /loop-implementer.
  • 90loop-evaluator
    The evaluator role in a /loop-driver. Reads diffs and traces, runs the app, and is told from message one that the code is broken and its job is to prove it. Grades the contract and scores taste. Use when the user assigns this session as the evaluator/reviewer in a…
  • 100planner
    Explicitly invoked two-session workflow for planning repository changes and handing approved implementation to another model through PLANNER.md. Use when the user requests planner plan or planner implement.
  • 100run-next-sprint
    Drive one full sprint of the proof refinement harness: spawn the Planner to write a Sprint Contract, spawn the Generator to execute it, spawn the Evaluator to grade it, and report a one-paragraph status. Use when the user runs /run-next-sprint or when /loop fires this command.
  • 90goal-loop
    Run a task as a goal loop. Write a contract (goals, exit criteria, checks, budget), work, verify with an independent agent, repeat on FAIL until PASS or budget. Use for "goal loop", "verify until done", or exit criteria plus a verifier.
  • 95gauntlet-loop
    Turns any goal into one short, paste-ready gauntlet-loop prompt for Grok Build, then can run it with a lead-managed spawn_subagent loop. Depth-1 spawns. No /loop, no ultracode — those are Claude Code. Triggers on "/gauntlet-loop", "gauntlet loop", "gauntlet this".

Feedback and reports

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