Comet: OpenSpec + Superpowers Dev Workflow Guide

TL;DR

TL;DR: Comet bundles OpenSpec and Superpowers — two of the most popular AI coding workflows — and installs them across 28 platforms with a single command. Auto-detects your tools, supports project and global scopes, and keeps everything updated.

Source and Accuracy Notes

Based on the official rpamis/comet repository, MIT licensed. Platform support details and CLI options sourced from the repository README as of June 2026.

What Is Comet?

Comet solves a mundane but real problem: setting up AI coding agent skills across multiple platforms. If you use Claude Code for some projects, Codex for others, and maybe Cursor or Windsurf occasionally, you’d normally have to install OpenSpec and Superpowers separately for each — copying files, managing versions, and keeping them in sync.

Comet automates this. One comet init command detects all your installed AI coding platforms, installs OpenSpec (for spec-driven development) and Superpowers (for agent skill enhancement), and sets up working directories. It supports 28 platforms and handles language selection (English or Chinese).

What Are OpenSpec and Superpowers?

• OpenSpec: A spec-driven development workflow from Fission AI. You write specifications, the agent implements against them, and you track progress through spec stages.
• Superpowers: A skill collection (from obra/superpowers) that extends AI coding agents with capabilities like planning, testing, debugging, and code review workflows.

Comet bundles both as a dual-star workflow — specs drive the plan, Superpowers drive the execution.

Repo-Specific Setup Workflow

Prerequisites

• Node.js 20+
• npm
• Git
• Bash-compatible shell (Git Bash on Windows)

Step 1: Install

npm install -g @rpamis/comet

Step 2: Initialize

cd your-project
comet init

The interactive prompt will:

1. Detect installed AI coding platforms
2. Ask for install scope — project-level or global
3. Ask for skill language (English or 中文)
4. Install OpenSpec skills
5. Install Superpowers skills
6. Deploy Comet skills to detected platforms
7. Create docs/superpowers/specs/ and docs/superpowers/plans/ directories

Step 3: Check Status

comet status

Shows active changes, task progress, and the recommended next workflow command.

Step 4: Keep Updated

comet update

Updates the npm package and refreshes installed skills across all detected platforms.

Deeper Analysis

Platform Detection

Comet’s auto-detection scans for platform-specific config directories:

| Platform | Config Dir | Platform | Config Dir | |---|---|---|---| | Claude Code | .claude/ | Cursor | .cursor/ | | Codex | .codex/ | OpenCode | .opencode/ | | Windsurf | .windsurf/ | Cline | .cline/ | | RooCode | .roo/ | Continue | .continue/ | | GitHub Copilot | .github/ | Gemini CLI | .gemini/ | | Amazon Q | .amazonq/ | Auggie | .augment/ |

This means you can switch between platforms freely and Comet keeps the same workflow available everywhere.

Spec-Driven Workflow

Comet’s workflow revolves around OpenSpec stages:

1. Spec: Write what you want to build
2. Plan: The agent creates an implementation plan
3. Build: The agent executes against the plan
4. Review: Manual review at key decision points

Comet’s skills auto-detect the current stage and surface the right tools, while keeping humans in the loop at decision nodes.

Non-Interactive Mode

For CI or scripting:

comet init --yes --scope project --skip-existing

And JSON output for programmatic consumption:

comet status --json
comet doctor --json

Practical Evaluation Checklist

• One-command setup across 28 AI coding platforms
• OpenSpec + Superpowers dual-workflow integration
• Auto-detects existing installations — no manual config
• Project vs global scope for flexible usage
• Auto-update mechanism keeps skills current
• JSON output for scripting and CI integration
• MIT licensed with no restrictions

Security Notes

• Comet installs files into local project directories — no code leaves your machine
• The skills it installs (OpenSpec, Superpowers) are open-source and auditable
• No telemetry in the Comet CLI itself
• Review skill contents before installing if working in sensitive environments

The Multi-Platform Development Reality

Most developers don’t use a single AI coding platform exclusively. You might use Claude Code for complex architecture work, Codex for rapid prototyping, and Cursor when you need a GUI. Each platform has strengths, and context-switching between them is the norm rather than the exception.

Comet’s value becomes clear in this multi-platform world. Without it, you’d need to configure OpenSpec and Superpowers separately for each platform — learn each platform’s skill installation method, manage version discrepancies, and remember which platform has which set of skills configured. With Comet, you run init once and all platforms are synchronized. The workflow is consistent regardless of which agent you’re using for a given task.

FAQ

Q: What if I only use one AI coding platform? A: Comet still adds value — it installs and configures OpenSpec and Superpowers automatically, saving you the manual setup. But its biggest benefit is multi-platform consistency.

Q: Can I use my own skills instead of Superpowers? A: Comet is currently focused on OpenSpec + Superpowers. For custom skill setups, you can still install them manually alongside Comet.

Q: Does comet init overwrite existing skills? A: By default, it skips existing installations. Use --overwrite to replace them or the interactive prompt to choose per component.

Q: What happens when Superpowers or OpenSpec update? A: Run comet update to pull the latest versions of both and deploy to all detected platforms.

Workflow: From Spec to Merged PR

A typical Comet-powered development cycle starts with running init to configure all 28 platforms with OpenSpec and Superpowers. You write a spec in the docs directory describing your feature. Any of your AI coding agents reads the spec, creates a plan, and starts implementing. Superpowers skills guide the agent through testing, debugging, and code review. Manual review at key decision points keeps you in control. When the spec is complete, the agent moves to the next one automatically.

This workflow means you can switch between Claude Code, Codex, Cursor, and Windsurf without losing your development context. Each agent picks up where the last one left off because the spec and plan files are platform-agnostic.

Enterprise Considerations

For teams, Comet’s global install scope creates consistency across all developers’ machines. Combined with the JSON output flags, you can script setup verification in CI: run doctor with JSON output and fail the build if skills aren’t correctly installed across the team.

Q: Does Comet conflict with manually installed skills? A: No. Comet installs into standard skill directories but doesn’t touch files it didn’t create. Manual skills coexist with Comet-managed skills. The doctor command helps identify conflicts and stale installations.

Conclusion

Comet is infrastructure for AI coding workflows — not glamorous, but essential if you juggle multiple platforms. The dual-star approach (OpenSpec for structure, Superpowers for capability) gives you a consistent development loop regardless of which agent you’re using on a given day. For teams standardizing on spec-driven AI development across diverse toolchains, Comet eliminates the per-platform setup tax.