goal

Solid

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".

AI & Automation 14 stars 0 forks Updated 3 days ago MIT

Install

View on GitHub

Quality Score: 80/100

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

Skill Content

# /goal — autonomous goal loop You prompt yourself a proactive executor: state a GOAL plus how to verify it, and the agent runs check→fix→check on its own, returning ONLY with the finished result. Frees you from sitting at the monitor nudging every step. This instruments four principles (think before code · simplicity · surgical edits · drive through a verifiable target) into a reusable loop. Not a replacement for a heavy decomposing orchestrator — `/goal` is for ONE mid-sized goal. The design phase (goal / verification / control rubrics) is cherry-picked from Looper (ksimback) — the framework wasn't installed, the techniques were. ## When to use - A clear goal with a **verifiable done-criterion**: a bug (test reproduces → green), research (facts verified), content (critic ≥ threshold), audit (findings adversarially checked), refactor (tests + lint green). - NOT for: trivial work (just do it), pure discussion, and ⚠️ NOT for irreversible/production mutations without confirmation (see guards). ## Goal template (fill in BEFORE starting — design phase, don't skip) ``` Goal: <a concrete OUTCOME + the artifact/state that proves completion; NOT "improve X"> Sharpness test: what counts as "done" if two competent agents disagreed? Subjective → measurable proxy. Scope: included <…> / excluded <…> / max depth <…> Context: <path to project/data, symptoms, logs — what to READ, not assume> Checks (typed, programmatic FIRST — see "Verification"): - [programmatic] <test / compile / ...

Details

Author
Sanexxxx777
Repository
Sanexxxx777/curated-claude-code
Created
1 months ago
Last Updated
3 days ago
Language
N/A
License
MIT

Integrates with

Similar Skills

Semantically similar based on skill content — not just same category

Code & Development Listed

goal-verified

Run a goal with an independent verifier — pin the bar before building, build then STOP, verify against the bar with a fresh reviewer and the machine gates, then commit. Use for /goal, build, implement, refactor, redesign tasks where you keep finding bugs the agent didn't point out.

3 Updated yesterday
caiuswang
AI & Automation Solid

goal-builder

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.

0 Updated today
scoobydrew83
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