I compared my agent framework with Spec Kit, Superpowers and the rest. Here is what is actually different
Last week I described the rule behind claude-agentic-kit, the framework I built to run coding agents on Trusq: models write, scripts decide. That invites an obvious question, which is why I built my own at all when GitHub, Amazon and a few very popular open-source projects offer the same idea. On 24 October I went through every one of them again, against their current documentation, and compared them with my kit as honestly as I could.
The field in October 2026
The frameworks fall roughly into three groups. The first are process frameworks with fixed phases and written artifacts: GitHub's Spec Kit walks from a project constitution through specification, plan and tasks to implementation, BMAD organises the work as clarify, plan, build and learn, Amazon's Kiro turns requirements into a design and a task list inside its own IDE, and GSD Core runs phases from discussion to shipping. The second group are collections of small skills you combine as you like, with Matt Pocock's skills as the clearest example and Jesse Vincent's Superpowers somewhere between the two. OpenSpec sits apart with its delta specs, which describe only what a change adds, modifies or removes.
They are not small projects. On GitHub, Superpowers and Matt Pocock's skills each have around 300,000 stars, Spec Kit about 143,000 and OpenSpec about 73,000. My kit has one maintainer, lives on a private server and has been used seriously on one product.

Where my kit is actually different
Almost all of these frameworks now have some form of review loop, so "it reviews its own work" no longer sets anything apart. The difference is in who decides what happens next.
The end of a review loop is a tested script. In my kit, a shell script reads the number of critical findings and warnings per round and returns one of four answers, with the history of earlier rounds in a state file and a test suite behind it. Spec Kit's converge step, which compares code against the specification, is a model check. Superpowers caps its fix loop, but its own documentation describes that cap as an instruction to the model. GSD Core has a convergence loop that counts the serious concerns per cycle and warns when they stop falling, which is close to my idea, but its documentation does not say whether a script or a model does the counting.
Mistakes become checks that can block. After pull requests are merged, the kit collects recurring review findings into a catalogue, and where a mistake has a literal code signature, a script searches every new change for it and stops the run. Other frameworks learn from experience too, but in the ones I looked at the lessons remain advice for the next session.
Unattended runs stop for named reasons. When the kit runs a feature from specification to pull request without me, it halts on about ten typed blockers, such as a specification that changed underneath it, two runs on the same item or a critical security finding, and it can resume from exactly that point. The closest peer here is bmad-loop, a separate BMAD project that also enforces its gates in code.
Upgrades merge instead of overwriting. Projects customise the kit, so upgrading it does a three-way merge between the old version, the new version and the local changes. Spec Kit, by comparison, checks whether its managed files are untouched and refuses to update them otherwise.
Where the others are better
In several places they are clearly ahead.
They are used by far more people, which means far more bugs found by someone other than the author. They support many more coding agents: Spec Kit lists 41 integrations, OpenSpec more than 30 and Superpowers 16, while my kit runs only in Claude Code. GSD Core and bmad-loop can send a review to a model from a different vendor, which gives more independent reviewers than my alternation between two models from the same family. They install with one command from a public registry or plugin marketplace.
And several of them are much lighter. Matt Pocock's README explicitly positions small, composable skills against process frameworks that take control of how you work. Birgitta Böckeler, writing on martinfowler.com about spec-driven tools a year ago, put the cost of heavy process well: "I'd rather review code than all these markdown files." My kit is on the heavy side of that line. Its refinement skill alone is 1,836 lines, while Anthropic's own guidance suggests keeping a skill under 500.
Keeping a comparison current
The field moves fast. In April my kit was one of the few with an adversarial review loop; by October most frameworks had one, and what still sets the kit apart is that a script with tests ends the loop. So this comparison carries a date on every external fact, and I check it against the frameworks' own documentation instead of quoting it from memory.
What carries over
When you choose an agent framework, or build one, the question that sorts the field better than star counts is this: which decisions are made by code you can test, and which are left to a model following instructions? Both have their place. But you should know, for each step, which one you are relying on.
Next Wednesday: how I measured whether my kit actually helps, by regenerating plans for features we had already shipped.