Superconductor logo

Superconductor

Community
HazAT
superconductor

Operates the super.engineering/Superconductor `sc` CLI for app-managed agents, teams, sessions, layouts, worktrees, and review threads. Use when a workflow explicitly calls for SC orchestration or app-managed UI/session behavior.

Overview

PublisherHazAT
Repositorypi-config
Skill namesuperconductor
Stars
450
Forks
44
Bundled files
2
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 2 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by HazAT on GitHub. Read the source before you install it.

Installation

Install the Superconductor AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/HazAT/pi-config.git /tmp/pi-config
mkdir -p .claude/skills
cp -r /tmp/pi-config/skills/superconductor .claude/skills/superconductor
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Superconductor in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Superconductor on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Superconductor is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Superconductor CLI

Use live sc instructions and capability output as authoritative. Keep SC syntax and lifecycle policy here; role skills should reference this skill rather than reproduce commands.

Boundaries

  • Use SC only for the requested orchestration or app-managed outcome.
  • Require explicit human intent for worktree/branch creation or deletion, target-branch changes, force termination, destructive cleanup, closing/rearranging existing sessions, and unrelated review-thread mutations.
  • Never create a worktree merely for delegation or launch replacement agents for follow-ups.
  • Prefer stable labels or stable target IDs and --active keep.
  • Dispatch and idle state are not completion; always wait, read, and verify.

Live Preflight

Before the first mutation, run the matching guide:

AreaCommand
Agents, teams, delegationsc instructions orchestration
Tabs, panes, viewssc instructions layout
Worktrees or branchessc instructions worktree
In-app review threadssc instructions review

For orchestration, inspect current capabilities and targets:

bash
command -v sc
sc layout capabilities --output json
sc layout views --worktree "$PWD" --output json
sc agents list --worktree "$PWD" --output json
sc chat providers --json

Verify the launch shape, provider, UI mode, model, reasoning level, and structured-read support before specifying them. If unavailable, report the exact limitation instead of silently substituting another mechanism.

Read references/orchestration.md before launching or controlling sessions. Read references/worktrees-and-reviews.md before requested worktree or review-thread operations.

Individual Pi Worker

Delegated Pi sessions default to terminal mode. Long prompts should use a temporary JSONL launch input built with jq; it is command input, not durable workflow state, and must be removed after launch.

bash
sc layout run tabs \
  --provider pi --ui terminal \
  --label worker-TODO-001 \
  --prompt 'Complete prompt with task and absolute handover paths.' \
  --worktree "$PWD" --active keep --output json

Capture the returned label/stable target. Then collect that same target:

bash
sc agent wait --to label:worker-TODO-001 --idle --timeout-ms 120000 \
  --worktree "$PWD" --output json
sc agent read --to label:worker-TODO-001 --last 40 \
  --worktree "$PWD" --output json

Check reads for target/provider errors, incomplete output, and the evidence required by the prompt. Verify source-writing results independently with Git and tests. Run shared-checkout source writers sequentially.

Use sc agent send for clarification in the existing session. If a turn must be redirected, interrupt then send. Do not infer success from launch, queue admission, or idle state.

Independent Teams

Use sc team run only for genuinely independent fan-out whose roles do not require per-role UI or model overrides:

bash
sc team run \
  --label correctness --provider pi --prompt 'Independent read-only review prompt.' \
  --label regressions --provider pi --prompt 'Independent read-only review prompt.' \
  --worktree "$PWD" --output json

sc team run currently has no per-role --ui, --model, or --reasoning flags. When an ensemble requires distinct Pi models or Pi Chat UI, launch individually labeled sessions with sc layout run tabs, wait/read their stable targets, and fan their reports into the designated lead session. Do not claim those sessions are an SC team run or instruct them to call sc team report.

Every team prompt must include its task, absolute handover paths, read/write limits, and this completion contract:

bash
sc team report --run RUN_ID --role ROLE --status done \
  --summary 'Concise evidence-based report.' --worktree "$PWD" --output json

Use --result-file only when a detailed report exceeds the summary limit; do not use it for the session-file workflow. In a synchronous workflow, capture the returned stable role targets, wait for them, then collect the durable reports with sc team status. Once every role is Reported, use those report summaries directly; call sc agent read only for a missing, failed, or malformed report.

Do not pass --notify self when the coordinator waits synchronously. That option inserts the team synthesis into the creator's editor as a follow-up prompt and may require the user to submit it. Use it only for an explicitly asynchronous workflow, end the coordinator turn after launch, and explain that behavior to the user. Never combine it with manual wait/status collection. Team launch provides parallelism, not sequencing.

Session-File Handover

For /plan, /todos, /execute, and /review:

  • A coordinator session file is required: PI_SESSION_FILE in Pi, or $HOME/.claude/projects/<project slug>/$CLAUDE_CODE_SESSION_ID.jsonl in Claude Code (slug = the project directory path with / and . mapped to -).
  • Durable handover files are exactly ${SESSION_FILE%.jsonl}.plan.md, ${SESSION_FILE%.jsonl}.todos.md, and ${SESSION_FILE%.jsonl}.review.md.
  • /review may use the session JSONL and Git state without plan or todos files; include either handover when it exists.
  • The coordinator alone writes these files.
  • Delegated prompts receive the resolved absolute paths and read them directly.
  • Do not create sidecar directories, repository run stores, membership records, coordination-state mirrors, or custom JSONL state.

Managed Terminal Title

In a managed Pi terminal:

bash
sc tab title "$TITLE" --to "id:terminal:$SUPERCONDUCTOR_TERMINAL_ID" --json

Verify response.new_title. Do not omit the stable target.

Cleanup

Do not stop agents, close tabs/views, delete groups, or remove other managed state unless the human requested cleanup. Inspect exact targets and current help before any such operation.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Superconductor AI skill do?

Operates the super.engineering/Superconductor `sc` CLI for app-managed agents, teams, sessions, layouts, worktrees, and review threads. Use when a workflow explicitly calls for SC orchestration or app-managed UI/session behavior.

Why use Superconductor on TypingMind?

Because you install it once and use it with any model. Superconductor is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Superconductor in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/HazAT/pi-config/tree/main/skills/superconductor. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Superconductor?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Superconductor?

As many as you like. As long as a model supports skills, you can use Superconductor with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Superconductor AI skill free?

Yes. It is published on GitHub by HazAT under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇