Superpowers at 210K Stars: The Next Frontier of AI Coding Isn't Writing Faster—It's Thinking First

The first week of July 2026 delivered an unexpected signal from GitHub Trending.

For two years, the AI coding narrative has followed a single track: models keep getting stronger, and programmers keep getting less necessary. Every week brings a new model. Every benchmark score goes higher. Open Twitter/X and you'll see the same cycle: "game-changer," "disruption," "another profession is dying."

But this week, the top spot didn't belong to a new model. It belonged to a GitHub project called Superpowers. 210,000 stars. 90,000 of them in seven days. Nearly 50,000 more than second place.

Here's the thing—this project's core idea isn't "make AI write more code." It's the exact opposite: don't let AI write code directly.

Vibe Coding Meets Its End: Engineering Discipline

Vibe Coding swept through the developer community over the past year. You type a sentence into Claude Code or Cursor, AI generates an entire feature, and if it runs, it "feels right." It is fast. But the cost of that speed is measurable: research shows 45% of AI-generated code contains security vulnerabilities. How many logic errors? How many concurrency issues? How many edge cases go unhandled? Nobody knows, because nobody reads them, and nobody tests them.

Jesse Vincent—creator of Superpowers and the veteran behind RT (Request Tracker)—saw through the problem. It's not about whether AI can write code. Obviously it can. The real problem is that AI writes code with zero engineering discipline. A human developer might skip a test out of laziness, but at least they know they're cutting a corner. AI doesn't—it simply "forgets."

Not a Tool. A Set of Iron Rules.

Superpowers isn't a new code generation tool. It's a mandatory skill enforcement system. Once installed, your AI coding agent—whether Claude Code, Cursor, Codex, or Gemini CLI—gets embedded into a 7-step workflow:

Step	Purpose	Core Constraint
1. Clarify	Socratic questioning to nail down intent	Agent cannot skip; must ask first
2. Isolate	Create isolated Git Worktree	No pollution of the main branch
3. Plan	Break tasks into 2-5 minute chunks	Junior engineer should be able to follow
4. Execute	Dispatch independent sub-agents per task with dual review	Clean context, no inertia bias
5. TDD	Write failing test → minimal implementation → refactor → commit	Code written before tests gets actively deleted
6. Review	Report issues by severity; Critical blocks progress	Not a rubber stamp
7. Finish	Verify all tests pass → merge / PR / keep / discard	Human makes the final call

The TDD Iron Law: Untested Code Doesn't Deserve to Exist

Step 5 is the most brutal. Superpowers enforces RED-GREEN-REFACTOR with no exceptions. The agent must write a failing test first, confirm it fails, write the minimal code to pass, confirm it passes, then commit.

What if you wrote implementation code before the test? It gets deleted. Not "marked for revision." Not "refactored for you." Deleted.

That sounds radical. But step back—isn't this what TDD was always supposed to be? When Kent Beck introduced it, the whole point was define the correct behavior first, then implement. Over two decades, human developers found every excuse to skip it. An AI, ironically, can do it without compromise.

Sub-Agent Dispatch: Fighting Inertia Bias

Step 4 deserves more attention. Superpowers requires each sub-task to be handed to a fresh sub-agent, which gets destroyed after completion. This isn't technical showing-off—it solves a real problem. Agents have "inertia": after finishing task A, they carry A's assumptions into task B. A clean agent reading the plan from scratch significantly reduces this bias. Each task also passes through two review gates: spec compliance first, code quality second.

Why 210K Stars

I'll be honest—when I first heard about Superpowers, I thought it sounded pedantic. But 210,000 stars point to a real pain point: AI writes code fast, but it doesn't write correct code very often. It's not that the models aren't strong enough—it's that the process lacks guardrails.

Jesse Vincent's design philosophy boils down to four principles, all gerunds, all contrarian:

1. Test-Driven Development — against "write code first, add tests later"
2. Systematic over ad-hoc — against "wing the process based on mood"
3. Complexity reduction — against "complexity for complexity's sake"
4. Evidence over claims — against "I think it's fine"

These four aren't written for humans. They're written for the AI agent. Each maps to a set of executable Skills underneath.

Even better, each Skill contains a Rationalization Table—a pre-written list of excuses agents commonly use, with rebuttals:

Agent: "I'll add tests later."
Skill: "No."

Agent: "This case is special."
Skill: "There are no special backdoors."

The design radiates a "I've been managing open-source for twenty years and I'm done arguing" energy. Jesse knows every excuse developers make to bypass process. Now he's encoded that experience directly into AI workflows.

What Superpowers Tells Us

Let's return to the opening: in the first week of July 2026, GitHub Trending's hottest item wasn't a new model. It was a project about disciplining AI. That same week, TypeScript thought-leader Matt Pocock's skills project hit 148K stars—its core command /grill-me forces intent alignment. Google's agents-cli entered the arena. Xiaomi's MiMo-Code entered the arena.

This isn't coincidence. For two years, the AI coding world obsessed over model capability: bigger parameters, higher benchmarks, flashier demos. But 210K stars tell us something different: what developers actually need isn't stronger models—it's models that follow the rules.

Writing faster isn't enough anymore. Writing correctly, writing reliably, writing maintainably—that's the next step.

Superpowers isn't a silver bullet. Installing a skill framework won't turn your agent into a 10x engineer overnight. But it points in a clear direction: the second half of AI coding isn't about compute. It's about process. And the best processes turn out to be the old rules humans got lazy about skipping—TDD, code review, thinking before typing.

---

Superpowers was created by Jesse Vincent (obra), open-sourced under MIT license, and supports Claude Code, Cursor, Codex, Gemini CLI, GitHub Copilot CLI, and other major AI coding platforms. As of July 2026, it has surpassed 226K GitHub stars.