Superpowers framework: TDD workflows for coding agents

Top AI agents now exceed 80% on SWE-bench Verified, yet most still lack a structured approach to autonomous engineering. The Superpowers framework solves this by enforcing a rigid subagent-driven development cycle that prioritizes specification validation before code generation. Published by Hermes Atlas, this methodology transforms coding agents from impulsive text generators into disciplined engineers capable of executing red/green TDD workflows without constant human intervention.

The system operates by extracting user requirements into chunked specifications, ensuring alignment before an implementation plan is formed for even the most inexperienced engineer to follow. Once activated, the framework launches autonomous subagents that inspect and review work, often running for hours without deviating from the agreed design. This approach integrates YAGNI and DRY principles directly into the agent's operational logic, preventing the bloat and hallucination common in unguided AI coding sessions.

Agentic skills redefine modern software development methodology by replacing ad-hoc prompting with composable skill libraries. Installation differs per tool: Cursor, Claude Code, and GitHub Copilot CLI each need their own setup, and the commands appear below.

The Role of Agentic Skills in Modern Software Development Methodology

Superpowers Framework as an Agentic Skills System

Superpowers emerged on 9 Oct 2025 as a distinct methodology for coding agents, published by Hermes Atlas. The system relies on composable Agent Skills that function as portable artifacts holding instructions, code templates, and verification logic. These components alter agent behavior during inference, enabling flexible loading of procedural knowledge without model retraining or parameter updates. Such an architecture moves development away from purely model-centric improvements toward context-centric augmentation, formalizing capabilities into an emerging open standard.

Simple code helpers lack this discipline, whereas the framework enforces a strict workflow where agents execute subagent-driven development cycles. Brainstorming, planning, and rigorous test-driven development (TDD) phases occur before any implementation begins. Packaging company-specific context and verification logic into reusable folders addresses reliability gaps common in autonomous agents. A dependency on initial skill definition quality exists alongside these benefits. Poorly constructed templates propagate errors across downstream tasks just as effectively as correct logic. Operational burden shifts from tuning model weights to curating high-fidelity instruction sets and maintaining the library of composable skills. Agents work autonomously for extended periods while adhering to a validated plan, turning unstructured generation into a repeatable engineering process.

Subagent-Driven Development and TDD Workflows

Execution starts when the agent extracts a specification before writing code. Immediate implementation does not happen. The system queries the user to define boundaries, ensuring the resulting plan adheres to YAGNI principles. This initial constraint prevents scope creep during autonomous execution phases. The framework mandates Test-Driven Development workflows where agents generate failing tests prior to logic insertion. This red-green-refactor cycle operates within isolated worktrees, maintaining a clean baseline throughout the session. Rigid sequencing allows agents to work autonomously for hours without deviating from the approved design.

Strict linearity increases upfront latency because the agent cannot skip the design validation step even for trivial fixes. Builders must weigh the cost of initial deliberation against the risk of plan deviation in complex repositories. The implementation plan serves as the single source of truth, binding the subagent to the original intent.

Context-Centric Augmentation vs Model Retraining

Flexible loading of procedural knowledge avoids expensive retraining cycles. This architecture injects company-specific context and verification logic at inference time by treating capabilities as portable artifacts. Formalizing agent capabilities into an emerging open standard solves reliability gaps. Substantial implementations now apply organized folders containing instructions that agents discover and load dynamically to extend capabilities without model retraining. Industry preference has shifted from purely model-centric improvements to augmenting agents with procedural knowledge via Skills.

Base model generalization conflicts with task-specific precision. Relying solely on larger parameter counts fails to address domain-specific verification logic required for autonomous execution. Operators must manage skill versioning separately from model weights to maintain consistency. This separation enables rapid iteration on workflows while keeping the underlying model static. Builders gain the ability to patch agent behavior instantly rather than waiting for next-generation model releases. Skills do not emerge spontaneously from scaling laws, so they must be explicitly curated.

Inside the Subagent Workflow and Test-Driven Execution Cycle

The Mandatory Brainstorming Skill and Design Phase

Superpowers operates as a complete software advancement methodology for coding agents, built on composable skills and initial instructions ensuring their usage. The process begins the moment a coding agent starts. Instead of jumping into code, the agent steps back to ask what the user is truly trying to do. Once teased from the conversation, the spec appears in chunks short enough to actually read and digest.

Explicit validation converts rough ideas into clear specifications, moving away from ad-hoc prompting patterns lacking context. This distinct design sign-off guarantees the subsequent implementation plan remains actionable for downstream executors. The resulting plan is clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow. Such rigorous upfront definition serves as the single source of truth, emphasizing true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY principles.

How Subagents Review Their Own Work

Saying "go" launches the subagent-driven-development process. Each subagent inspects and reviews its own output before moving on, so the finished work still matches the design intent fixed during specification. Builders get a verifiable process where every step corresponds to the validated specification.

Two-Stage Code Review and Progress Blocking Rules

Workflows for code review exist within the composable skills library. The process dispatches subagents per task with a two-stage review focusing first on spec compliance and then on code quality. This mechanism enforces a verification process where validation occurs against the approved plan before further execution proceeds.

Specification drift does not compound across multiple subagent tasks because of this constraint. Autonomous agents often accumulate minor deviations without it, resulting in significant architectural inconsistencies by the final merge. The system activates requesting-code-review between tasks to review work against the plan, ensuring critical issues block progress until resolved.

Skills trigger automatically, requiring no special action from the user. Your coding agent simply has Superpowers. This automation prioritizes correctness and alignment with user intent throughout long-running development sessions. Once design approval is granted, the system activates using-git-worktrees to create isolated workspaces and verify test baselines.

Installing Superpowers Across Cursor, Claude Code, and GitHub Copilot CLI

Superpowers Installation Commands for Cursor and Claude Code

Install Superpowers on Cursor by entering /add-plugin superpowers within the Agent chat interface or searching the integrated marketplace. This method uses the editor's native ability to load agent skills from external collections, ensuring the framework's subagent-driven workflows activate immediately upon session start. For Claude Code, operators have two distinct paths depending on their trust model and update requirements. The official Anthropic marketplace offers a verified channel using the command /plugin install superpowers@claude-plugins-official. Alternatively, teams requiring direct access to the latest framework iterations can register the Superpowers marketplace via /plugin marketplace add obra/superpowers-marketplace followed by /plugin install superpowers@superpowers-marketplace.

Selecting the custom registry for Claude Code bypasses official review cycles, which accelerates access to new TDD features but introduces a dependency on the external repository's availability. Operators must install the plugin separately for each tool, as the skills framework does not share state between distinct agent environments. This isolation prevents cross-contamination but requires maintaining consistent versions across tools manually. The installation process injects a bootstrap sequence that enforces planning before code generation, fundamentally altering the agent's default behavior from immediate execution to structured analysis.

Executing CLI Setup for Antigravity and GitHub Copilot

Install Antigravity by running agy plugin install obra/superpowers to load the framework directly from the repository. This command triggers a session-start hook that activates immediately, enforcing structured planning before any code generation begins. Unlike manual configuration files, this hook ensures the subagent-driven workflow loads automatically without requiring users to remember specific trigger phrases or context flags. The installation process for GitHub Copilot CLI requires a two-step registration to access the extended marketplace where the plugin resides. First, register the source using copilot plugin marketplace add obra/superpowers-marketplace, then execute copilot plugin install superpowers@superpowers-marketplace to deploy the skills package.

Distinct installation procedures require separate setup for every active coding agent.

1. Verify Superpowers exists in each environment, as sharing state between Cursor and Claude Code is unsupported.
2. Confirm the session-start hook executes automatically to enforce planning before code generation begins.
3. Validate that the planning workflow triggers correctly during the initial design phase.
4. For updates, contributors must fork the repository and switch to the dev branch.
5. Adhere to the writing-skills guide to ensure compatibility across all supported platforms.

The cost of skipping validation is silent plan deviation, where agents ignore constraints without raising errors. Reusable agent skills reduce engineering redundancy but demand strict isolation per use to prevent context leakage. AI Agents News recommends running the full test suite after every plugin update to maintain architectural integrity.

Enterprise Viability and Strategic Adoption of Agentic Frameworks

Defining Enterprise Viability via SWE-bench Verified Metrics

Real-world complexity validates enterprise adoption far better than synthetic prompts ever could. The SWE-bench Verified benchmark supplies this necessary rigor by testing agents against actual GitHub issues, establishing a credible baseline for production readiness. This metric directly addresses the question of whether to use Superpowers for enterprise projects by confirming its alignment with high-performance agentic workflows.

High benchmark scores do not guarantee smooth integration without proper governance. A gap exists between solving isolated issues and maintaining long-term architectural coherence across a monorepo. Prime Radiant offers commercial support and additional tooling for organizations requiring guaranteed uptime and managed spending. Viability depends on verifiable performance metrics combined with the support structures.

Deploying Prime Radiant Commercial Support and Managed Tooling

Enterprises evaluating Superpowers for production deployments can turn to Prime Radiant for commercial support and managed spending controls. The framework addresses this gap by offering additional tooling designed specifically for organizational governance and audit compliance. Accessing these enterprise-grade capabilities requires direct coordination with the development team rather than a self-service portal. Coverage spans specific implementation requirements, custom skill curation, and volume licensing arrangements.

The absence of an automated provisioning system for corporate accounts limits immediate adoption. Organizations cannot instantly generate invoices or assign seat licenses through a dashboard; instead, they must rely on the established communication channel to finalize agreements. This friction ensures that every deployment receives specific architectural review, preventing misconfiguration in critical environments.

Balancing Agent Autonomy with Telemetry Opt-Out Protocols

Strict telemetry boundaries allow enterprises to deploy Superpowers securely while excluding sensitive project details. The framework transmits only version information during operation, ensuring that prompts, coding agent data, and proprietary logic remain entirely local to the development environment. This telemetry does not include project details, prompts, or coding agent data. This limited data scope addresses core compliance concerns regarding intellectual property exposure in generative AI workflows. Administrators retain full control over network traffic, as the telemetry feature is 100% optional and requires no inbound connections.

Setting the SUPERPOWERS_DISABLE_TELEMETRY environment variable to any true value within the host system disables data transmission. The framework also respects existing opt-out configurations for Claude Code, specifically honoring the DISABLE_TELEMETRY and CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC flags to prevent conflicting network requests. This dual-layer approach allows organizations to maintain centralized policy enforcement without modifying individual agent harnesses or disrupting the execution cycle.

Teams can use advanced company-specific context packaging without triggering external data flows that violate internal security perimeters. Unlike open repositories containing thousands of community skills, enterprise deployments often require deterministic network behavior where every outbound packet is accounted for. Isolating telemetry to a simple version check that can be nullified via environment variables supports high-assurance environments where agent autonomy must not compromise network segmentation strategies.

References

• Devin 🚀 [Cloud] [GitHub] - Fully autonomous AI software
• SWE-bench Verified tests agents against real GitHub issues, and
• GitHub Copilot | GitHub-native teams | Free to $39/mo