The Biggest Shift in AI Coding Isn't Better Models — What Superpowers' 240K Stars Tells Us

The biggest thing in AI coding over the last two weeks wasn't a new model. Not an acquisition. Not a security advisory.

It was a GitHub repo called Superpowers. 240,000 stars. 90,000 of those in seven days.

What does it do? Simple: it stops AI from writing code immediately.

In the same window, TypeScript heavyweight Matt Pocock's skills repo hit 148K stars. Google's agent-skills held steady at 56.7K. agency-agents reached 112.3K. These projects share one thing in common: none of them are about making AI smarter. They're all about making AI more disciplined.

Meanwhile, another conversation is getting louder. Midjourney founder David Holz posted on X that his friends are "insanely productive with the latest coding models, but also completely exhausted." A developer burnout survey put the average self-reported fatigue at 7.4 out of 10 — over 70% of respondents had been burned out for at least six months. And "AI pressure" now ranks alongside "always-on culture" and "shifting priorities" as one of the top four sources of developer burnout.

These aren't separate stories. They're the same story, told from two angles.

Why AI coding makes us more tired

The narrative for the past two years was straightforward: models keep getting stronger, programmers keep becoming less important.

The reality in the first half of 2026? Models did get stronger. Programmers did not get more relaxed. Henry Yager, writing in Harvard Business Review, calls this "workload creep" — AI drives productivity up, organizational expectations follow, task scope expands, and cognitive load doesn't drop. It rises.

Siddhant Khare, a core maintainer of OpenFGA, wrote a piece earlier this year that went viral in developer circles. The title: AI Fatigue Is Real and Nobody Talks About It. He described a fundamental shift in how work feels:

Writing code used to be a clear path: think about the problem, write the code, run the tests, ship when they pass. That felt like creating something. Now his daily cycle looks like this: issue a prompt, wait for output, read the output, evaluate the output, judge correctness, judge safety, judge architectural fit, fix what's wrong, issue another prompt. Repeat.

The programmer went from creator to QA inspector. When the work is done, there's no sense of accomplishment — just a flat, blank exhaustion.

And it gets worse. The faster AI generates code, the more pressure you feel reviewing it. You used to write 200 lines and know them intimately. Now AI spits out 2,000 lines in two minutes, and you have to decide in the same two minutes whether any of those lines are broken. They usually are — but you might not spot it at a glance.

What Superpowers actually does

Superpowers was built by obra (also the creator of Day One). It's a structured development methodology packaged as a set of composable Skill files and initial instructions that force AI agents through a thinking process before they touch any code.

The core is a seven-stage workflow:

1. Clarify requirements — ask smart questions before assuming anything
2. Plan and get approval — generate a readable spec, wait for human sign-off
3. TDD implementation — write tests first, then code
4. Parallel sub-agents — break work into 2-5 minute chunks and dispatch
5. Review and close — verify all tests pass before calling it done

The TDD rule is brutal in its simplicity: tests come first, and any code that fails a test gets deleted by the agent. Not flagged for revision. Not refactored. Deleted.

Those four words — "deleted by the agent" — are the soul of Superpowers. It doesn't trust AI to fix its own mistakes. It operates on the assumption that letting AI revise AI-generated code is about as effective as asking a drunk person to sober themselves up. Better to throw the bad code away and start from a correct foundation.

obra put it plainly in an interview: "I'm not building a smarter AI. I'm building a process where AI can't be stupid."

That's slightly hyperbolic, but the direction is right. For two years, everyone chased the ceiling — how good can the model get? Superpowers raises the floor.

It's not alone: the methodology explosion

Superpowers didn't emerge in a vacuum. Several projects launched in the same period, each with a different angle but the same underlying logic:

Project	Stars	Focus	Approach
Superpowers	240K+	Development methodology	Design → Plan → TDD → Implement
agent-skills (Addy Osmani)	56.7K	Production-grade workflows	21 SDLC phase skills
agency-agents	112.3K	AI expert role library	232 role definitions
Compound Engineering	18.3K	Compound engineering	Every change makes the next one easier

Matt Pocock's skills project deserves a closer look. His four core commands have refreshingly blunt names:

• /grill-me — force requirement alignment; not a single line of code until the agent truly understands the intent
• /tdd — red-green-refactor cycle
• /diagnose — systematic root cause analysis through a diagnostic tree
• /caveman — slash token consumption by 75%

Pocock's own summary nails it: "I'm not making AI smarter. I'm making it follow the rules."

The simultaneous rise of these four projects is not a coincidence. They all answer the same question: once AI can write passable code, what separates good results from bad isn't model capability — it's how you use the model.

What this means going forward

If I had to summarize the first half of 2026 in AI coding with one sentence, it'd be this: the ceiling war is cooling down. The floor war is just heating up.

GPT-5.6 shipped. Grok 4.5 shipped. Claude Fable keeps iterating. The model arms race is very much alive, but developer attention is shifting. More people are realizing that a stronger model, used poorly, can produce worse outcomes than a weaker model used well.

This tracks with software engineering history. Nobody talked about CI/CD in the 1990s — not because it wasn't useful, but because writing code itself was the bottleneck. When AI pushes code-writing speed to unprecedented levels, the problems that used to hide behind "development velocity" — code quality, architectural consistency, team coordination — all surface at once.

Katherine Wu, who runs Claude Code at Anthropic, recently said she now "uses a single AI agent to go deep on one hard task." Her reasoning: "Normally I spin up a dozen agents simultaneously, but the immersion of focusing on one thing and polishing the details is rare and valuable."

That's someone who sells AI coding tools saying this. Worth sitting with.

Wrapping up

Superpowers' 240K stars don't represent one tool's success. They represent a collective reckoning: AI can write code. Now what?

The answer taking shape is: build the process. Lock down the rules. Let AI operate within those boundaries. The next phase of AI coding won't be won by whoever has the most parameters. It'll be won by whoever has the most mature engineering methodology.

For two years we've been asking AI "what can you do?" Starting now, we should be asking ourselves "how do we want AI to do it?"