Written by
Ashish Bagri
Date added
TL;DR
Superpowers is an AI coding agent workflow. It is a set of Claude Code skills that teaches one coding agent to work like a careful engineer: brainstorm, plan, test first, review. It is excellent at that, and it runs in almost every coding agent.
A software factory solves a different problem. It is a system for multi-agent software development that keeps a team’s agents building for days or weeks, to the same bar, with a record of every decision.
You can use both. The question is which problem you have: a better agent for one developer, or a system for a whole team.
Superpowers vs software factory: why we compared them
Superpowers is one of the most popular projects in the agentic coding world, with over 300,000 stars on GitHub. Almost every time we demo our software factory, someone asks how it compares. The question is fair. Both start with a plan before any code, both use subagents or separate sessions to build, and both review every change.
So we sat down and compared them honestly. We did not ask which one is better. We asked what each one is for.
What is Superpowers? A skills framework for Claude Code and other coding agents
Superpowers is a set of Claude Code skills plus a short bootstrap that tells the agent to use them. When a session starts, a hook loads the bootstrap, and from then on the agent follows a fixed workflow:
Brainstorm. The agent asks questions until it understands what you want, then writes a design.
Plan. It breaks the work into tasks of 2 to 5 minutes each, with file paths, the code to write and how to check it.
Build. In its most thorough mode, a controller session hands each task to a fresh subagent, then has a second subagent review it against the plan. A cheaper mode works every task in the same session and reviews the whole branch once at the end.
Test first. Every task follows red, green, refactor.
Finish. It runs the tests and offers to merge, open a pull request or keep the branch. It discards the work only if you ask.
It is MIT licensed, it needs no server, and it installs into 16 different coding agents. For one developer and one feature, it is a very good way to work.
What is a software factory for AI agents?
We wrote about this in What is a software factory. The short version: a software factory is a system for multi-agent software development that turns a plan into shipped, reviewed software. Agents do the work. People make the decisions.
Ours has two parts. The crew is a set of Claude Code sessions in the background, each with one role: an orchestrator, builders, a reviewer and an optional releaser. Tares is the record. It holds the spec, the plan, the tickets, every review, every assumption and every answer a person gave.
The difference shows up in one line. Superpowers is a method that lives inside a session. A factory is a system that lives outside any session.
That one difference explains everything below.
Superpowers vs software factory at a glance
Superpowers | Software factory (Tares + crew) | |
|---|---|---|
Built for | One developer, one agent, one feature | A team shipping with agents in the same codebase |
What it is | A set of skills that lives inside a session | A system that lives outside any session |
Team use | Design, plan and ledger are files in your repo or worktree | Shared record of specs, tickets and decisions, with project leads and code owners |
Long projects | Built for hours; stops if the controller session stops | Built for days or weeks; stalled sessions are revived and resume from the last ticket |
Guardrails | Written skills the model follows | Written rules plus enforced role permissions and your own checks (block or warn) |
Merging | The agent offers to merge or open a PR | One merge queue per repo, owned by the factory, not the builder |
Prompt cache use | Fresh subagent per task in its most thorough mode | One builder per milestone and a long-running reviewer; 97% of input tokens read from cache over 14 days |
Setup | MIT licensed, no server, installs into 16 coding agents | Open source; |
Best when | You work alone and your work fits in a session or an afternoon | Several people ship with agents, projects run for weeks, or some rules must hold even if the model ignores them |
1. Software factory vs Superpowers for teams
Superpowers is built for one person and one agent. The design, the plan and the progress ledger are files in your repo or worktree. The controller session is the only thing that knows what is going on. When the work is done, its own workspace is deleted.
That is fine when you are the whole team. It gets hard when you are not:
Who decided this? Your teammate's agent made a ruling at 2am. It is in a ledger file on their laptop.
Who owns this part of the code? Two people's agents change the same module, and neither knows about the other.
Who signs off? The plan touches billing, and the billing owner never saw it.
A factory starts from the team. The spec, tickets and decisions live in Tares, so everyone sees the same record. In the version we are rolling out now, each person has their own crew, projects have a lead and members, and parts of the codebase have owners. When a spec session touches an area someone else owns, the question goes to that person, and the hand-over waits until they sign off. Private projects stay private.
There is also a practical limit. One Superpowers session builds one plan in one repo. A crew takes every project you hand it, in several repos, at the same time.
2. Running AI coding agents on long projects that survive restarts
Superpowers says that once you approve a plan, the agent can work for hours without drifting. The skills even plan for the hard part: progress goes into a ledger file because "conversation memory does not survive compaction."
But hours is not the problem we have. Our projects run for days or weeks. They have milestones, they span repos, and they wait on people. Over that time, many things stop a single session:
Claude Code stops a session that has been idle for about an hour.
A laptop sleeps, restarts or runs out of battery.
Usage limits run out halfway through a milestone.
A ticket waits two days for a decision from someone on holiday.
A session-based method has nothing that outlives the session. If the controller stops, the work stops, and someone has to notice and restart it.
A factory treats sessions as replaceable. A watch brings back any station that stops, under the same name. The orchestrator wakes on a schedule to look for stalled tickets and newly unblocked work. A revived builder reads the project from Tares and carries on from the last ticket, not from the last message. Sessions come and go. The record stays.
That also changes how plans age. In a long project, the plan is wrong in places. Our builders record an assumption every time the plan does not cover something, and at the end of a milestone you read that list and keep or change each one. Superpowers has the same idea, called rulings, but they live in the ledger of one plan and disappear with it.
3. AI coding agent guardrails: enforced rules vs skills
Superpowers calls its workflows "mandatory, not suggestions." But there is nothing to enforce them. A skill is text the model reads. If the model skips a step, nothing in the system stops it. The skill even lists the cases where the agent must stop and ask, such as a merge, a push to a shared branch or anything destructive. That is a rule, written down and trusted.
We think of guardrails as two layers.
Rules the agents follow. Every factory has written rules, such as how to test, when to run integration tests, and what "done" means. Tares keeps them in one place, and every station reads them. Like skills, these are followed by the model. Unlike skills, the team changes them in one place and every crew picks them up.
Rules the system enforces. Some things should never depend on the model behaving. In our crew, a hook checks every command before it runs. Only the role that owns an action may do it: the reviewer cannot merge, and a builder cannot deploy. When a station needs something outside its role, the request goes to a person on the desk, and they allow or deny it.
The enterprise version adds a third layer: your own guardrails. At set points such as before a build, before a merge and before a release, the factory calls the checks you already run. That might be a policy service, a security scanner or an internal approval API. Each one is set to block or to warn. The merge itself is the factory's decision, not a builder's. Changes go through one merge queue per repo, so two builders never race each other into main.
4. Prompt caching for coding agents: why long-running builders cost less
This one surprised us, and it matters more as agents do more of the work.
Every coding agent pays for the context it reads. Prompt caching makes repeated context much cheaper: if the start of a request matches a recent one, the model reads it from cache at a fraction of the price. A long session that keeps working in the same area gets that discount on everything it has already read.
In its most thorough mode, Superpowers deliberately gives every task a fresh subagent with no history. That is good for focus, but it means each task starts cold. The subagent reads the same files, the same conventions and the same parts of the plan again. Then a fresh reviewer reads them again. Meanwhile, every report a subagent sends back stays in the controller's context for the rest of the session, which the skill itself warns about.
Our builders work the other way. One builder owns a milestone in one repo and works its tickets in order. By the second ticket, the repo layout, the conventions and the code around the change are already in its context, and most of that is read from cache. The reviewer is also one long-running session, so the review bar and the repo's patterns stay warm across every pull request. When a builder's context does fill up, it starts fresh and reads the project from Tares, so we lose the cache once, not on every task.
Our own numbers bear this out. Over the last 14 days, the sessions on our factory cell read 6.6 billion input tokens from cache, which is 97% of all the input they sent.
5. Using Superpowers inside a software factory
We do not see these as either/or. A factory is made of parts, and good parts should plug in.
The clearest fit is the spec session. When you run tares factory spec, you are in an ordinary Claude Code session with your own plugins. Superpowers' brainstorming skill does much of what our spec interview does: one question at a time, then a design you approve. If your team already likes how it asks questions, keep it. The spec and the plan still land in Tares, and from there the crew takes over.
Inside the crew, it is a choice per role. Superpowers' build and finish skills would compete with the factory's own roles, because they want the builder to review and merge its own work, and in a factory that belongs to the reviewer and the merge queue. Its test-first and debugging habits fit a builder well.
This is the direction the whole factory is going. We are making each part an integration: tickets in Tares, Linear, GitHub or Jira; review by Tares, CodeRabbit or Qodo; CI on your machine or in GitHub Actions; memory in Tares or Cognee. A skill library is one more input to that system, not a replacement for it.
6. Do Claude Code skills still matter with modern models?
Here is my honest view, and some of you will disagree.
A year ago, skills like these made a big difference. Models skipped tests, forgot to plan and declared victory early. Writing the discipline down in a skill fixed a lot of that.
Today's models already know how to brainstorm, plan, write a failing test first and debug from the root cause. Ask for it in one sentence and you get it. A long skill about good engineering mostly costs context on every session start.
Skills still matter where the model has not been trained, for example:
your company's internal systems and APIs,
a niche industry with its own rules, such as a regulated domain, an unusual file format or an in-house protocol,
the decisions your team already made and does not want relitigated.
None of those are general engineering practice. They are about your system. That is why we put them in the record, as shared rules and memory every station reads, rather than in Claude Code skills each person installs.
Which one should you use?
Use Superpowers if you work alone, your work fits in a session or an afternoon, and you want a better agent in whatever tool you already use. It is free, it is portable, and it needs nothing else.
Use a software factory if:
more than one person ships with AI coding agents in the same codebase,
your projects run for days or weeks and must survive restarts,
some rules must hold even when the model ignores them,
you need a record of what was decided, by whom and why,
you want one place to plug in your tickets, review, CI and guardrails.
And if you like Superpowers, bring it along. Run it in your spec sessions and let the factory do the rest.
Try it
Tares is open source. Install it and follow the get-started guide to set up a crew on your machine in a few minutes:
If your team is thinking about running a factory on your own servers, with teams, your own guardrails and your own integrations, we would like to talk. Tell us in the comments which part of your workflow you would plug in first.
Share the article
You might also like

Agent Infrastructure
What is a software factory, and how we run ours with Tares
A software factory turns a plan into shipped, reviewed software. See how we run ours with open-source Tares and Claude Code agents. Get started in minutes.
Written by
Ashish Bagri
read article
read article

Agent Infrastructure
Is a software factory worth it? A month of data from running ours
We ran a software factory and plain Claude Code side by side for a month. Result: 5x more changes shipped per day, same cost, 1/3 of the hands-on time.
Written by
Kiran Nambiar
read article
read article

Agent Infrastructure
Can a decision model replace an LLM? Tune it on your own data first
We ran Cloudflare's Clef-flash next to Claude Haiku for 6 days on production logs. As a filter, it cut LLM calls ~80%. Test it on your own data with Tares.
Written by
Ashish Bagri
read article
read article





