loop-spec
Skill2 starsChanged 4 months agoMITView on GitHub
Execute the per-wave implementation loop: implement against spec one TASK at a time, run checks/tests, fix failures, record local TASK proof — then stop for human wave-acceptance. Writes Wave-Execution artifact and one stage-level commit_workspace Forge package after the wave is green. Never commits/pushes. Use during active wave development. Does not run ground-spec or learning-extract.
2 other projects use a version of this.
Adopted by
Most recently taken up by
- VioletScar-Hui/Build_Great_Looptheir own version, first seen Oct 9, 2026
- getlago/lago-fronttheir own version, first seen Oct 8, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- getlago/lago-front★ 163same name
- VioletScar-Hui/Build_Great_Loop★ 2same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository22 other files it gives its agents.
- ground-specSkill
- initiative-feasibilitySkill
- learning-extractSkill
- pre-implementSkill
- purge-initiative-artifacts-appSkill
- spec-draftSkill
- spec-implementation-planSkill
- spec-technical-reviewSkill
- ensure-repo-graphSkill
- post-product-questionsSkill
- prd-codebase-mapSkill
- review-product-questionsSkill
- commit-workspaceSkill
- create-board-ticketsSkill
- open-draft-prSkill
- prd-impact-mapSkill
- prd-qualitySkill
- prd-thinkSkill
- purge-initiative-artifacts-metaSkill
- review-findingsSkill
- update-documentsSkill
- validate-requirementsSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
13 rules. About 0 are common, 4 are distinctive, and 9 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈4
Distinctive · estimate
This author's own choices. Worth a look.
9
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 54
After each TASK, run {check_command} and {test_command} from the harness profile (or tests_readme) — check/unit layers only.
- Very specific: line 63
When all TASKs are green: write Wave-Execution-{INIT}-W{N}.md, emit completed TASK-* IDs/evidence (observed commands + results), fill …
- Distinctive: line 70
Do not skip check/test steps to save time.
- Very specific: line 91
Do not run human live verification or grounding.
- Very specific: line 114
Run {check_command} — zero warnings/errors required.
- Very specific: line 115
Run {test_command} — all tests pass required.
- Very specific: line 116
If any failure: fix and repeat from step 3.
- Distinctive: line 118
When TASK is green: record local completion/proof in Wave-Execution / handoff (actual commands + evidence, files touched, exit criteria …
- Distinctive: line 122
After all TASKs are green:
- Very specific: line 123
Write {reports_dir}/Wave-Execution-{INIT}-W{N}.md listing completed TASK-* ids and observed evidence (not mutated intent).
- Distinctive: line 168
All wave TASKs complete with local proof recorded
- Very specific: line 206
When the invocation binds handoff_path (orchestrator / AgentRunner baton), also overwrite that path with the same handoff: envelope before …
- Very specific: line 211
Follow prayog-skills/references/forge-side-effects.md#content-producers when this stage's pin has forge.commit_workspace other than …
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Loop spec
Execute the per-wave Pass-1 loop:
implement TASK → check/test → fix → record local proof → repeat
→ write Wave-Execution + Forge commit_workspace readiness
→ stop at wave-acceptance (human prove + patch tip)Closeout (/learning-extract → /ground-spec) is a separate Pass-2 after
human wave-acceptance — not this skill's job.
Content skills write locally and emit Forge readiness; they do not commit, push, branch, open PRs, label, create issues, or merge.
Conventions: prayog-skills/references/id-conventions.md,
prayog-skills/references/artifact-write-contract.md.
Canonical artifact after the wave is green:
{reports_dir}/Wave-Execution-{INIT}-W{N}.md.
NON-NEGOTIABLE
- Implement against the product spec only — do not implement scope from the next wave.
- Prerequisites — run only after
/pre-implementproduced a checklist with gate verdict PASS on the current wave. Do not run on an open Draft spec PR branch (chore/*-spec-*). The implementation plan must exist ondevelop(spec package merged withspec-lgtmon merge head). Wave head is bound by Forge/human context. Canonical §9 WorkManifest (prayog/v1) must already have passed contract validation at pre-implement. - Consume WorkManifest tasks — execute
TASK-*for this wave in dependency order (depends_onDAG within the wave). Remain within each TASK's declaredfiles[]path/action scope. Do not mutate the approved WorkManifest intent (no rewriting exit criteria, deps, or live contract in §9). Persist actual command/evidence results only inWave-Execution-{INIT}-W{N}.mdand the stage handoff. - After each TASK, run
{check_command}and{test_command}from the harness profile (ortests_readme) — check/unit layers only. Both must pass before recording the TASK complete. Implement co-shipped live FILE TASKs (scripts underlive_verify_dirand fixture packs underfixtures_dir) when the plan/manifest includes them — deliver stimulus + probes perlive-fixture-contract.md; do not execute live verify,verify_all, or{verify_command}as this skill's success bar, and never claim human smoke/sandbox success or opaque look-at pass. - Fix failures before moving to the next TASK — do not accumulate failures.
- When all TASKs are green: write
Wave-Execution-{INIT}-W{N}.md, emit completedTASK-*IDs/evidence (observed commands + results), fillcommit_workspacereadiness and completehandoff.forgefor nextwave-pr-action(open_draft_prrequires). Do not run/ground-specor/learning-extractin this hop. Do not self-approve the wave. Handoff MUST list human prove:{verify_command}, coveredCAP-*/J-*, fixture paths, and anyhuman_observationslook-ats. - Do not skip check/test steps to save time.
- Bind execution — each iteration names
TASK-W{n}-{nn}, the wave board issue URL/number, andimplements: [REQ-…]from the WorkManifest (board body is projection only). - Structured failures — on check/test failure, record under handoff
blockerstheTASK-*id plus command and short why; prepare optional issue-comment Forge readiness when tooling is authorized elsewhere. Do not advance while any TASK blocker remains. - Never commit or push inside this skill — not per TASK and not at wave
end. ForgeClient or
/commit-workspacepublishes the workspace tree to the bound wave head after this hop when the pin requires it.
Outcome selection
| Outcome | When |
pass | All wave TASKs green; Wave-Execution-* written; commit_workspace readiness filled; handoff.forge complete for wave-pr-action (title, body_path, head_ref, base_ref); handoff lists human prove (verify_command, CAP/J, fixtures, look-ats) |
findings | Check/test failure on a TASK that needs further local fix (keep TASK-* in blockers) |
blocked | Prerequisites fail or an authoritative gate prevents progress (e.g. missing pre-implement PASS, unbound wave head) |
failed | Execution error running commands or writing the execution artifact |
Do not run human live verification or grounding. Do not emit skipped.
Happy path: pass → wave-pr-action → (after authorize) wave-acceptance.
Inputs
- Wave slice — plan §9 WorkManifest (
prayog/v1) for W{N}: tasks withdepends_on,files[],implementsREQ-*, exit proof, and waveverification(check/unit/live intent) - Board wave issue — URL/number from board seed / pre-implement checklist (projection of manifest — not a second authority)
- Pre-implement checklist —
{reports_dir}/Pre-Implement-{INIT}-W{N}.md {check_command}— static checks (from harness profile orAGENTS.md){test_command}— unit verification (from harness profile ortests_readme){verify_command}— human live script entry (underlive_verify_dir); document on handoff; never run as exit criteria of this skill
Loop body (each TASK iteration)
- Announce current binding:
TASK-*, wave issue,REQ-*implements, file scope, done-when / exit proof expected (from WorkManifest). - Implement or fix the current TASK against the spec only — stay inside
declared
files[]scope. - Run
{check_command}— zero warnings/errors required. - Run
{test_command}— all tests pass required. - If any failure: fix and repeat from step 3; keep
TASK-*inblockerswith{command, expected, actual/summary}until green. - When TASK is green: record local completion/proof in Wave-Execution / handoff (actual commands + evidence, files touched, exit criteria met); clear that blocker; move to the next dependency-ready TASK. Do not commit. Do not edit the approved WorkManifest.
- After all TASKs are green:
- Write
{reports_dir}/Wave-Execution-{INIT}-W{N}.mdlisting completedTASK-*ids and observed evidence (not mutated intent). - Fill
handoff.forgefor stage-levelcommit_workspace(code onhead_ref) and for nextwave-pr-action/open_draft_pr(title,body_path,head_ref,base_ref). ForgeClient applies commit after this hop, then opens the Draft PR onwave-pr-action(authorization: automated— no interactive STOP when requires complete). - Hand off with
pass→ pin nextwave-pr-action. Handoff MUST include{verify_command}for the human. Do not run live verify /verify_allas this skill's success, and do not claim smoke/sandbox human success.
- Write
Wave-Execution artifact (minimum)
# Wave execution — {INIT} W{N}
| Field | Value |
|-------|-------|
| Initiative | {INIT} |
| Wave | W{N} |
| Wave head context | Bound by Forge/human: `{ref}` |
| WorkManifest source | plan §9 (immutable intent — not mutated) |
| Outcome | pass / findings / blocked / failed |
## Completed TASKS
| TASK | Implements | Declared files | Proof expected (manifest) | Observed (command / evidence) | Status |
|------|------------|----------------|---------------------------|-------------------------------|--------|
| TASK-W{N}-01 | REQ-… | path… | exit.proof.expected | `{check}` / `{test}` + paths | green |
## Live verify (human — not claimed here)
- Planned script: `{verify_command}` under `live_verify_dir`
- Prove rungs: `CAP-*` / `J-*` from manifest `covers`
- Fixtures: paths under `fixtures_dir`
- Look-ats: `human_observations` (if any) — human completes; ack = `wave-accepted`
- Agent created planned FILE + fixtures: yes/no — **did not** run smoke/sandbox or claim look-at success
## Forge readiness
- After this hop: `commit_workspace` (code on bound `head_ref`)
- Next external-action: `open_draft_pr` / `wave-pr-action`
- title / body_path / head_ref / base_refStop conditions
- All wave TASKs complete with local proof recorded
{check_command}exits 0{test_command}exits 0Wave-Execution-*written;commit_workspace+wave-pr-actionforge readiness filled- Handoff
passtowardwave-pr-action
Chain position
Illustrative only — transitions SSOT: pinned root workflow.yaml
(dispatch: orchestrated on this node).
/pre-implement (checklist PASS) → Forge commit_workspace (checklist)
↓
/loop-spec ← YOU ARE HERE
bind WorkManifest TASK + wave issue → implement in file scope
→ check/unit only → fix → record observed proof (do not mutate manifest)
failures: handoff blockers (TASK-*, why); no commits
↓
checks/tests green → Wave-Execution-* + commit_workspace + wave-pr readiness
↓
wave-pr-action (Forge open_draft_pr) → wave-acceptance (human on Draft PR)
↓ (Pass-2 Enter-at or /learning-extract)
/learning-extract → /ground-spec → wave-signoffUsage with /loop timer (optional)
/loop 15m loop-spec: implement W{N} TASK-* in WorkManifest dependency order,
stay in declared file scope, run {check_command} and {test_command} after each
TASK, record observed proof in Wave-Execution (do not mutate WorkManifest,
do not commit), fix failures before moving on, stop when all TASKs green.Workflow handoff
- Emit the envelope from
prayog-skills/references/handoff-envelope.mdin the final task summary and persist state inWave-Execution-*. Use stageloop-spec. - When the invocation binds
handoff_path(orchestrator / AgentRunner baton), also overwrite that path with the samehandoff:envelope before exit. Leaving the baton empty is a failed stage for automated consumers.artifact.pathremains the workspace skill output, not the baton path. Seeprayog-skills/references/handoff-envelope.md(Orchestrator baton). - Derive
next_candidates,human_checkpoint, andexternal_actionfrom pinned rootworkflow.yamlfor(stage: loop-spec, outcome)perprayog-skills/references/handoff-envelope.md(Derive from pinned workflow). Sethuman_checkpoint: trueonly when the resolved next node'stypeishuman-checkpoint— never because the artifact "should be reviewed." Setexternal_action: truewhen next isexternal-action. - Happy path:
outcome: pass→ nextwave-pr-action(type: external-action,forge.action: open_draft_pr,authorization: automated) →human_checkpoint: false,external_action: true. After this hop Forge appliescommit_workspace: required(code on samehead_ref), then ForgeClient opens the Draft PR without interactive STOP whenhandoff.forgerequires are complete. Fill completehandoff.forgeforopen_draft_prwith pinrequires:title,body_path,head_ref,base_ref. First Draft PR view should already include checklist (from pre-implement publish) + code. - Follow
prayog-skills/references/forge-side-effects.md#content-producerswhen this stage's pin hasforge.commit_workspaceother thandisabledor next is anexternal-actionwithforge.requires— fillhandoff.forge/ recommend the matching/forgeskill; do not treat local CLI as skill success.
Transitions: pinned root workflow.yaml for this stage (SSOT). Human or
agent may run this skill; orchestrators may auto-dispatch when authorized.
Same legality for both invoke paths.
List failed TASK-* (and command/why) under blockers; do not advance while
any remain. signals SHOULD include wave_issue, current_task,
implements, and completed TASK ids. next_candidates never authorize invoke.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

