goal-builder

Solid

Turn a vague intent into a correct, transcript-verifiable Claude Code /goal condition through a short question-and-answer interview, then (when the pattern recurs) crystallize it into a reusable .claude/commands/ slash command. Use whenever the user wants to write, fix, or improve a /goal command, set a completion condition, "keep Claude working until X", run an unattended/until-it-passes Claude Code session, or says their /goal "just keeps looping" or "stops too early". Trigger even if they don't say "goal" but describe wanting Claude Code to loop on its own until a measurable end state holds. The point is to stop them writing a PROMPT ("clean up my code") when /goal needs a CONDITION ("npm test exits 0, without editing the test file"), and to refuse any goal whose finish line a transcript-reading evaluator can't check. For crafting the single /goal line; to build a full builder/verifier loop package (spec, prompts, harness, CI) use loop-creator.

AI & Automation 0 stars 0 forks Updated today MIT

Install

View on GitHub

Quality Score: 78/100

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

Skill Content

# Goal Builder Helps a user write a Claude Code `/goal` condition that actually works, by interview. The deliverable is a ready-to-run `/goal …` line (and, when the pattern recurs, a reusable `.claude/commands/` command). Read `references/goal-mechanics.md` for how `/goal` works and `references/good-vs-bad-goals.md` for the worked examples. ## The one idea that makes or breaks a goal `/goal` keeps a Claude Code session looping across turns until a **separate evaluator** (a fresh, fast model — not the one doing the work) confirms your condition holds. The evaluator **only reads the transcript**: it does not run commands or open files. So the condition must be something Claude's own *printed output* can prove. That single fact is why people get `/goal` wrong: they write a **prompt** (open-ended, judged by a human) when `/goal` needs a **condition** (resolves to yes/no from the transcript). "Clean up my code" has no checkable finish line, so the loop either churns forever or quietly declares victory. "`npm test` exits 0" works, because Claude runs it and the result lands in the transcript for the evaluator to read. A durable condition (per Anthropic's docs) has three parts, and is bounded: 1. **A measurable end state** — a test result, a build exit code, a file count, an empty queue. 2. **A stated check** — how Claude should prove it (`npm test` exits 0, `git status` is clean). 3. **Constraints that must hold** — what must not change on the way there (and what would count ...

Details

Author
scoobydrew83
Repository
scoobydrew83/skills
Created
1 months ago
Last Updated
today
Language
Python
License
MIT

Integrates with

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 3 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 today
adamlinscott
AI & Automation Featured

craft-goal

Compile or lint a persistent Mayor-style goal that ratchets a bead graph through bounded RPI experiments toward one larger outcome. Triggers: "craft a goal prompt", "turn this into a goal", "create a bounded goal", "lint this goal", "is this goal safe".

414 Updated today
boshu2