Not Smarter, Just More Disciplined — Superpowers and the 210K-Star AI Coding Workflow

Last month, a project dominated GitHub Trending. Not a new model. Not a new framework. A collection of Markdown files.

Superpowers, 210K stars, built by Jesse Vincent (obra on GitHub). The README opens with a line that made me chuckle: "A complete software development methodology for your coding agents." Not a plugin. Not a tool. A methodology.

If you've used AI for coding, you know the drill. You say "add a login feature," and it starts dumping hundreds of lines of code immediately. It doesn't run. No tests. Zero edge case handling. You end up spending more time fixing its output than writing the code yourself. The problem isn't that the model isn't smart enough. It's that it has no discipline.

That's the hole Superpowers fills.

What it actually does

The core idea is simple: don't let the AI write code until it has thought it through.

The workflow has seven stages: brainstorming → using-git-worktrees → writing-plans → subagent-driven-development → test-driven-development → requesting-code-review → finishing-a-development-branch.

Each stage maps to a Skill — essentially a Markdown file containing structured instructions that tell the AI what to do at that point. Fourteen Skills in total, covering the full chain from requirement clarification to code review.

There's one design choice that stands out: mandatory triggers. Before the AI does anything, it must check whether a matching Skill exists. If one does, it has to use it. No "skip this step" option.

The most hardcore bit is the TDD rule: code that fails tests gets deleted by the agent. Not flagged for review. Not refactored. Deleted. I thought this was extreme at first, but think about it — if you don't delete bad code, the AI will find a way to route around failing tests and keep writing, leaving you with a pile of code that technically runs but is full of holes.

Why Markdown?

When people hear "210K-star open source project," they picture some complex piece of engineering. Superpowers is literally a bunch of .md files, mounted onto AI coding assistants through each platform's plugin system.

Here's an amusing detail the docs admit openly: the mandatory-trigger mechanism works because of Robert Cialdini's principles of persuasion. The prompts say "skills are mandatory" (authority), have the agent announce that it's using a skill (commitment), and describe what "always" happens (social proof). They're essentially using psychology tricks to make an LLM follow the rules.

There's a dark humor to this. We built something super-intelligent, and now we need persuasion science to get it to behave.

What I noticed after trying it

It's great for new projects. When starting from scratch, the biggest risk isn't that the AI can't write code — it's that it writes the wrong code. AI easily misunderstands your requirements and then generates furiously based on that misunderstanding. The brainstorming stage forces alignment before any code is written — it asks questions one at a time, presents design options for your approval, and only proceeds once you confirm. This "slow down first" approach was more useful than I expected.

It's maddening during rapid prototyping. Sometimes you just want to quickly validate an idea and see a demo working. Running the full seven-stage pipeline in that context feels like wearing a tuxedo to a sprint. The official docs acknowledge this — different scenarios get different workflows. New project: full seven stages. Adding a feature to an existing codebase: six stages. Bug fix: three stages.

Git worktree isolation is genuinely practical. Each development branch runs in an independent worktree. If things go wrong, delete the worktree and the main branch is untouched. This is moderately valuable for new projects. For existing codebases where you might not remember what every module does, it's invaluable — AI-induced regressions are much harder to spot in code you're not actively thinking about.

Parallel subagent development is the hidden gem. During the planning phase, large tasks get broken into 2-5 minute chunks, each dispatched to an independent subagent running in parallel. Each subagent sees only the context relevant to its task — no pollution from other tasks' context. After completion, each chunk passes two reviews: spec compliance and code quality. This essentially moves code review upstream into the development process itself.

But it's not a silver bullet

Let me be honest about the downsides.

First, it's too heavy for small tasks. If you just want the AI to change one config line or fix a typo, running the full workflow is overkill.

Second, mandatory triggers can feel rigid. The AI insists on brainstorming with you when you already know exactly what you want. That back-and-forth eats patience.

Third, it depends on platform support. Currently supported: Claude Code, Cursor, Codex, OpenCode, GitHub Copilot CLI, Kimi Code, and a few others. If your tool isn't on the list, you're on your own for integration.

What this wave of attention tells us

Superpowers' explosion isn't random. For two years, the dominant narrative in AI coding has been "models are getting stronger, programmers are becoming less relevant." But the first half of 2026 on GitHub Trending tells a different story. The hottest projects aren't new models. They're tools for managing AI.

Same week, TypeScript community heavyweight Matt Pocock's skills project hit 148K stars. agency-agents reached 123K. The collective realization was: whether AI can write code hasn't been the question for a while. The question is how to make what it writes actually reliable.

What Superpowers does is fundamentally simple: it takes decades of accumulated software engineering discipline and bolts it onto an unconstrained agent. Not new technology. Just old-school engineering rigor. But in an era where AI is sprinting forward at breakneck speed, it's exactly this kind of "pull back and think" that has become the scarcest thing.