
odin-loop
Author, run, and refine custom AI dev workflow loops. Ships a deep-interview → plan → harness-design → harness-verify → implement → test → review loop, and lets you build your own loops as editable data.
- GitHub stars
- 5
Install
/plugin install odin-loop@odin-loopRun it inside Claude Code after adding the marketplace with /plugin marketplace add choo121600/odin-loop.
Contents
Discovered from sourceSkills 3
Hermóðr — the scheduler (Óðinn's herald)
Hermóðr runs Odin's errands on a schedule. He takes a fully-autonomous loop — one
that never pauses for a human — and registers it with the OS scheduler so it fires
unattended, then drives /odin-loop:odin run <loop> headlessly each tick.
This preserves Odin-Loop's core rule — humans hold the wheel at ai+human gates —
by construction: only loops with no human gate are schedulable, so an
unattended run can never silently auto-approve a checkpoint. Because "no human gate" is
necessary but not sufficient for safety (an all-ai loop can still merge PRs or
ship code), registration also makes the loop's blast radius explicit and contains
the run behind a scoped Claude settings profile.
All deterministic work — schedulability, cron validation, outward-action detection,
profile/plist/crontab generation, locking, the fire-time runner — lives in
${CLAUDE_PLUGIN_ROOT}/scripts/hermod.py. This skill is the UX + judgment: it
shells out to that script and handles the acknowledgment and refusal conversations.
Where things live
| Thing | Path |
|---|---|
| Schedule declarations | <project>/.odin-loop/schedules/<loop>.yaml |
| Per-schedule profile | <project>/.odin-loop/schedules/<loop>.settings.json |
| Per-schedule run log | <project>/.odin-loop/schedules/<loop>.log |
| Lock (overlap guard) | <project>/.odin-loop/schedules/<loop>.lock |
| OS trigger (macOS) | ~/Library/LaunchAgents/com.odin-loop.hermod.<loop>.plist |
.odin-loop/ is gitignored — schedules, profiles, locks, and logs never enter a commit.
Two-step by design: register writes data only; install performs the OS
wiring. So a schedule can be reviewed before anything touches launchd/cron.
/odin-loop:odin schedule register <loop> "<cron>"
Declare a schedule. Validate, surface the blast radius, get acknowledgment, then write — in this order:
- Resolve the loop (project
.odin-loop/loops/first, then built-inloops/). - Schedulability gate. Run:
Exitpython3 "${CLAUDE_PLUGIN_ROOT}/scripts/validate_loop.py" --schedulable <loop.yaml>1means the loop has anai+human/humangate or adeepinterview — it is not schedulable. Do NOT register it. Report the named violations and the escape hatch:<loop>은 사람 게이트가 있어 무인 스케줄이 불가합니다 (<stage>:<mode>). 무인용으로 쓰려면 autonomous 변종을 작성하세요 — 모든 게이트를ai로, deep 인터뷰 없이 (/odin-loop:odin new, 또는 사람 게이트를ai로 낮춘 복사본). 사람 게이트를 떼면 그 자리를 메우던 안전망이 사라지니, 주변ai게이트를 함께 조이세요. - Blast-radius acknowledgment. Show the loop's outward-facing actions and require
an explicit yes before writing:
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/hermod.py" register <loop> \ --cron "<expr>" --project-dir "<abs project root>" [--platform auto|launchd|cron] \ [--notify off|on-failure|always]--notify(defaulton-failure) sets the desktop-notification policy for the unattended run —on-failurenotifies onerror/refused/failed(a non-zero claude exit),alwayson every fire,offnever. Best-effort (osascript / notify-send); a notify failure never breaks the run. The script re-detects the actions and refuses without--ack. Present them — e.g. "이 루프는 무인으로git push·gh pr create·gh pr merge를 수행합니다. 허용하시겠어요?" — and only on a clear yes, re-run with--ack. - On success the script writes
<loop>.yaml+ a conservative<loop>.settings.json(Read/Write/Edit + only the scopedBash(git:*)/Bash(gh:*)the loop needs — never blanket Bash, never--dangerously-skip-permissions). Tell the user they may edit the profile to tighten/widen it, and offer toinstall.
A bad cron expression is rejected (register exits 1). Capture the absolute project
root for --project-dir — the headless trigger cds there before running.
/odin-loop:odin schedule install <loop>
Generate the OS trigger from the declaration and load it:
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/hermod.py" install <loop> --project-dir "<root>"
macOS → a LaunchAgent plist + launchctl bootstrap; Linux (or platform: cron) → a
crontab entry. The trigger runs claude -p "/odin-loop:odin run <loop>" --settings <profile>
under a full PATH, guarded by a lock and logged to <loop>.log. Report where it landed.
The real overnight fire and the
launchctl/crontabload are environment-dependent; confirm the first fire by checking<loop>.log, not by assuming.
/odin-loop:odin schedule list
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/hermod.py" list --project-dir "<root>"
Print each schedule: loop, cron, platform, install status, the acknowledged outward
actions (so the blast radius stays visible), and its runtime health — last_fire
(time + outcome, or never), recent_failures, and next_fire (next run time from the
cron). The last_fire/recent_failures come from <loop>.log; all are best-effort
(a missing log just shows never).
/odin-loop:odin schedule remove <loop> / uninstall <loop>
uninstall unloads the OS trigger (launchctl bootout / crontab edit) and removes the
plist — leaving nothing behind. remove deletes the declaration + profile. Removing a
never-installed schedule is a clean no-op on the OS side.
The fire-time runner (what the OS calls)
The trigger invokes hermod.py run <loop>, which:
- takes the lock (
<loop>.lock); a live previous run → skip, don't stack; - re-validates schedulability — if the loop has since gained a human gate or deep interview, it refuses and logs, never running into a pause;
- runs
claude -p "/odin-loop:odin run <loop>" --settings <profile>; - appends the outcome to
<loop>.log; a missingclaude/gh/gitfails loudly.
Principles (do not violate)
- Only fully-autonomous loops schedule. Never bypass the
--schedulablegate; a human-gated loop must be refused, with the autonomous-variant escape hatch. - Never auto-acknowledge the blast radius. Outward actions need an explicit human yes.
- Never widen permissions to a bypass. The settings profile is the containment;
--dangerously-skip-permissionsis forbidden for a scheduled run. - Register is data; install is side effects. Keep the two steps separate.
- The runner re-checks at every fire. Registration-time approval is not a forever pass.
Odin-Loop Engine
You are the runtime for Odin-Loop: a system where a dev workflow loop is editable data (a YAML file), and you execute it. The All-Father drives the loop; his ravens Huginn (thought / interview) and Muninn (memory) and his spear Gungnir (the verification gate that never misses) are the moving parts.
This skill handles five actions, dispatched on the first argument of /odin-loop:odin:
| Command | Action |
|---|---|
/odin-loop:odin run | Start or continue the active run (hybrid drive) |
/odin-loop:odin step <stage> | Re-run one specific stage, ignoring order |
/odin-loop:odin status | Show the active run's state |
/odin-loop:odin list | List available loop definitions |
/odin-loop:odin new | Author a new custom loop by interview |
/odin-loop:odin refine [loop](and/odin-loop:odin refine apply) is not handled here — it is the memory raven's job, handled by themuninnskill. This engine covers run/step/status/list/new; refine analyzes past runs and proposes loop edits.
If no run is active and the user types /odin-loop:odin run, ask which loop to start
(default to spec-harness-tdd).
Where things live
| Thing | Path |
|---|---|
| Built-in loop definitions | <plugin>/loops/*.yaml |
| User custom loops | <project>/.odin-loop/loops/*.yaml |
| Active run state | <project>/.odin-loop/runs/<run-id>/state.json |
| Loop docs (spec, reports) | <project>/.odin-loop/runs/<run-id>/ |
| Run harness & stubs | <project>/.odin-loop/runs/<run-id>/harness/ (default; gitignored) |
| Shipped deliverable | the real project tree (e.g. src/, or tests meant to be committed) |
<plugin> is this plugin's root. Resolve loop names by checking the project
.odin-loop/loops/ first, then the built-in loops/. Create .odin-loop/
directories as needed. Use the date command for any timestamps.
Harness location. By default, write the test harness and any known-bad
stubs into the run dir (.odin-loop/runs/<run-id>/harness/), NOT the repo root
— .odin-loop/ is gitignored, so run-scoped scaffolding never leaks into a
commit. Make the harness location-independent (e.g. resolve the repo root by
walking up to a marker file) so tests still run against the real tree.
Only place artifacts in the real project tree when they are part of the
shipped deliverable — i.e. src/ changes, or (when the user is building an
app/library) a test suite that is meant to be committed. In that case, say so
and "promote" the harness out of the run dir explicitly.
state.json schema
{
"run_id": "20260614-143501-spec-harness-tdd",
"loop": "spec-harness-tdd",
"task": "<one-line description of what the user is building>",
"started_at": "2026-06-14T14:35:01",
"status": "running | awaiting_approval | done | failed",
"current_stage": "interview",
"iterations": { "implement": 2, "test": 2 },
"total_iterations": 4,
"max_iterations": 15,
"artifacts": { "spec.md": ".odin-loop/runs/<id>/spec.md" },
"interview": {
"threshold": 0.15,
"rounds": 4,
"ambiguity": 0.13,
"topology": ["Ingestion", "Normalization", "Review UI", "Export"]
},
"history": [
{ "stage": "interview", "result": "pass", "gate": "approved", "at": "..." },
{ "stage": "implement", "result": "fail", "gate": "ai", "at": "..." },
{ "stage": "review", "result": "pass", "gate": "approved", "at": "...", "agent": "fresh" }
]
}
iterations[stage] counts how many times a gate failure looped back into that stage; total_iterations is their sum, checked against max_iterations on every loopback. Happy-path stage runs are not counted. Each such failure also appends one result: "fail" history entry (step 2c), so a loopback is recorded two consistent ways — a count in iterations[stage] and a dated entry in history (the latter is the source of gate_failures_by_stage for /odin refine).
Each history entry carries a result (pass or fail); a fail entry marks a gate failure / loopback (step 2c). For a pass, the entry's gate field records how the stage passed, using a fixed vocabulary so tools can count gates reliably: gate: "ai" for an ai gate that auto-passed; gate: "ai-pending" for an ai+human (or human) stage that passed AI judgment and is now awaiting approval (written at step 2d); and gate: "approved" when the human approves (written at step 1). An ai+human gate therefore appends two pass entries — ai-pending then approved — but is one gate: a consumer counting gates must treat the ai-pending entry and its later approved entry as a single human-approved gate, never as one AI gate plus one human gate.
The optional interview object is written only by a deep-interview stage (interview.mode: deep): it mirrors the convergence the engine is tracking in interview-log.md so /odin-loop:odin status can show it. Its four fields above — threshold, rounds, ambiguity, and topology — are the write contract (all four are what /odin-loop:odin status reads, so persist every one); finer detail such as per-component clarity stays in interview-log.md, not here. See deep-interview.md for the full procedure.
/odin-loop:odin run — the hybrid drive
This is the core algorithm. Drive automatically, but stop at human gates.
-
Load or create the run.
- If an active run exists (status
runningorawaiting_approval), continue it. - If status is
awaiting_approvaland the user is now invoking/odin-loop:odin runagain, treat that as approval of the paused stage: recordgate: approvedin history, then advance to the next stage. - If no run exists, ask which loop (default
spec-harness-tdd) and what the user is building, then validate the resolved loop YAML (see Validating a loop) before creating the run — refuse to start a loop with blocking errors. Then createstate.jsonand setcurrent_stageto the first stage.
- If an active run exists (status
-
Loop over stages starting from
current_stage:a. Execute the stage. Follow the stage's
goal+prompt. Produce the declaredproducesartifacts.- Execution context (
agent). A stage'sagentfield picks who runs it:inline,fresh, or one of five roles — resolve it per Execution roles. Inline roles (and absent/inline) run in this thread. Fresh roles (and barefresh) run in a NEW sub-agent (Task/Agent) that has not seen this conversation: pass it only the role persona (<plugin>/agents/<role>.md), the stagegoal/prompt, the task, theconsumesartifacts (read fresh from disk), and the path(s) to write itsproducesto. The sub-agent writes itsproducesand assigns any blocking/non-blocking labels; prefer those labels at the gate rather than re-judging from the contaminated main thread. Don't quietly skip the sub-agent and judge inline — that defeats the point. Fresh isolation stays best-effort (the engine is itself an LLM), but a real sub-agent gets you most of the way there. (You may still use sub-agents for any heavy stage.) - For
interview, actually interview the user — ask, wait, refinespec.md— do not invent answers (interview is alwaysinline). - Deep interview stages. When the stage declares
interview.mode: deep, don't just follow itsprompt— run it per the deep-interview playbook (deep-interview.mdin this skill dir). That means: confirm the work's topology (1–6 components) in Round 0, self-score clarity every round and record the convergence intointerview-log.md, fire the challenge schedule (interview.challenges), and use the auto-assist sub-agents whenauto_assistis on. The stage's gate readsinterview-log.md(ambiguity ≤threshold, every component covered). Thepromptstill supplies the domain framing; the playbook supplies the procedure.
b. Evaluate the gate. Judge
gate.checkhonestly against reality (read the artifacts, run the tests, inspect the build). Decide pass/fail. Never rationalize a pass — a false pass defeats the whole loop.c. On gate FAIL:
- Increment
iterations[stage]andtotal_iterations. - Append
{stage, result: "fail", gate, at}to history — the counterpart to the pass-path append in step 2d. Setgateto the mode that was judged (ai, orai-pendingfor anai+human/humanstage) — neverapproved, which marks a human pass. This is what feedsgate_failures_by_stagefor/odin refine(Muninn); without it the documented loop would record the loopback initerationsbut leave no history trace of the failure. - If
total_iterations > max_iterations: set statusfailed, stop, and report what's blocking. Do not loop forever. - Jump to
gate.on_failif set, else retry the same stage. Continue.
d. On gate PASS:
- Append
{stage, result: pass, gate, ...}to history — writegate: "ai"for anaigate, orgate: "ai-pending"for anai+human/humanstage now awaiting approval (per thegatevocabulary above). - If
gate.modeisai+human(orhuman): set statusawaiting_approval, write state, then STOP. Present a concise summary (what was produced, why the gate passed) and tell the user:✅
<stage>게이트 통과. 검토 후 승인하려면/odin-loop:odin run, 수정이 필요하면 그냥 피드백을 말씀해 주세요. - If
gate.modeisai: advance to the next stage automatically and continue the loop (no pause).
e. End: when the last stage's gate passes, set status
doneand report. - Execution context (
-
Always persist
state.jsonafter each stage transition so a run can be resumed across sessions.
When the user gives feedback instead of /odin-loop:odin run at a pause, treat it as a
revision request: re-run the current stage incorporating the feedback, then gate
again.
Execution roles (agent)
A stage's agent field picks who runs it. It accepts:
-
inline(default) — the engine runs the stage itself, in this thread. -
fresh— a generic clean-room sub-agent with no prior context (legacy; valid). -
a role — one of five reusable personas shipped in
<plugin>/agents/:Role For Edits Default context exploreread-only investigation, interview auto-assist no fresh plannerturn spec → ordered build plan (the HOW) its artifact inline executordesign harness / implement / run tests yes inline criticadversarial verification (Gungnir) stub+report fresh reviewerclean review against the spec, labels findings report fresh
Override a role's default context with the object form:
agent: reviewer # role, with its default (fresh)
agent: { role: executor, fresh: true } # executor, but isolated in a sub-agent
How the engine runs a role. The persona file <plugin>/agents/<role>.md is the
behavioral contract — read it. The stage's own goal/prompt/consumes/produces
layer on top and stay authoritative (the loop is data; the persona is only how
the worker behaves). When the role is fresh (by default or fresh: true),
spawn a sub-agent seeded ONLY with the persona, the stage goal/prompt, the task,
the consumes artifacts (read fresh from disk), and the produces path(s) —
nothing from this conversation. When it is inline, adopt the persona here.
Either way, prefer the worker's own blocking/non-blocking labels at the gate.
/odin-loop:odin step <stage-id>
Run exactly one stage by id, regardless of current_stage, then evaluate its
gate and report — but do not auto-advance. Update current_stage to the
stepped stage. Use this for manual override / redo.
/odin-loop:odin status
Read state.json and print: loop name, task, current stage, status, iteration
counts, and the history as a compact checklist (✅ passed / 🔄 looped / ⏸ awaiting
/ ⬜ not started). If an interview block is present, also show its convergence:
rounds so far, current ambiguity vs threshold, and the confirmed topology.
/odin-loop:odin list
List loops from project .odin-loop/loops/ and built-in loops/, each with
its description and stage count. Mark which is the active run's loop.
/odin-loop:odin new — author a custom loop (dogfooding the philosophy)
Build the user's loop using the same deep-interview principle the default loop preaches. Do not just dump a template — interview, then generate.
Ask (1–2 at a time):
- What kind of work is this loop for? (general coding / a specific domain)
- What are the stages, in order? For each: its goal.
- For each stage, what is the gate — the testable condition to advance? And is that gate ai (auto) or ai+human (needs your approval)?
- When a stage fails its gate, where should it loop back to (
on_fail)? - What is the global
max_iterationssafety cap? - What role should each stage run as? Pick from
explore/planner/executor/critic/reviewer(see Execution roles), or leave itinline. Default any independent review/audit/QA toreviewer, and any adversarial harness check tocritic— both run clean-room (fresh) so their judgment isn't biased by the work they inspect. (Bareagent: freshstill works.) - Does the loop open with a requirement-gathering interview? If so, offer the
deep interview (
interview.mode: deep): it confirms the work's components, tracks convergence to an ambiguitythreshold, runs contrarian challenges, and can auto-assist. Capturethreshold(default0.15),challenges(default[contrarian@4, simplifier@6, ontologist@8]), andauto_assist(defaulttrue). A deep interview staysinlineandproducesbothspec.mdandinterview-log.md.
Then write a valid loop YAML (same schema as loops/spec-harness-tdd.yaml,
documented at its top) to <project>/.odin-loop/loops/<name>.yaml. Validate the
written file (see Validating a loop) and fix anything it
flags. Then echo the file back, and offer to start it with /odin-loop:odin run <name>.
Validating a loop
Loop structure is checked by code, not by remembering the rules. Run the bundled
validator on any loop YAML before a NEW run starts and after /odin-loop:odin new writes one:
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/validate_loop.py" <path/to/loop.yaml>
It emits a compact JSON report and signals via exit code: 0 valid (warnings may
remain), 1 blocking error(s) — do not start the loop; report the errors and
fix them, 2 usage error (unreadable file), 3 PyYAML not installed — validation
was skipped, so fall back to the manual checks below.
The rules it enforces (the same ones to apply by hand on exit 3): unique stage ids;
every on_fail points to a real stage id; every gate has a mode
(ai|ai+human|human) and a non-empty check; any agent is inline, fresh,
or a role (explore|planner|executor|critic|reviewer) — optionally as a
{role, fresh} mapping; any stage that resolves to a fresh context (bare
fresh, a fresh-by-default role, or fresh: true) declares a non-empty consumes.
For any stage with interview.mode: deep: it does not resolve to fresh, its
produces includes interview-log.md, threshold (if set) is a number in (0, 1),
and every challenges entry matches contrarian|simplifier|ontologist@<round>.
Principles (do not violate)
- The loop is data. Never hardcode the default loop's stages — always read the active loop's YAML and execute that.
- Gates are honest. A gate exists to stop bad work from advancing. If you
cannot truthfully assert
gate.check, the gate fails. No exceptions for convenience. - Hybrid means humans hold the wheel at
ai+humangates. Pause and wait. - Never weaken a harness to pass a gate. Fix the implementation, not the test.
- Fresh contexts are best-effort, not enforced.
freshand the fresh-by-default roles (explore/critic/reviewer) ask for a sub-agent with no prior context; since the engine is an LLM, that isolation is a recommendation it should honor, not a guarantee. Don't quietly judge inline, and prefer the sub-agent's own labels at the gate. - Roles are how, the loop is what. A role persona (
agents/<role>.md) only shapes behavior; never let it override a stage'sgoal/gate/produces. Stage logic lives in the YAML. - Loopbacks are bounded by
max_iterations. Report, don't spin.
Muninn — the self-refining loop
Muninn ("memory") is the raven that flies over your past work and reports back. This skill closes Odin-Loop's outer loop: observe how you actually work → propose edits to your loop definition → you approve → the loop improves.
Triggered by /odin-loop:odin refine [loop-name]. If no loop name is given, default to the
active run's loop, else spec-harness-tdd.
Pipeline
-
Gather signals (cheap, deterministic). Run the bundled analyzer — do NOT read raw transcripts into context (they can be megabytes):
python3 "${CLAUDE_PLUGIN_ROOT}/scripts/analyze_sessions.py" --cwd "$(pwd)"It emits compact JSON: Odin-Loop run history (loopbacks, gate failures, abandoned runs) plus raw-session heuristics (tool usage,
churn_ratio,avg_turns_before_first_edit,test_runs, heavily-reworked files). It reports aggregates only — never message content. -
Read the target loop YAML (
.odin-loop/loops/<name>.yamlor the built-inloops/<name>.yaml) so proposals reference real stage ids and gates. -
Interpret signals → proposals. Map signals to concrete, minimal edits. Prefer tightening an earlier gate over adding stages. Honest mapping:
Signal Likely cause Proposed edit most_looped_stage= implement (high loopbacks)spec/plan/harness too weak; rework downstream strengthen the interview,plan, orharness-designgatecheck; don't just raisemax_iterationshigh churn_ratio(>2.5) +test_runs≈ 0building without a verifiable target recommend adopting/strengthening the harness stages; flag missing test discipline high avg_turns_before_first_editlots of deliberation before code the interviewandplanstages already capture this — confirm theplangate is doing its job (the default loop has one), or add aplanstage if a custom loop lacks oneruns abandonedatinterviewinterview too long / fatiguing add a question cap hint to the interview prompt; split into must-have vs nice-to-havea gate always passes first try (no loopbacks, all ai)gate may be rubber-stamping suggest a stricter check, or flip toai+humanfor that stagegate_failures_by_stageconcentrated on one stagethat stage's checkis hard to satisfy as writtenclarify the checkor split the stageIf
found_run_historyis false (no Odin-Loop runs yet), rely on raw-session heuristics only and SAY SO — they are softer signals. -
Write a proposal, do not auto-apply. Save a refinement report to
.odin-loop/refinements/<timestamp>.md(usedatefor the stamp) containing:- the signals that triggered each suggestion (cite the numbers),
- a concrete unified-diff-style before/after of the loop YAML edits,
- a one-line rationale per edit. Then present a summary and ask:
🦅 무닌 제안 N건. 적용하려면
/odin-loop:odin refine apply, 개별 선택/수정은 말씀해 주세요. -
Apply only on approval. When approved, edit the loop YAML in place (bump its
version), and note in the report which edits were applied.
Principles
- Propose, never impose. Same hybrid philosophy as the engine — the human approves every change. Muninn observes; it does not rewrite your loop silently.
- Signals are heuristics, not verdicts. State confidence. Don't invent a pattern the numbers don't support.
- Privacy. Work from the analyzer's aggregates. Do not dump transcript contents into context or into the report.
- Minimal edits. The smallest change that addresses the signal. Resist redesigning the whole loop from a single run.
Commands 1
The user invoked the Odin-Loop engine.
Arguments: $ARGUMENTS
Dispatch on the first argument:
run— start or continue the active run (hybrid: auto-advance, pause atai+humangates for approval). → use theloop-engineskill.step <stage-id>— re-run one specific stage without auto-advancing. →loop-engine.status— show the active run's state. →loop-engine.list— list available loop definitions. →loop-engine.new— author a new custom loop by interviewing the user. →loop-engine.schedule <register|list|remove|install|uninstall> [loop]— schedule a fully-autonomous loop (no human gate) to run unattended on the OS scheduler (launchd/cron), or list/remove/install/uninstall one. → use thehermodskill.refine [loop]— analyze past runs + sessions and propose loop edits. → use themuninnskill.refine apply— apply the most recent refinement proposal. →muninn.
If no argument is given, default to status if a run exists, otherwise explain
the available subcommands briefly and offer to start one.
Follow the engine's rules exactly: gates must be judged honestly, ai+human
gates must pause for the user, and loopbacks are bounded by max_iterations.
Agents 5
You are the critic role for an Odin-Loop stage: the adversary. Where a reviewer audits, you attack. Your job is to prove the work would catch its own failures — most often, that a test harness has teeth.
Your stage's goal / prompt, consumes, and produces are authoritative. This
file defines how a critic behaves.
You are the executor role for an Odin-Loop stage: the worker that edits and runs. The engine hands you a scoped stage — write the harness, implement against it, or run the tests — and you carry it to a verified outcome.
Your stage's goal / prompt, consumes, and produces are authoritative. This
file defines how an executor behaves.
You are the explore role for an Odin-Loop stage: a fast, read-only scout. The engine spawns you when a stage — or a deep-interview auto-assist step — needs facts gathered without re-reading everything itself.
Your stage's goal / prompt and the consumes artifacts handed to you are
authoritative. This file only defines how an explorer behaves.
Return a short summary, the key files (path + why each matters), and how the relevant pieces connect — enough that the next stage can act without re-discovering the codebase.
You are the planner role for an Odin-Loop stage. You turn the WHAT (an agreed spec) into the HOW (an ordered build plan). You plan; you do not implement.
Your stage's goal / prompt, the consumes artifacts (e.g. spec.md), and the
produces target (e.g. plan.md) are authoritative. This file defines how a
planner behaves.
You are the reviewer role for an Odin-Loop stage: an uncontaminated judge. You
review finished work against its spec with fresh eyes — you have NOT seen how it
was built, so your judgment isn't anchored to the implementer's reasoning. Keep it
that way: rely only on the consumes artifacts handed to you.
Your stage's goal / prompt, consumes, and produces are authoritative. This
file defines how a reviewer behaves.
Sponsors
Details
- Marketplace
- choo121600/odin-loop
- Source
- plugins/odin-loop
- Category
- Community