supergoal: the paste is unavoidable, so the goal is a condition rather than a script
Plan and autonomously build a software task end-to-end. One ready-to-paste /goal, adaptive phase count, memory preload + writeback, 3-strike self-healing recovery.
At a glance
- What is it?
- supergoal is an agent skill that turns a one-line request into a multi-phase autonomous build: it recons the codebase, loads your saved preferences, derives a phase count from the task, writes a specification per phase, runs its own pre-flight smoke check, and then hands you a single command to paste. Two design decisions are worth stealing whatever you think of the result, which are running the mandatory commands once before dispatch and counting debug output across the whole working tree including untracked files.
- Who is it for?
- Reach for this when the work is well enough understood that you would only be approving a plan and then watching, because that is exactly the loop it removes, and when the task is large enough that a phase specification on disk beats a long prompt you would have to re-send every turn. Do not reach for it when you need to steer mid-run, because the appeal of the design is that steering is not available until a phase fails three times and hands off.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 89 days ago.
- What is it written in?
- Mainly Shell, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- robzilla1738/supergoal686 ★ · +10
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| robzilla1738/supergoal | 676 | 686 |
10 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The paste cannot be automated, and the readme admits it
The interaction contract is two human touches: one approval and one paste. After that the run is autonomous, phase by phase, with built-in retry, spec recovery and a memory written at each phase boundary, until a completion sentinel appears in the output. The second touch is not laziness in the design, it is a platform fact, and the readme states it plainly: slash commands only fire from user input, so an agent cannot invoke its own command. The planner prepares the line and a human pastes it. Calling that an honest handoff rather than a clever one is the right characterisation, and it is worth checking whether the tool you are evaluating has quietly worked around the same constraint or simply ignored it. The more interesting decision is what goes in that line. On both supported hosts, the goal command takes a short end-state condition that an evaluator checks against the transcript after each turn, not a long task body. So one goal can drive a whole multi-phase run because the phase detail is not in the command at all: it lives in files the agent reads from disk as the run progresses. No character budget to exceed, no chain of sessions to stitch, no long prompt to re-send. That is the mechanism that makes a single paste plausible, and it is the part you would have to rebuild yourself if you wanted the same behaviour with a different tool.
The phase count is derived, and the readme gives both ends of the range
Decomposition happens before any code exists, and the count is a function of the task rather than a setting. The readme gives the two ends of the range: a small change gets two phases, and a full-stack project built from nothing gets eight to twelve or more, with no upper cap. That is a better default than most planning tools, which pick a number and then distribute work into it, because the failure mode of the fixed number is predictable. Eight phases for a two-file fix produces ceremony, and two phases for a new service produces a plan that cannot be checked. The comparison diagram makes the other half of the argument, and it is about turns rather than plan quality. The traditional loop is: ask for a plan, receive it, execute step one, re-prompt, execute step two, re-prompt, and so on until done, across many turns. Here it is one request, one approval, one paste. The readme also claims the plan itself is deeper than a one-shot plan, and the argument is specific rather than rhetorical: recon, a risk list, phase shaping informed by memory, and validated specifications all happen before you see anything. That claim has a cost attached to it, and it is worth naming. You are paying for six stages of planning before the first line of code exists, so a two-phase task pays that tax too. Whether that is worth it depends on how expensive your own re-prompting is.
Greenfield gets a checklist, brownfield gets two questions
The intake stage branches on the first question it asks itself: is there a codebase to scan. If there is not, the skill walks a full category checklist covering platform, stack, design direction, integrations, scope, audience, performance and data model, and it does that in batches of up to four questions at a time until every gap that matters has been filled. If there is a codebase, it asks zero to two questions and only for gaps that recon genuinely cannot answer. That branch is the right shape, because the question budget should be a function of what is already knowable, and the readme is explicit that recon answers most of the brownfield cases. Two details are worth copying. The batching of four is a deliberate compromise: it keeps the interrogation moving without asking a user to answer twenty questions in a row. And the word the readme uses for a gap worth asking about is a material one, which is a useful filter. It means the checklist is not a formality you must complete before any work starts, since questions about details that will not change the work are skipped. The cost sits entirely in the greenfield path, where a project starting from an empty directory gets a long interview before it gets a plan, and where the quality of the result depends heavily on how well you answer.
One self-critique pass, and you see the corrected plan rather than the objections
Before the plan is shown, the planner runs exactly one self-critique pass over it, looking for three specific things: criteria that cannot be checked, phases that were sliced in the wrong place, and dependencies that are too weak. Where it finds a criterion that cannot be falsified, it rewrites it in place rather than listing it. The user therefore sees the post-critique version of the plan, never the draft with comments attached. That is a real design choice and it has a real cost. You cannot review what the critic objected to, only whether you agree with its correction, so your ability to catch a bad rewrite is limited to your own reading of the corrected text. And one pass is a bound rather than a loop: the critique cannot find problems introduced by its own corrections, because nothing runs a second time. After the critique the plan is presented with its assumptions, its risks, the memories that were applied, and a revision menu with four concrete options rather than a yes or no: start now, adjust an assumption, tweak a phase, or restructure the phases. That menu is the actual contract of the approval step, and offering four specific shapes of disagreement is better than inviting general comments, because the skill can act on all four and on none of a vague note.
Pre-flight exists so three retries are not spent on a baseline that was already broken
This is the most interesting piece of engineering in the readme, and it exists to prevent one specific failure. After the approval and immediately before the goal line is printed, the planner runs the deduplicated mandatory commands once. If they pass, it proceeds. If they fail, it does not refuse: it re-shows the plan with an option to skip the pre-flight and dispatch anyway, and the reason it offers that option is precise. Sometimes the baseline being broken is exactly what the first phase is meant to fix, and in that case failing fast is wrong. What the check prevents is the alternative. Without it, the autonomous run starts, the first phase fails for a reason that has nothing to do with the first phase, and the three-strike recovery loop spends all three attempts against a condition that was true before the run began. The run then hands off having produced nothing and having told you nothing it did not already know. Deduplication matters here too: the same mandatory command appearing in three phase specifications is one run, not three, so the pre-flight does not itself become a slow thing. The check is also what makes the retry loop a recovery mechanism rather than a delay mechanism, which is a distinction most autonomous workflows never get to.
Cleanliness is counted across the working tree, including files you never committed
Each phase verification carries a cleanliness pass on top of whatever else it checks. It counts, with plain text search, three things that a phase should not have introduced: debug print statements, leftover to-do markers, and dead imports. The part that matters is where it looks. The readme is explicit that the counts cover the phase's complete set of working-tree changes, which means committed files, staged files, unstaged edits and untracked files alike, gathered by a script in the repository. A check that only inspected committed work would miss exactly the state you are trying to catch, because debug output accumulates in the middle of a phase and gets cleaned up, or does not, before anything is committed. Counting untracked files is what closes that gap, and it is a small idea with a large effect on whether a check is worth running. Non-zero counts feed into the same three-strike mechanism, so a phase that leaves debug output behind gets retried rather than passed. The escape hatch is a specification-level setting: if a phase legitimately needs debug output, the specification says so and the allowance applies. Related to that is the baseline capture, where the current commit is written into the run's state file so the final audit can diff what was delivered against the tree as it stood before the run began.
Two hosts, two install paths, and an SSH key footgun on the short form
Installation is where the two supported hosts diverge. On the first, it is three commands typed inside a session.
/plugin marketplace add https://github.com/robzilla1738/supergoal.git
/plugin install supergoal@supergoal
/reload-pluginsThe readme says this was verified end to end against the live repository, and it gives the cost in tokens, which is the number to check before adding a skill to a session you pay for on every turn: a few hundred always, and about ten thousand when it is invoked. The footgun is worth knowing because the failure message will not explain it. The short form of the marketplace command, which takes just an owner and a repository name, works only if you have GitHub SSH keys configured, because it defaults to cloning over the secure transport. Two specific errors are named as the symptom. If you see either of them, use the full repository URL instead. There is a second documented failure with its own fix: if the install command reports that it cannot find the plugin, update the marketplace and try again, which is what you do after a version bump. The second host has no plugin marketplace at all, so the install is a clone and a copy into its skills directory.
mkdir -p ~/.codex/skills
git clone https://github.com/robzilla1738/supergoal /tmp/supergoal-clone
cp -R /tmp/supergoal-clone/skills/supergoal ~/.codex/skills/
rm -rf /tmp/supergoal-cloneUpdating later means running the same three commands again. The manual path for the first host is identical, which makes it a reasonable fallback for anyone who would rather not use the marketplace flow at all.
Editorial conclusion
Reach for this when the work is well enough understood that you would only be approving a plan and then watching, because that is exactly the loop it removes, and when the task is large enough that a phase specification on disk beats a long prompt you would have to re-send every turn. Do not reach for it when you need to steer mid-run, because the appeal of the design is that steering is not available until a phase fails three times and hands off. Three things to know before you trust a run. The self-critique pass rewrites the plan in place, so you see the corrected version and not the objections that produced it, which means your review is a review of the output rather than of the reasoning. The pre-flight can be skipped deliberately when phase one is meant to fix the broken thing, which is a judgement call you have to make in advance. And the whole thing depends on your agent reading phase files from disk and an evaluator checking a short end-state condition after each turn, so the host has to support both. It installs on two hosts today, one through a plugin marketplace and one by copying files.
Frequently asked questions
What does the supergoal skill do?
It recons your codebase, loads your saved preferences from memory, derives a phase count from the task, writes a specification per phase, and asks for one confirmation. It then prints a single ready-to-paste goal command, and after you paste it the phases run sequentially with retry, spec recovery and a memory written at each phase boundary until a completion sentinel appears.
Why do I have to paste the goal command myself?
Because slash commands only fire from user input, so an agent cannot invoke its own. The planner prepares the line and a human pastes it. The goal itself is a short end-state condition that an evaluator checks after each turn rather than a long task body, so one goal can drive the whole run while the phase detail lives in files on disk.
How many phases will a supergoal task get?
Whatever the task needs, with no fixed cap. The readme gives the range: a small change becomes two phases, and a full-stack project built from nothing becomes eight to twelve or more. The count is derived during decomposition rather than chosen by you.
How do I install supergoal in Claude Code?
Type three commands in a session: add the plugin marketplace from the repository URL, install the plugin, then reload the plugins. The short owner and repository form only works if you have GitHub SSH keys configured, since it clones over that transport by default, so use the full URL if you hit an authentication error.
Does Codex support the plugin install for supergoal?
No. Codex has no plugin marketplace, so the install is a manual clone and copy into its skills directory, and updating later means running the same commands again. The same manual path works for the other host if you would rather skip the marketplace flow.
What is the pre-flight check in supergoal for?
It runs the deduplicated mandatory commands once before the goal line is printed. If they pass, the run proceeds; if they fail, the plan is re-shown with an option to dispatch anyway, for the case where the broken baseline is exactly what the first phase is meant to fix. It exists so the three-strike retry loop is not spent on a failure that predates the run.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/robzilla1738-supergoal)Star history chart for your README
[](https://hysenlabs.com/projects/robzilla1738-supergoal)Was this useful?