Skip to content
Back to search

hyper

MarketplaceWorks with Claude CodeGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/omarhafez1--hydra/badge.svg)](/listings/omarhafez1--hydra)

HTML

<a href="/listings/omarhafez1--hydra"><img src="/api/listings/omarhafez1--hydra/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install it from this repository, then run setup once:

/plugin install hyper --marketplace OmarHafez1/Hyper
/hyper:setup

From a shell, the same in two commands: `claude plugin marketplace add OmarHafez1/Hyper`, then `claude plugin install hyper@hyper`.

Setup checks your machine, asks which models you have, researches what each is good at, and writes your use-case file. To try Hyper without the research, copy an example roster and adjust it:

python3 <plugin folder>/scripts/hyper.py init --example claude-only

Install it for one project (`--scope project`) if you want Hyper only there.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 17 lines
  1. {
  2. "name": "hyper",
  3. "owner": {
  4. "name": "OmarHafez1"
  5. },
  6. "metadata": {
  7. "description": "Hyper: the right model and effort for every step, from an idea to a finished branch."
  8. },
  9. "plugins": [
  10. {
  11. "name": "hyper",
  12. "source": "./",
  13. "description": "One job from an idea to a finished branch: ask first, design with EGM, build with Superpowers, and give every step the model and effort that fit it.",
  14. "version": "0.2.1"
  15. }
  16. ]
  17. }
README.md · README · 225 lines
  1. # Hyper
  2. One job from an idea to a finished branch, with every step on the model and effort that fit it.
  3. Hyper is a Claude Code plugin. It does not replace the tools you already use. It puts two of them in order and adds
  4. the one thing none of them has: a table that says which of *your* models does which kind of work.
  5. ```
  6. ASK Hyper the interview: one round of questions, each with a recommended answer
  7. DESIGN Google's EGM the design document, in EGM's template, approved by you once
  8. BUILD Superpowers the plan, test-first builds in parallel, reviews, the finished branch
  9. ROUTE Hyper the size of the job, the record, the model and effort of every agent
  10. ```
  11. ## Why
  12. - **Different work suits different models.** A strong reasoner should write the design. A cheaper, careful model
  13. should build from it. A model from another vendor should review it, because it misses different things.
  14. - **Small work should stay small.** A rename needs no agents. A new subsystem needs a reviewed design. Hyper sizes the
  15. work first and runs only the steps that size needs.
  16. - **Asking first is cheaper than rebuilding.** Nothing is designed or built until you have confirmed, in a written
  17. record, what was understood.
  18. - **Time is spent where it pays.** One reviewer per gate, independent tasks built at once, and per-task reviews only
  19. while the job's own history says they still find something. `hyper time` shows where a job's time went.
  20. ## Requirements
  21. - Claude Code 2.1.271 or later, and Python 3.9 or later on your PATH as `python3`.
  22. - For the full flow: [EGM](https://github.com/google/elephant-goldfish-model) and
  23. [Superpowers](https://github.com/obra/superpowers), both enabled where you use Hyper.
  24. - Recommended: [Matt Pocock's skills](https://github.com/mattpocock/skills), for the `domain-modeling` skill that
  25. writes the words of the domain into a glossary after the interview. They only need to be installed.
  26. - Optional: the Codex command-line tool, when you want a second vendor to review. (The Gemini tool also works, at a
  27. basic level.)
  28. ```
  29. claude plugin marketplace add google/elephant-goldfish-model
  30. claude plugin install egm@egm
  31. claude plugin enable egm@egm
  32. claude plugin install superpowers@claude-plugins-official
  33. claude plugin install mattpocock-skills@claude-plugins-official
  34. ```
  35. ## Install and set up
  36. Install it from this repository, then run setup once:
  37. ```
  38. /plugin install hyper --marketplace OmarHafez1/Hyper
  39. /hyper:setup
  40. ```
  41. From a shell, the same in two commands: `claude plugin marketplace add OmarHafez1/Hyper`, then
  42. `claude plugin install hyper@hyper`.
  43. Setup checks your machine, asks which models you have, researches what each is good at, and writes your use-case
  44. file. To try Hyper without the research, copy an example roster and adjust it:
  45. ```
  46. python3 <plugin folder>/scripts/hyper.py init --example claude-only
  47. ```
  48. Install it for one project (`--scope project`) if you want Hyper only there.
  49. ## Install the Codex skill
  50. Run these commands at the root of a clone of this repository.
  51. ```sh
  52. skill_dir="${CODEX_HOME:-$HOME/.codex}/skills/hyper"
  53. mkdir -p "$skill_dir"
  54. cp codex/skills/hyper/SKILL.md "$skill_dir/SKILL.md"
  55. ln -s "$PWD/scripts/hyper.py" "$skill_dir/hyper.py"
  56. ```
  57. Use `$hyper <idea>` or `$hyper resume` in Codex. Both hosts use the same model settings and jobs.
  58. ## Upgrading from Hydra
  59. Install the new plugin ID, then disable the previous plugin in Claude Code so its hooks run only once.
  60. Hyper uses existing settings and jobs in place. When an old data directory exists alone, Hyper links
  61. the new name to it so saved paths, Git worktrees and concurrent sessions keep using the same files.
  62. On filesystems that cannot create symlinks it reads the old directory directly. `HYPER_HOME` and
  63. `HYPER_OFF` take precedence over the previous environment variable names.
  64. ## Use
  65. ```
  66. /hyper:feature <idea> the whole flow, from the first question to the finished branch
  67. /hyper:feature build <design.md> the design exists and is reviewed: plan and build it
  68. /hyper:feature resume continue a job in a later session
  69. /hyper:setup refresh your models changed
  70. ```
  71. Two skills also work by themselves, without the flow: `hyper:asking-first` runs whenever you ask for something new, and
  72. `hyper:routing` gives the model and effort for any single agent.
  73. ## How it decides
  74. Three inputs, three settings:
  75. | Input | Setting |
  76. | --- | --- |
  77. | The kind of work (the *seat*) | which model |
  78. | How hard the step is (the *level*: easy, normal, hard) | how much effort |
  79. | How big the job is (the *lane*) | which steps run |
  80. **Lanes.** The ask-first step looks for four facts: the work is costly to undo, it is wide, its requirements conflict,
  81. or it touches a risk path (money, authentication, user data, concurrency).
  82. | Lane | When | Steps |
  83. | --- | --- | --- |
  84. | trivial | a mechanical edit, none of the four facts, at most 2 files | just do it |
  85. | small | none of the four facts, and new work of at most 5 files (or a larger mechanical edit) | ask, plan, build, final review, close |
  86. | feature | one or two facts, or new work of more than 5 files | adds a design document (approved once) and one review of the design and the plan together |
  87. | critical | three or more facts, or costly to undo on a risk path | the same steps at harder efforts, with a second reviewer from another vendor at the final review |
  88. A concept review (EGM's brainstorm lenses, before any design) runs only when you ask for one. In any lane, work on a
  89. risk path gets a security checklist in the final review, and the final review also lists where the code differs
  90. from the design.
  91. **Builds.** Up to `max_parallel` plan tasks (default 3) build at once, each in its own git worktree, when their
  92. dependencies are merged and their files do not overlap. Easy tasks get no review of their own; hard tasks always do;
  93. normal tasks are reviewed until `trust_after_clean` reviews in a row (default 2) came back clean, and again as soon as
  94. one finds a Critical or Important problem. The final review always runs. Every builder and reviewer writes its full
  95. report to a file and replies in at most 10 lines.
  96. **Roles.** The table inside the plugin never names a model. It names five roles, and setup binds each to one of your
  97. models:
  98. | Role | Does | Chosen for |
  99. | --- | --- | --- |
  100. | designer | architecture, the design document, hard plans | strength; nothing later catches a design miss cheaply |
  101. | builder | code, tests, fixes, ordinary plans | build quality for its cost |
  102. | critic | the first review of everything | being different from the builder: another vendor when you have one |
  103. | second | a second review, only beside a critic from another vendor | low cost |
  104. | scout | search, fetches, mechanical edits | lowest cost |
  105. **Effort.** Each model has three efforts: a floor, a normal one, and a hard one. Hyper never asks for an effort
  106. below a model's floor. Search and
  107. mechanical work, and builds whose code is already given, run at the floor. A step runs at the hard effort when it is
  108. hard by the facts, when it is the last gate before the work is finished, or when it is a redo after a miss. The rest
  109. runs at normal.
  110. ## Your files
  111. Everything about you lives outside the plugin, in `~/.config/hyper` (or `$XDG_CONFIG_HOME/hyper`, or `$HYPER_HOME`).
  112. `hyper doctor` prints the folder.
  113. | File | What it is |
  114. | --- | --- |
  115. | `models.json` | your models, the role each plays, each model's three efforts |
  116. | `USE-CASES.md` | the same as a readable page: who does what and why |
  117. | `evidence/` | what the choices rest on, each claim with its source, date and confidence |
  118. | `settings.json` | your changes: a role, an effort, a single cell of the table, a setting |
  119. | `ledger.jsonl` | one row for every agent Hyper checked |
  120. Each project keeps its own in `.hyper/`: the review bar (`bar.md`), an optional `settings.json` that wins over yours,
  121. and one folder per job with its record, its state and EGM's working files. Hyper writes a `.hyper/.gitignore` that
  122. keeps the job folders out of git; the bar and the project settings are yours to commit.
  123. Useful commands (`hyper` means `python3 <plugin folder>/scripts/hyper.py`):
  124. ```
  125. hyper pick build --level hard which model and effort for this work
  126. hyper model off <id> a model hit its limit; its stand-in runs
  127. hyper config set fix_round_cap 3 fix rounds per task before what is left is settled
  128. hyper config set max_parallel 2 plan tasks built at once
  129. hyper job list the jobs of this project and where each stands
  130. hyper time <job> where a job's time and tokens went, per step and per seat
  131. hyper gate normal --task 3 whether a task gets its own review (the build loop runs it)
  132. hyper ledger --summary what ran, on which model
  133. hyper doctor what is installed, what is missing
  134. ```
  135. ## What it changes in the other tools
  136. Nothing in their files. Where their rules meet, Hyper chooses as follows, and says so in `docs/DESIGN.md`:
  137. - The interview happens once, in the ask-first step, and it is written down by Hyper. Superpowers' brainstorming is
  138. not run again. EGM still asks about design decisions the record leaves open.
  139. - The design is written in EGM's template in one pass and approved by you once, without egm-draft's section-by-section
  140. gates. EGM's staged review is replaced by one review of the design and the plan together; EGM's brainstorm lenses
  141. run only for a concept review you ask for.
  142. - Superpowers' advice on which model to use is replaced by the table. Its build runs several tasks at once in
  143. worktrees, and its implementers and reviewers read its own prompt templates. Its fix loop keeps its rules, with a
  144. lower cap on rounds (default 1; `fix_round_cap` 5 gives its own length), and a fix is re-reviewed only when it
  145. answers a Critical finding.
  146. - The approved design is committed, the build's branch carries it, and decisions made during the build are written
  147. back into it. The final review lists where the code differs from the design, and you decide each difference.
  148. - A decision the build made that you reject sends the code back to be fixed.
  149. How a job ends is yours to choose in Superpowers' last step: merge, pull request, or keep the branch.
  150. ## Turning it off
  151. `touch .hyper/off` in a project stops Hyper's session note there. `HYPER_OFF=1` does the same for one session. The
  152. hook only checks agents in a session that is running a Hyper job, or agents whose prompt starts with a Hyper tag; it
  153. is silent everywhere else, and it never stops a session when something goes wrong inside it. It checks the model of
  154. every such agent, and the effort whenever Claude Code reports it.
  155. ## Version 0.2
  156. 0.2.0 is the speed pass: fewer steps (a critical job has 8 instead of 15), one reviewer per gate, parallel builds,
  157. per-task reviews that adapt to the job's quality, short replies, and `hyper time`. Jobs started under 0.1 keep
  158. working: a step done under an old name counts under its new one (`approve` as `design`, `plan_check` as `review`,
  159. `finish` as `close`), and a settings override of a removed seat is ignored with a warning from `hyper validate`.
  160. Not here yet: a calibration run that measures your models on planted defects, a script that proposes table changes
  161. from the ledger, automatic reading of usage meters, a saved account of a half-finished interview, and the final
  162. result of a background agent in the log. Windows support is partial: the hooks need a `python3` command, and two
  163. commands at once are not protected by file locks there. The Gemini tool is supported at a basic level.
  164. The 0.2.0 lanes have not yet carried a real feature from start to finish. Treat the first job as a trial.
  165. Known limits. Hyper is built for one user, one project and one job at a time, with the design inside the
  166. repository. It has not been hardened for: job folders that are symbolic links, job files edited by hand, a design
  167. kept in a worktree of another branch than the one being built, and several sessions driving one job at the same
  168. moment (a second session is refused, not merged).
  169. ## Credits
  170. Hyper drives, and does not copy, [EGM](https://github.com/google/elephant-goldfish-model) (Google, Apache-2.0),
  171. [Superpowers](https://github.com/obra/superpowers) (Jesse Vincent, MIT) and
  172. [Matt Pocock's skills](https://github.com/mattpocock/skills) (MIT). Hyper itself is MIT licensed.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.