ultimatepowers

Ultimatepowers

Ultimatepowers is the complete software development methodology from superpowers, extended with K-notation formal verification fused into its review pipeline — composable skills plus the session-start instructions that make your coding agent actually use them. The formal method is digested from the formal-verification-kit (FVK): contracts and proof sketches written in K notation, never an executed toolchain. Formal analysis runs automatically during every code review; you don't ask for it. The UX is otherwise identical to superpowers — same skills, same workflow, no new commands.

⚠️ Do not install ultimatepowers alongside superpowers. Ultimatepowers bundles every superpowers skill under its own namespace. Installing both gives you duplicate SessionStart hooks, two competing bootstraps, and identically-named skills. Uninstall superpowers first.

How it works

It starts the moment you fire up your coding agent. As soon as it sees you're building something, it doesn't jump into writing code. It steps back and asks what you're really trying to do. Once it has teased a spec out of the conversation, it shows it to you in chunks short enough to actually read and digest.

After you sign off on the design, your agent writes an implementation plan clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow — true red/green TDD, YAGNI, DRY. Then, once you say "go", it launches a subagent-driven development process: a fresh subagent per task, each one's work inspected and reviewed before moving forward.

Here is what ultimatepowers changes: every review dispatches two reviewers in parallel — a conventional code reviewer and a formal one. The formal reviewer derives contracts from your plan/spec intent, constructs proof sketches against the changed code, and files findings with concrete counterexample inputs (input → observed vs expected). The evidence persists under docs/ultimatepowers/verification/ in your project, next to your specs and plans.

Because the skills trigger automatically, you don't need to do anything special. Your coding agent just has ultimatepowers.

Installation

Installation differs by harness. If you use more than one, install ultimatepowers separately for each.

The canonical repository URL is https://github.com/fastxyz/ultimatepowers. It appears in this README's install commands, the platform manifests, and .opencode/INSTALL.md; if hosting elsewhere, it is one search-and-replace away.

Claude Code

• Register the marketplace and install:

  /plugin marketplace add fastxyz/ultimatepowers
  /plugin install ultimatepowers@ultimatepowers-dev
  

• Or from a local clone:

  /plugin marketplace add /path/to/ultimatepowers
  /plugin install ultimatepowers@ultimatepowers-dev
  

• Or for testing without installing:

  claude --plugin-dir /path/to/ultimatepowers
  

Codex CLI / Codex App

Install from a local clone via the plugins interface. The skills manifest is at .codex-plugin/plugin.json.

Cursor

Point the plugin system at the repo: the manifest is .cursor-plugin/plugin.json, and hooks load via hooks/hooks-cursor.json.

Gemini CLI

gemini extensions install https://github.com/fastxyz/ultimatepowers

OpenCode

Follow .opencode/INSTALL.md: add the plugin array entry ultimatepowers@git+https://github.com/fastxyz/ultimatepowers.git to your opencode.json, then restart OpenCode.

The formal-verification delta (what ultimatepowers adds to superpowers)

• Four new skills: formal-reasoning-foundations (+ references/claim-shapes.md), formalizing-code, verifying-specs, formal-code-review — FVK's method digested into superpowers-style skills. K is used as notation; no toolchain is ever executed. Reasoning is constructed, with a machine-check escape hatch via emitted runnable .k artifacts in deep mode.
• Automatic wiring: requesting-code-review dispatches conventional + formal reviewers in parallel with one merged verdict (Critical from either blocks). Subagent-driven development runs the formal reviewer in parallel with the code-quality reviewer after spec review passes on every task. The end-of-plan final review runs both over the whole branch in final-review mode.
• Cost control: trivial-diff fast path / per-task mode / final-review mode — selected automatically from the diff and the review context, not a knob.
• Honesty guarantees:
  • constructed is never called machine-checked
  • [ESCALATION BOUNDARY] obligations are never faked as [trusted]
  • capability gaps are reported as gaps, not code bugs
  • test removal is recommendation-only and machine-check-gated
• Durable artifacts: docs/ultimatepowers/verification/YYYY-MM-DD-<topic>/ (SPEC.md, FINDINGS.md, PROOF.md, optional .k) — siblings of specs/ and plans/.