goal-loop

Solid

Manual-only long improvement campaign run by Claude + Codex as a pair. Use only when the user explicitly invokes goal-loop and supplies one target plus what 'better' means; the agents repeatedly test, improve, ship PRs, and require current evidence plus peer acceptance to stop.

AI & Automation 3 stars 0 forks Updated today MIT

Install

View on GitHub

Quality Score: 82/100

Stars 20%
20
Recency 20%
100
Frontmatter 20%
70
Documentation 15%
100
Issue Health 10%
80
License 10%
100
Description 5%
100

Skill Content

# Goal Loop A reusable, goal-driven improvement loop. The human runs `/goal-loop <target> <intent>` to name **one thing to improve** and what "better" means; the two agents (Claude + Codex) **plan and set the goal themselves**, break the target into testable stories, validate them with real execution, improve whatever the goal covers (correctness, behavior, performance, UX, polish), and ship autonomous PRs — looping until the goal's quality bar and the peer both pass. Design is one possible dimension, not the focus: route UI work through `impeccable` only when the goal touches the interface. The human never hand-authors a `/goal` prompt. The skill owns goal generation: it synthesizes a Scope Contract from the human's target/intent, then a **Goal Block** whose first token is literally `/goal ` when handed to Codex's goal loop. ## Roles - The agent the human invokes is the **coordinator-writer**. It owns the planning files and applies code changes. - The other agent is the **peer**: adversarial review + runtime validation. It writes code only under a recorded **lease** (see Leases). - **Both agents test in parallel**, partitioned by area, each on its own browser / computer-use session. - Subagents inherit the role of the agent that spawned them and the same skill-reading requirement. Default invocation is in the **Claude pane** (Claude = coordinator). The skill works either way; the only asymmetry is the Codex goal kickoff (below). ## Required reading (every agent...

Details

Author
hcaiano
Repository
hcaiano/skills
Created
2 months ago
Last Updated
today
Language
JavaScript
License
MIT

Similar Skills

Semantically similar based on skill content — not just same category

AI & Automation Solid

goal

Autonomous goal loop — give it ONE goal plus how to verify it, the agent runs check→fix→check itself and comes back only with the finished result (code with audit, research with fact-check, content with critique, audit/backtest). Self-verification instead of constant supervision, with hard safety guards. Vary the loop with a verification rubric designed before it runs. Triggers — "work autonomously to the result", "don't come back until it's done", "run the loop yourself", "drive it to done".

14 Updated 2 days ago
Sanexxxx777
AI & Automation Listed

goal-workflow

Run a settled implementation goal as a bounded autonomous build loop — lock the goal from the conversation and any docs written this session, front-load every decision, map the terrain, write a completion-invariant contract before any code, then loop (building with explicit Agent-tool fan-out, committing at intervals, verifying at milestones with fresh-eyes against the contract) until the invariants hold, and close out. Gated on a `--confirm` flag asserting the user has manually set ultracode effort and auto-accept mode (a skill can set neither); without the flag it stops, gives the setup steps, and offers two paths — a managed `--confirm` run, or a copy-pasteable `/goal` command that hands the work to native goal + workflow orchestration. An optional `--commit` flag (default off) enables commit-at-intervals and push-at-milestones in both the managed run and the generated command; without it, nothing is committed. Use when a plan is settled and you want Claude to implement it end-to-end on its own — typically

3 Updated 3 days ago
adamlinscott
AI & Automation Solid

auto-loop

Drive a Claude Code session toward a verifiable goal until done or a hard cap fires - autonomous loop, no user intervention. Use for refactor batches, test-coverage runs, migration loops where success is a check command (tests, lint, custom predicate) plus a fresh-context audit. Hosts the loop intra-session via Stop hook with two-vote completion gate; supports optional Codex /goal delegation.

2 Updated today
vanducng