Skip to content

transcendr/slopware-skills / plugins/coder-loop/skills/coder-loop

coder-loop

Verified

Run the Codex Optimized Development, Evaluation, and Remediation (CODER) Loop with an orchestration-only coordinator, non-overlapping task-family owners, fresh independent reviewers, evidence-scoped remediation, and final coordinator acceptance. Discover and compose optional MSW, Timebox, MSL, and Codex Voice Optimizer companions as the Slopware Dev Stack without making them dependencies. Use in Codex when the user invokes the CODER Loop, asks to divide a complex change into bounded implementation families with independent reviewers, requests multi-agent implementation without overlapping ownership, requires review and repair until every blocking gap is independently rechecked, asks for the CODER tutorial or Slopware Dev Stack, or wants CODER to install or use its companions. Do not trigger for an ordinary single-agent change, a review-only request, or a non-Codex host.

FileKindSize
SKILL.mdskill md12.4 KB
agents/openai.yamlconfig310 B
references/codex.mdmarkdown5.1 KB
references/companions.mdmarkdown7.9 KB
references/postmortem.mdmarkdown2.6 KB
references/review-kernel.mdmarkdown2.6 KB
references/role-contracts.mdmarkdown3.5 KB
references/workflows/tutorial.mdmarkdown5.5 KB

references/workflows/tutorial.md

View on GitHub
# Workflow: CODER Loop tutorial

The tutorial is a named, opt-in onboarding process that teaches the CODER Loop
and Slopware Dev Stack before offering any live demonstration. A tutorial
request asks for explanation, not repository work.

## Invoke the tutorial

Anchors:

> Start the CODER Loop tutorial.

Also activate on a clear ask such as "teach me CODER," "how does the CODER
Loop work," or "show me the development stack." When the user asks only to see
the stack, start at the companion-stack section instead of repeating the core
tour.

Offer the tutorial once when the user appears new to CODER and no loop is in
flight. After a decline or non-selection, continue without repeating the
offer.

## Teaching rules

- Explain before demonstrating. The default tutorial uses no repository,
  project, task, collaboration, or installation tools and changes nothing.
- Treat a named project, repository, task, branch, or change as teaching
  context, not authority to inspect, create, message, edit, test, or delegate.
- Answer directly from the loaded skill and references. Never say "let me
  check" before explaining CODER behavior.
- Teach in short sections. Let the user interrupt, ask for detail, skip ahead,
  or end the tutorial.
- Preserve literal authority. Learning, companion discovery, and hypothetical
  decomposition never authorize a real CODER run.

## Start with the core explanation

The first tutorial response should teach and sell the actual mechanism:

> The CODER Loop turns one development outcome into bounded worker-owned
> changes, independently evaluates every candidate, and sends only
> acceptance-blocking gaps back for remediation. The coordinator accepts the
> integrated result, cleans up temporary tasks, and uses completed evidence to
> improve the next comparable routing decision. It works alone, while MSW,
> Timebox, MSL, and CVO can optimize scope, convergence, communication, and
> voice control. Ask about any part, say continue for the tour, or say show me
> the stack.

Adapt this to established context without dropping the distinctions. Do not
ask for a real implementation request or imply that learning requires a worker.

## Basic tour

When the user asks to continue, teach these concepts in order unless their
question selects one directly:

1. **Outcome and task families.** The coordinator binds the complete candidate
   and proof, then creates only coherent implementation families with one owner
   each.
2. **Independent evaluation.** Every candidate goes to a fresh read-only
   reviewer that did not implement it and receives raw evidence rather than the
   worker's conclusion.
3. **Targeted remediation.** Only findings that leave acceptance unmet or
   unproven become repairs. Changed claims receive fresh review; unrelated
   belonging evidence survives.
4. **Acceptance and authority.** The coordinator accepts the integrated
   candidate. Delegation never authorizes commit, push, publication, merge, or
   deployment.
5. **Cleanup and evolution.** Any temporary top-level fallback tasks are
   archived when their role is terminal. The postmortem may improve one future
   comparable model assignment when repeated accepted evidence supports it.
6. **Slopware Dev Stack.** MSW controls scope, Timebox supplies an authorized
   convergence envelope, MSL shapes the final user report, and CVO supplies
   voice control. Every layer remains optional and independently installable.

After the basic tour, answer questions or offer the advanced topics and an
optional live demonstration.

## Optional live demonstration

Run only the demonstration the user explicitly selects:

- A hypothetical walkthrough decomposes an invented example and changes
  nothing.
- Companion inspection reports active catalog state and changes nothing.
- A real CODER run requires an explicit implementation outcome and the normal
  scope and authority binding.
- Companion installation requires explicit permission for exact plugins.

Naming a real repository or task while learning selects an example, not a live
action. Never spawn a worker, inspect state, or install a plugin until the user
separately asks for that action.

## Advanced tour

Explain each selected topic before offering a demonstration:

1. **Model routing.** Mechanical and reasoning-required work receive the
   minimum capable execution profile. Collaboration subagents normally own
   every internal role. A role that needs inherited working context plus a
   different model or reasoning effort uses `fork_turns: "99"` with both
   settings selected explicitly. Separately authorized top-level tasks remain
   a lifecycle fallback.
2. **Timebox.** One requester-authorized AWT/CGP clock wraps the CODER Loop.
   The CODER coordinator owns it; CVO, workers, and reviewers do not reset or
   independently monitor it.
3. **Voice topology.** CVO routes committed intent to an owning CODER task and
   returns material state. It never becomes the CODER coordinator.
4. **Evidence evolution.** Postmortem routing changes come from repeated
   accepted comparable evidence, never one success or model preference.
5. **Stack setup.** State what is active, available, and optional. With
   permission, install exact companions or provide commands or a setup prompt.

End a requested advanced tour by offering a compact inline cheat sheet with
the relevant anchors:

```text
Use $coder-loop to run this change through the CODER Loop.
Start the CODER Loop tutorial.
Show me the Slopware Dev Stack.
Install MSW, Timebox, MSL, or CVO.
Install the full Slopware Dev Stack.
```
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 468kUpdated Claude CodeCodexUnverifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 319kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 319kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 319kUpdated Claude CodeCodexVerifiedInstall