superclaude

Shape how Claude Code works.

superclaude is an independent Claude Code content framework: commands, agents, modes, rules, and hooks installed into a scope you choose.

Get started Explore the GitHub repository ↗
Content + scope
CommandsSlash commands for planning, implementation, review, and more.
AgentsDomain-specific roles for delegated work.
ModesBehavioral guidance selected by context.
HooksSession and tool boundaries that enforce workflow rules.
CLIInstall at user, project, or local scope.

A content framework for Claude Code

The CLI copies framework files into Claude Code's content directories. Claude Code reads them at session start; the framework does not run a proxy or daemon.

Workflows you can invoke

Use /sc:brainstorm, /sc:plan, /sc:implement, and /sc:review across the development cycle.

Specialized agents and modes

Agent definitions and behavioral modes supply task-specific instructions when Claude Code loads the installed content.

Hook-enforced rules

Hooks help preserve workflow rules across sessions and tool calls while the installer merges with existing hook settings.

Optional integrations

The core works without MCP servers. Add supported integrations separately when a task needs them.

Install the CLI and content

No clone needed. Install uv if you don't have it, install the CLI from the latest release with it, then install the framework content into a scope.

@stable always points at the latest release. To pin one, replace it with that release's tag, @v<version>.

This runs the release unchanged. To edit your own copy, see Clone install, or Fork install to keep that copy on GitHub.

Full installation and scope options ↗

  1. Install uv

    Skip this step if uv --version already works. Otherwise run the line for your OS, then open a new terminal.

    macOS / Linux

    curl -LsSf https://astral.sh/uv/install.sh | sh

    Windows

    powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

  2. Install the CLI

    uv tool install -p 3.13 git+https://github.com/ajitta/superclaude.git@stable

    If your shell then can't find superclaude, run this and open a new terminal:

    uv tool update-shell

  3. Install the content

    superclaude install --scope user

    For a committed team install, or personal files inside one project, run one of these in the project instead:

    superclaude install --scope project
    superclaude install --scope local

  4. Restart Claude Code

    Then run /sc:help to list the commands.

Update to a new release

Upgrade the CLI, then refresh each scope you installed:

uv tool upgrade superclaude
superclaude update --scope user

Clone install

Run your own copy from a local clone and edit the commands, agents, modes, or rules. The content is markdown under src/superclaude/. No GitHub account is needed, and every step needs only git, uv and the superclaude CLI. To keep your copy on GitHub, see Fork install.

Full guide in the README ↗

  1. Clone the repository

    This starts from the latest release.

    git clone -b stable https://github.com/ajitta/superclaude.git
    cd superclaude

  2. Set up the environment

    uv venv -p 3.13
    uv pip install -e ".[dev]"

    Don't run uv sync: it removes the dev tools installed above, and the tests stop running.

  3. Run the CLI from your clone

    uv tool install --force --editable .

    superclaude now reads your clone, so later edits need no reinstall, but moving or deleting the clone breaks the CLI and its hooks. If you installed the release before, this replaces it.

  4. Install the content

    superclaude install --scope user

    For a committed team install, or personal files inside one project, run it in that project with --scope project or --scope local. Restart Claude Code afterwards.

  5. Edit, then sync into a scope

    After changing files under src/superclaude/, copy them into the scope you use, then restart Claude Code. For a project or local install, run it in that project with --scope project or --scope local.

    superclaude update --scope user

  6. Run the tests

    The markdown is tested too (counts, cross-references, structure), so run them after content edits as well.

    uv run pytest

Update to a new release

Commit your edits, then merge the new release into your clone. Resolve any conflicts with your changes, reinstall the CLI in case dependencies changed, and refresh each scope you installed:

git pull --no-rebase origin stable
uv tool install --force --editable .
superclaude update --scope user

Fork install (recommended)

A clone install whose copy lives in your own GitHub fork: your edits are backed up, and you can use the same copy on every machine. Follow Clone install with these changes.

Full guide in the README ↗

  1. Fork the repository

    Fork it on GitHub before you clone. Copying only the stable branch, the default, is enough.

  2. Clone your fork instead

    git clone https://github.com/<your-account>/superclaude.git
    cd superclaude

  3. Push your edits

    After committing your edits, push them to your fork:

    git push

Update to a new release

Add this repository as upstream once, then pull new releases from it instead of origin:

git remote add upstream https://github.com/ajitta/superclaude.git
git pull --no-rebase upstream stable
uv tool install --force --editable .
superclaude update --scope user

Try a command

After restarting Claude Code, begin with a specific task or use /sc:help to see the available commands.

/sc:brainstorm

Explore an underspecified request.

/sc:plan

Turn a task into an implementation plan.

/sc:implement

Work through the implementation.

/sc:review

Review code, a plan, or a design.

Ask what to do next

Claude Code's /btw asks a side question. It answers from the conversation so far, works while Claude is still busy, and never enters the conversation history. It has no tools, so it answers only from what the session already holds:

/btw based on what we just did, which /sc command should I run next, and why?

Run a command toward a goal

Claude Code's /goal sets a completion condition, and Claude keeps working turn after turn until a separate model judges it met. The condition is also Claude's first instruction, so a command named in it runs as part of the goal:

/goal sc:review the current diff, fix every finding, and review again until it reports none

Run /goal alone to check progress, or /goal clear to stop early.

Go from intent to done in one prompt

/sc:intent --through records your five lines word for word, then runs brainstorm, spec review, design, plan, implement, branch review, test and reflect on a feature/<slug> branch, committing each step. It asks nothing: each choice takes the recommended option and is recorded as delegated for an independent audit. It never merges or pushes. Add --ask to answer, once after discovery, the up to four questions that change what you get. Start Claude Code with claude --permission-mode auto:

/sc:intent --through Problem: what cannot be done today Proposed outcome: what better looks like Affected users and systems: who and what Constraints: limits Done when: how you will know it worked

Wrap it in /goal to restart the run if it stops early, and add a line saying that --through is the approval for every step; without it, the evaluator can wait on the commands' own confirmation steps. The full recipe is in the README.

About this project

This ajitta repository began as a fork of SuperClaude Framework and has since diverged into an independent project. It does not share a roadmap or maintainers with upstream and is not affiliated with or endorsed by Anthropic.