Category: AI Coding Comparisons

OpenSpec and Superpowers solve different parts of AI-assisted software delivery. OpenSpec emphasizes explicit change artifacts and a maintained specification lifecycle; Superpowers emphasizes disciplined implementation practices such as design, testing, review, and verification. Spec Superflow and Comet both try to connect those layers—but the two projects now serve noticeably different buyers.

This comparison updates a Chinese WeChat article that examined earlier releases. As of July 16, 2026, the current published versions are Spec Superflow v0.9.1 and Comet 0.4.0-beta.4. That matters because the source compared v0.8.10 with v0.3.9. Since then, Spec Superflow has expanded its portable runtime and execution controls, while Comet has moved its Classic workflow from shell scripts to Node.js and broadened into skill composition and evaluation.

The short answer: choose Spec Superflow when you want a self-contained, prescriptive spec-to-execution contract. Choose Comet when you want a broader workflow platform with cross-tool installation, a dashboard, reusable skill composition, and evaluation. Neither is automatically the right answer for a small change that one agent can safely complete and verify.

Current comparison at a glance

The platform and skill counts above are project claims, not independent compatibility certifications. A listed installer does not guarantee that every host exposes identical hooks, subagents, permissions, or skill-discovery behavior.

Spec Superflow: make the handoff a contract

Spec Superflow’s defining choice is to make planning-to-implementation handoff explicit and difficult to bypass. Its nine skills cover discovery, specification, contract building, execution, debugging, review, release, and spec merging. A workflow starts by inspecting the content of existing artifacts, rather than relying only on timestamps, and routes the change through an eight-state model.

The centerpiece is execution-contract.md. The contract condenses the planning artifacts into an implementation boundary, with an intent lock, constraints, and freshness checks. Guards can refuse implementation when the contract is absent, stale, or unapproved. The workflow also enforces TDD, review, and spec synchronization in its full path.

Version 0.9.1 goes beyond the older “nine skills and a guard” summary. For full and hotfix changes, it can generate a guarded execution recommendation, ask the user to confirm an execution mode, persist an execution plan, and require passing review receipts for each wave. The available modes include inline work, serial batch-inline work, and subagent-driven development. A plan can be upgraded to a more structured mode, but the tooling intentionally prevents silent downgrade of an approved plan.

This design favors auditability and constraint retention. It also creates ceremony. A team must be willing to maintain the artifacts, honor decision points, and understand why a guard blocked progress. Spec Superflow includes hotfix and tweak routes, but its core value appears when a change is important enough to justify a durable contract.

Spec Superflow is the stronger fit when

• you want one self-contained package instead of runtime coordination across separately installed frameworks;
• the planning-to-build boundary is the main source of risk;
• TDD, review receipts, and spec synchronization should be enforced rather than suggested;
• a controlled set of execution modes is preferable to an open-ended workflow platform;
• CLI audit evidence matters more than a graphical dashboard;
• Chinese-first workflow instructions are useful to the team.

Comet: make the workflow a platform

Comet still offers a five-phase Classic workflow—open, design, build, verify, archive—but the current project is broader than the “YAML plus shell glue” description in the older source. Beginning with the 0.4 beta line, its runtime is pure Node.js. The installed Classic skills use JavaScript modules such as comet-guard.mjs, comet-state.mjs, and comet-handoff.mjs, while .comet.yaml remains the per-change state record.

That state file allows the main /comet entry point to determine the active phase and resume work. The 0.4.0-beta.4 release also adds an ambient resume probe, stable top-level state/guard/handoff/archive commands, stronger evidence handling for custom builds, and archive-confirmation enforcement. The dashboard provides a read-only browser view of active changes, phase status, task progress, artifacts, and archive history.

Comet’s larger strategic difference is /comet-any and its evaluation tooling. The project now positions itself as a harness for composing arbitrary skills into distributable workflows, then measuring them with rubrics and Pass@k/Pass^k-style experiments. comet eval can run local checks and produce HTML reports; the repository also documents a LangSmith path for teams that want centrally inspectable evaluation traces.

This breadth increases the number of moving parts. Comet declares OpenSpec as a package dependency and its initializer manages OpenSpec, Superpowers, Comet skills, platform-specific directories, language variants, updates, and uninstall behavior. Its published release is still named 0.4.0-beta.4, so teams should treat version pinning and upgrade tests as part of adoption, even though GitHub marks the release itself as non-prerelease metadata.

Comet is the stronger fit when

• the team already uses OpenSpec or Superpowers and wants an orchestration layer around them;
• one workflow must be installed across a heterogeneous set of coding tools;
• a visual status dashboard will help reviewers or project leads;
• TDD and review strictness need to be configurable by project;
• the organization wants to create, package, evaluate, and distribute skills beyond the Classic spec workflow;
• resumability and cross-device recovery are higher priorities than minimizing the framework surface.

The real trade-off: controlled depth versus platform breadth

It is tempting to reduce the choice to “discipline versus flexibility,” but that misses the engineering boundary.

Spec Superflow internalizes more of the workflow contract. Its guards, decision points, execution plans, and review receipts form one opinionated control system. That reduces runtime dependency on upstream frameworks and makes the intended path easier to audit. The cost is tighter coupling to Spec Superflow’s own artifact model and release cadence.

Comet externalizes and composes more capabilities. Its Classic mode coordinates OpenSpec and Superpowers concepts, while the wider platform adds installation adapters, a dashboard, skill creation, and evaluations. That provides more extension points, but each extension point is another compatibility surface to test.

Neither architecture guarantees better code. Both can enforce that evidence exists; neither can ensure that a generated test is meaningful, that a review caught the right risk, or that a specification captured the user’s actual intent. Human approval remains most valuable at irreversible decisions: scope, architecture, data migration, security boundaries, and release.

A practical pilot before standardizing either tool

Run the same medium-sized change through both systems in disposable branches. Avoid using a tiny edit, because both workflows will look artificially expensive, and avoid a mission-critical migration, because a first trial should be reversible.

Score each run on evidence rather than impressions:

1. Setup repeatability: Can a second developer install the pinned release and reproduce the environment?
2. Artifact quality: Do proposal, design, tasks, contract/state, verification, and archive records agree?
3. Guard behavior: Does an intentionally missing approval, stale artifact, or failing test actually stop progression?
4. Resume behavior: Can a new session recover the correct change and next action without guessing?
5. Review usefulness: Do review receipts or reports contain actionable evidence rather than a ceremonial “pass”?
6. Change overhead: How much time and model usage go to coordination compared with implementation?
7. Portability: Do the specific coding tools your team uses support the required hooks, skills, and permissions?
8. Exit cost: Can you uninstall or stop using the framework while preserving useful specifications and history?

Pin exact versions during the pilot. Both repositories are young and actively changing: Spec Superflow was created in late June 2026, and Comet in May 2026. Release notes, not old tutorials, should be the first stop before every upgrade.

Recommendation

For a team whose main failure mode is “the implementation drifted away from an approved design,” start with Spec Superflow v0.9.1. Its contract-builder, guarded execution plan, and review receipts directly target that boundary.

For a team whose main problem is “we need one resumable workflow and skill platform across many coding environments,” start with Comet 0.4.0-beta.4. Its installer breadth, dashboard, skill composition, and evaluation surface are the differentiators—not merely its five-phase Classic flow.

If the work is a one-file fix, a configuration adjustment, or a question that does not need a durable spec, start with neither. The best workflow is the smallest one that preserves the evidence and control the change actually requires.

Sources

• Original WeChat comparison
• MageByte-Zero/spec-superflow repository
• Spec Superflow v0.9.1 release
• rpamis/comet repository
• Comet 0.4.0-beta.4 release
• Fission-AI/OpenSpec repository
• obra/superpowers repository