Jesse Vincent's Superpowers 6 Cuts AI Coding Costs 60% After Overnight Fable Experiments

Superpowers, the open-source agentic coding workflow framework built by Jesse Vincent, just shipped version 6 -- and the headline numbers are hard to ignore: builds up to 50% faster and token costs cut by up to 60%. The release also officially adds support for Kimi Code, Moonshot AI's terminal-first coding agent, expanding the growing list of platforms Superpowers can plug into.

But the real story here isn't just the new integration. It's how those performance gains were achieved -- by pointing Anthropic's most powerful model, Fable, at Superpowers itself and letting it run experiments overnight.

What Superpowers actually does

Superpowers is an open-source agentic skills framework and software development workflow designed for coding agents such as Claude Code and Codex. The core idea is that AI coding agents, left to their own devices, tend to skip the boring but critical parts of engineering. You ask for a feature, and the agent immediately starts writing code -- no spec, no plan, no tests. Twenty minutes later you have something that looks right and is subtly wrong.

Superpowers fixes this by imposing a mandatory structured workflow on top of whatever coding agent you're using. Skills trigger automatically -- the agent checks the skills library before acting and selects the appropriate skill based on context. The workflow enforces:

• Mandatory RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit.
• Breaking work into bite-sized tasks of 2-5 minutes each.
• Dual-axis review of every change: did the agent implement exactly what was asked, and is the quality up to standard.
• Creating an isolated workspace on a new branch, running project setup, and verifying a clean test baseline -- before any code is written.

Superpowers is an open-source framework by Jesse Vincent -- a methodology for building coding agents with composable skills that auto-trigger, mandatory TDD, and subagent-driven development. It supports Claude Code, Cursor, Codex, and Gemini CLI. It's MIT-licensed and free to use.

The Fable experiment that changed everything

The version 6 performance story starts with Anthropic's Claude Fable 5 -- a new Mythos-class model built for long-horizon autonomous work. Claude Fable 5 is a Mythos-level model built for the most ambitious, long-running projects. It is thorough, proactive, and tests its own work. Vincent got brief access to Fable and decided to use it to optimize Superpowers itself.

The biggest complaint from Superpowers users had always been cost and speed. The framework's thoroughness -- all that planning, testing, and reviewing -- came with a real token bill. Vincent set Fable on the problem, hoping for maybe a 15% reduction. What he got was dramatically more.

The first win came from rethinking the handoff between coordinator and reviewer agents. Simply switching from written instructions for finding commits to a shell script that pre-generates a structured review package -- containing well-formatted diffs and metadata -- dropped token spend and wall-clock time by about 10%.

Then Vincent got more ambitious. He gave Fable a single overnight prompt:

/goal once this is done, run an autoresearch loop to improve cost-efficiency of the superpowers build loop. test with opus as the coordinator. make an hypothesis log. run experiments. run at least 25 experiments.

Fable built a full autoresearch harness and ran it overnight. The autoresearch code is on GitHub. The loop ran 25 experiments, pre-registered every hypothesis, and found several major wins:

• Terse reviewer contract: Cutting reviewer output verbosity by 41% with zero loss in verdict quality.
• Narration recipe: Reducing output by 54% with zero variance in outcomes.
• Conditional implementer tiering: Using cheaper models (Haiku) only when appropriate, saving roughly $0.5-$1 per run.
• Combining spec compliance and code quality review agents into one: This was independently discovered by both Vincent and Fable on the same night.

The total spend for the autoresearch loop was approximately $165 in unsubsidized tokens. The result: across about 36 hours of work, Superpowers builds on Anthropic's eval benchmarks were 50% faster and 60% cheaper.

Kimi Code joins the party

Kimi Code CLI is an AI coding agent that runs in your terminal -- it can read and edit code, run shell commands, search files, fetch web pages, and choose the next step based on the feedback it receives. It's built by Moonshot AI, a Chinese AI lab that has been shipping models at a rapid pace.

Kimi K2.7 Code is an open-source, coding-focused agentic model developed by Moonshot AI. It delivers stronger coding and agent performance, with substantial improvements in real-world long-horizon coding tasks. The model powering Kimi Code is notable for its architecture: Kimi K2.7 Code is built on a Mixture-of-Experts (MoE) architecture with 1 trillion total parameters and 32 billion activated parameters per token. The model supports a 256K context length.

K2.7 Code is priced dramatically lower -- by some estimates up to 12x cheaper per token -- which changes the calculus for high-volume, agent-driven workloads where running the most expensive model on every step isn't economically practical. For Superpowers users already watching their token spend, this is a meaningful alternative to Claude-based workflows.

What else shipped in v6

Beyond the performance overhaul and Kimi Code support, the release includes a range of other improvements:

• Support for Pi, Antigravity, and Kimi Code harnesses
• Better compatibility with Codex, OpenCode, and Cursor
• A rewrite of core Superpowers skills to be model and harness agnostic -- making them more reliable everywhere
• A new contribution guide for adding support for new coding agent harnesses
• Visual Brainstorming improvements: easier to use, safer, and more reliable
• A bug fix for code review subagents that were sometimes reviewing the whole branch instead of a single task

The team also published their eval suite on GitHub, which made all of these improvements measurable in the first place. Without a solid eval harness, none of the autoresearch experiments would have been trustworthy.

The bigger picture

Superpowers and similar tools reflect a larger shift: the developer community is recognizing that good agentic workflows need structure, not just capable models. When you hand an agent a complex task without a workflow, it doesn't know when to plan, when to code, when to test. The outcome is often disorganized. Superpowers lays a methodology foundation -- similar to how Agile or TDD provides structure for human developers -- and applies it directly to agent behavior.

The Superpowers 6 story also previews something more interesting: AI systems optimizing other AI systems' workflows. Fable didn't just help -- it independently converged on the same architectural insight as its human developer, then ran 25 controlled experiments to validate it. That's a qualitatively different kind of tooling assistance than autocomplete.

For teams already running Superpowers, the upgrade is a straightforward win: same quality, lower cost, faster builds. For teams on Kimi Code looking for more structure in their agentic workflows, there's now an official path in. You can install Superpowers directly from the GitHub repository right now, with marketplace distribution rolling out over the following days.