Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

pitroom-driven-development

Use when executing a written implementation plan - each task goes to a Pitroom worker in an isolated copy, a worker on another model reviews it, and you rule, apply and commit between tasks.

ATASTECH · Static checks on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add ATASTECH/pitroom --skill pitroom-driven-development

About this skill


name: pitroom-driven-development description: Use when executing a written implementation plan - each task goes to a Pitroom worker in an isolated copy, a worker on another model reviews it, and you rule, apply and commit between tasks.

Pitroom-Driven Development

Execute a plan by giving each task to a fresh implementer worker in an isolated copy, a task review (spec compliance and code quality) by a worker on another model after each, and a whole-branch review at the end. You are the controller: you never write a task's code yourself; you rule on conflicts, apply patches and commit.

Why workers: each gets exactly its task (Pitroom extracts it from the plan) and none of your conversation. Their tokens are cheap and your context stays free for coordination. A reviewer on a different backend is a second model, not the implementer grading itself.

Core principle: fresh worker per task + task review on another model + whole-branch review = high quality at worker prices.

Narration: between tool calls, at most one short line. pitroom plan status and the tool results carry the record.

Continuous execution: do not pause to check in with your human partner between tasks. The only reasons to stop are the four below, or all tasks complete. "Should I continue?" prompts waste their time: they asked you to execute the plan.

Rulings, not stalls. Conflicts, ambiguities, plan defects, a cap you would have asked to exceed: decide them. The spec is the binding authority, the plan is its argument, and your judgment settles what neither answers. Record every decision with pitroom plan note PLAN "Task N: Ruling: <what you decided> — <why> — <what it costs if wrong>" and keep going. A wrong ruling costs rework your human partner can see and undo; a session parked on a question costs their whole day.

Four things stop you, and only these: an irreversible or destructive operation; a security-sensitive action; a side effect outside this branch that norms say you ask about first (a merge, a push, a publish); a plan so broken that every path forward is a guess.

Setup

  1. Branch: pitroom-worktrees. Never implement on main/master without explicit consent.
  2. Where are we: pitroom plan status PLAN. A task with a Task N: complete note is done: never re-dispatch it. A task with runs but no completion note is mid-loop: continue it from its last run and review. After compaction, trust pitroom plan status and git log over your memory.
  3. Read the plan once, and its Spec. Note the Global Constraints. Create a todo per task.
  4. Pre-flight scan, before Task 1. Its output is a table, not a verdict: one row for every pair of tasks that share a file or an interface (what one produces against what the other consumes), one row per task on whether its own text agrees with itself (its tests against its code, the files it creates against the files it later touches), and anything the plan mandates that the review rubric treats as a defect (a test that asserts nothing, duplicated logic). Rule on every finding and note the rulings. The table also tells you which tasks are independent (see Parallel tasks).
  5. Worker setup: tasks that run the project's tests need its dependencies inside the isolated copy: pass --link node_modules (or .venv, …) or set link in the config.

Tiers

Every task names a tier (**Worker:** cheap|standard|capable), and pitroom run --plan uses it. The config maps tiers to workers (pitroom config shows tiers); an unconfigured tier falls back to the default worker with a warning. Escalating means the next tier up: cheap → standard → capable. Above capable is you, and you only rule; you do not write the code.

The task loop

1. Implement

pitroom run -i --plan PLAN --step N --link node_modules --verify "<the task's test command>" --bg \
  "<optional notes: interfaces or decisions from earlier tasks the brief cannot know, your resolution of an ambiguity>"

Pitroom gives the worker the implementer rules, the plan's context and Global Constraints, and Task N's text; never paste plan text yourself. The run joins the plan's group: follow it with pitroom watch -g <plan name> --json or pitroom wait <run>.

2. Handle the status

The report starts with plan: … · STATUS <value>:

  • DONE: review it (step 3).
  • DONE_WITH_CONCERNS: read OPEN ISSUES. Doubts about correctness or scope: resolve them first with pitroom run --continue <run> "<guidance>". Observations: note them and review.
  • NEEDS_CONTEXT: pitroom run --continue <run> "<the missing context>".
  • BLOCKED: a context problem → --continue with context; it needs more reasoning → a fresh run one tier up (--tier); too large → split it and note the ruling; the plan is wrong → rule, note, and re-dispatch with the ruling in the notes.
  • unknown (no status line): treat it as DONE_WITH_CONCERNS.

Never make the same worker retry without changing something. A failing verify: line is a finding for the fix loop, not a reason to fix it yourself.

3. Review

pitroom review <run>

A read-only worker on another backend gets one package: the brief, the implementer's report and the diff with context. It returns SPEC PASS|FAIL, QUALITY APPROVED|NEEDS-FIXES and the issues by severity. Never skip it, and never accept a review that lacks either verdict; the implementer's self-review never replaces it.

  • Don't pre-judge: never tell a reviewer to ignore something. A finding you think is a false positive enters the loop; you adjudicate at the cap.
  • CANNOT VERIFY items (requirements in unchanged code or across tasks): check each yourself before completing the task. A real gap is a failed spec review.

4. The fix loop

It triggers on SPEC FAIL, any Critical or Important finding, or a CANNOT VERIFY item you confirmed. Minor findings never enter the loop: note them (pitroom plan note PLAN "Task N: minor (deferred): …") for the

Read the complete source ↗