> ## Documentation Index
> Fetch the complete documentation index at: https://mintlify.com/mridullpandey/superpowers/llms.txt
> Use this file to discover all available pages before exploring further.

# Quickstart

> See Superpowers skills activate in a real session and learn how to trigger them manually on any platform.

This guide assumes you've completed [installation](/installation). Skills activate automatically — you don't need to do anything special. This page shows you what to expect and how to verify things are working.

## Skills activate automatically

When you start a session with Superpowers installed, the `using-superpowers` skill is discovered immediately. From that point, your agent checks for relevant skills before every response and every action. You don't invoke skills yourself — the agent does.

<Note>
  The rule is strict: if there is even a 1% chance a skill applies to what the agent is doing, it **must** invoke that skill before responding. This is not optional behavior — it's enforced by the `using-superpowers` skill itself.
</Note>

## Example prompts that trigger skills

Try any of these in a new session to see skills activate:

| What you say | Skill triggered |
| - | - |
| "Help me plan this feature" | `brainstorming` |
| "Fix this bug" | `systematic-debugging` |
| "Let's start implementing" | `test-driven-development` |
| "Review what I've built so far" | `requesting-code-review` |

## A real example: building a feature

Here's what a typical session looks like from the moment you describe something to build.

<Steps>
  <Step title="You describe what you want to build">
    You say something like: "I want to add rate limiting to our API."

    The agent recognizes this as a new feature request and invokes the `brainstorming` skill before doing anything else.
  </Step>

  <Step title="The agent asks questions one at a time">
    The `brainstorming` skill instructs the agent to ask clarifying questions one at a time — never all at once. For example:

    > "What kind of rate limiting are you thinking — per user, per IP, or per API key?"

    After you answer, it asks the next question. This continues until the agent has enough to propose a design.
  </Step>

  <Step title="The agent proposes 2–3 approaches with trade-offs">
    Once it understands the problem, the agent presents two or three concrete design options with trade-offs — not a single recommendation with assumed requirements. You choose the direction.
  </Step>

  <Step title="The agent presents the design in sections for your approval">
    Rather than dumping a wall of spec text, the agent presents the design in short, digestible sections and waits for your sign-off on each. When you approve, it saves the spec to a file.
  </Step>

  <Step title="The agent writes a detailed implementation plan">
    The `writing-plans` skill produces a task list where every item is scoped to 2–5 minutes of work, includes exact file paths, complete code, and explicit TDD steps. No placeholders.
  </Step>

  <Step title="Execution begins with subagents and strict TDD">
    The `subagent-driven-development` and `test-driven-development` skills run together during implementation. Each task gets a fresh subagent context. Tests come before code, every time.
  </Step>
</Steps>

## Manually invoking a skill

Skills are designed to activate automatically, but you can also invoke them by name if you want to jump directly into a specific workflow.

<Tabs>
  <Tab title="Claude Code">
    Use the `Skill` tool. In your conversation, you can direct the agent:

    ```text theme={null}
    Use the brainstorming skill to help me think through this design.
    ```

    Or the agent will invoke it via the `Skill` tool directly when it detects the context matches.
  </Tab>

  <Tab title="OpenCode">
    Use OpenCode's native `skill` tool. You can say:

    ```text theme={null}
    use skill tool to load superpowers/brainstorming
    ```

    To see all available skills first:

    ```text theme={null}
    use skill tool to list skills
    ```
  </Tab>

  <Tab title="Gemini CLI">
    Skills are loaded via the `activate_skill` tool. You can ask the agent directly:

    ```text theme={null}
    Activate the brainstorming skill and help me plan this feature.
    ```

    Gemini CLI loads skill metadata at session start, so the agent already knows which skills are available.
  </Tab>

  <Tab title="Cursor">
    In Cursor agent chat, describe what you want and the agent will invoke the relevant skill automatically. You can also be explicit:

    ```text theme={null}
    Use the systematic-debugging skill to help me track down this issue.
    ```
  </Tab>

  <Tab title="Codex">
    Skills are discovered automatically from `~/.agents/skills/superpowers`. You can activate one by name:

    ```text theme={null}
    Use the brainstorming skill.
    ```

    Codex parses skill descriptions at startup and activates the full content on demand.
  </Tab>
</Tabs>

## Verify the agent is following skills

After your first session, look for these signs that Superpowers is working:

* The agent **asks questions before writing code** — brainstorming is active.
* The agent **writes a failing test before any implementation** — TDD is active.
* The agent **announces which skill it's using** before beginning a workflow.
* The agent **blocks on critical review findings** rather than moving forward.

<Warning>
  If the agent jumps straight to writing code without asking any questions, skills may not be loading. Run `Tell me about your superpowers` to verify installation, or check the troubleshooting section in the [installation guide](/installation).
</Warning>

## Next steps

<CardGroup cols={2}>
  <Card title="The Workflow" icon="diagram-project" href="/workflow/overview">
    Understand the full seven-step development loop from idea to merged branch.
  </Card>

  <Card title="Skills Reference" icon="book-open" href="/skills/test-driven-development">
    Explore every skill: TDD, debugging, subagent orchestration, code review, and more.
  </Card>
</CardGroup>


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.