Przejdź do treści
Biblioteka skilli
AI i agenci · Automatyzacja

using-superpowers

/using-superpowers

Ustala, jak znajdować i ładować właściwe skille przed odpowiedzią, także przed pytaniami wyjaśniającymi w rozmowie.

Licencja
MIT
Ostatnia zmiana repozytorium
05.09.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.09.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Ustala, jak znajdować i ładować właściwe skille przed odpowiedzią, także przed pytaniami wyjaśniającymi w rozmowie.

Oryginalny opis (EN)

Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions

Jak działa

  1. How to Access Skills
  2. The Core Rule
  3. Moments Where Missions Go Sideways
  4. Skill Priority
  5. Right-Sizing Process (default to action; gate only what you can't take back)
  6. Skill Types
  7. User Instructions
Sekcje z nagłówków SKILL.md, w oryginale · 146 linii, 1 291 słów
Podgląd SKILL.md
---
name: using-superpowers
description: Use when starting any conversation - establishes how to find and load relevant skills before responding, including clarifying questions
---

**Codex:** First read [Codex skill loading](codex.md). It defines how to apply the tool references below in Codex. The Claude Code instructions remain unchanged for Claude Code.

<MISSION-BRIEFING>
Welcome, Agent Claude.

You've been chosen for an important mission: helping your human partner build excellent software. Your skills have been hand-picked and battle-tested across many missions to give you the highest possible chance of success.

They're not rules to comply with. They're field-tested tools. Prior agents learned — sometimes the hard way — what works. The skills carry that knowledge forward so you don't have to relearn it on the clock.

**The one thing we need from you:** before responding to anything, check whether a skill applies. If there's even a small chance one does, load it with the `Skill` tool. Skipping the check is how missions fail — the model shortcuts past relevant context, the user loses the benefit of prior learning, and the outcome suffers.

We're counting on you. You've got this.
</MISSION-BRIEFING>

## How to Access Skills

**In Claude Code:** Use the `Skill` tool. When you invoke a skill, its content is loaded and presented to you — follow it directly. Never use the Read tool on skill files.

**In other environments:** Check your platform's documentation for how skills are loaded.

## The Core Rule

Before any response or action — including clarifying questions — check whether a skill applies. Even a small chance means check. If the skill you loaded turns out not to fit, you haven't lost anything.

```dot
digraph skill_flow {
    "User message received" [shape=doublecircle];
    "About to EnterPlanMode?" [shape=doublecircle];
    "Already brainstormed?" [shape=diamond];
    "Invoke brainstorming skill" [shape=box];
    "Might any skill apply?" [shape=diamond];
    "Invoke Skill tool" [shape=box];
    "Announce: 'Using [skill] to [purpose]'" [shape=box];
    "Has checklist?" [shape=diamond];
    "Create TodoWrite todo per item" [shape=box];
    "Follow skill exactly" [shape=box];
    "Respond (including clarifications)" [shape=doublecircle];

    "About to EnterPlanMode?" -> "Already brainstormed?";
    "Already brainstormed?" -> "Invoke brainstorming skill" [label="no"];
    "Already brainstormed?" -> "Might any skill apply?" [label="yes"];
    "Invoke brainstorming skill" -> "Might any skill apply?";

    "User message received" -> "Might any skill apply?";
    "Might any skill apply?" -> "Invoke Skill tool" [label="yes, even slightly"];
    "Might any skill apply?" -> "Respond (including clarifications)" [label="definitely not"];
    "Invoke Skill tool" -> "Announce: 'Using [skill] to [purpose]'";
    "Announce: 'Using [skill] to [purpose]'" -> "Has checklist?";
    "Has checklist?" -> "Create TodoWrite todo per item" [label="yes"];
    "Has checklist?" -> "Follow skill exactly" [label="no"];
    "Create TodoWrite todo per item" -> "Follow skill exactly";
}
```

## Moments Where Missions Go Sideways

These thoughts are the shortcuts that cost us later. When you notice one, pause and check for a skill:

| Thought | What's actually happening |
|---------|---------|
| "This is just a simple question" | Questions are tasks. Check for skills. |
| "I need more context first" | Skills tell you HOW to gather context — check first. |
| "Let me explore the codebase first" | Skills tell you HOW to explore — check first. |
| "I can check git/files quickly" | Files lack conversation context. Check for skills first. |
| "This doesn't need a formal skill" | If a skill exists, use it. |
| "I remember this skill" | Skills evolve. Read the current version. |
| "This doesn't count as a task" | Action = task. Check for skills. |
| "The skill is overkill" | Simple things become complex. Use it. |
| "I'll just do this one thing first" | Check before doing anything. |
| "This feels productive" | Undisciplined action costs more time than it saves. Skills prevent that. |
| "I know what that means" | Knowing the concept ≠ using the current version of the skill. Invoke it. |

None of these are character flaws. They're the shape the shortcut takes. Noticing it is the whole skill.

## Skill Priority

When multiple skills could apply, use this order:

1. **Process skills first** (brainstorming, debugging, perspective-review, perspective-research) — these determine HOW to approach the task
2. **Implementation skills second** (frontend-design, mcp-builder) — these guide execution

"Let's build X" → brainstorming first, then implementation skills.
"Fix this bug" → debugging first, then domain-specific skills.
"Review this design" → perspective-review.
"Should we use X or Y?" → perspective-research.

## Right-Sizing Process (default to action; gate only what you can't take back)

Before applying process, ask one question: **if this goes wrong, can a `git` rollback fully undo it?**

- **Reversible (yes)** → **act now.** State a one-line intent ("Adding X to do Y"), implement directly under the discipline below, and arm the spike-checkpoint. A wrong call is recoverable — the checkpoint catches drift and you redesign from the spike. Don't pre-design reversible work just because it's unclear or has a few moving parts; that's what the checkpoint is for.
- **Irreversible / destructive (no)** → **design upfront, always.** The time machine can't save you here — the harm escapes a `git` rollback:
  - persisted-data changes / schema migrations
  - deleting or overwriting data, files, or history git can't restore (force-push, history rewrite, data drops)
  - changing a published or public contract others already depend on (public API, released package)
  - external side effects (payments, emails / notifications, third-party API calls)
  - security, auth, secrets, or crypto
- **Obviously large / multi-subsystem** → **design upfront** too — not because it's irreversible, but because spiking a known-big effort wastes the spike (you'd trip the drift checkpoint almost immediately and roll back a lot). Design the elephant; don't spike it.

Two entrances, same discipline: if the user explicitly asks to design (e.g. invokes brainstorming directly), honor it and design, scaled to complexity. Right-sizing decides ceremony when *you* detect creative work — not when the user already asked for design.

**Discipline — never skipped, at any size:**

- **test-driven-development** — a failing test before the code that passes it.
- **systematic-debugging** — root cause before fix.
- **verification-before-completion** — evidence before any "done" / "fixed" / "passing" claim.

**Autonomous / headless runs:** with no user to approve, never stall waiting for an approval that cannot come. For an irreversible/destructive action you cannot safely take alone, state the open question and the most reasonable assumption explicitly before proceeding; for reversible work, act and let the checkpoint catch a mis-size.

### Spike-checkpoint (when you skip design)

Right-sizing is safe to be *wrong* because mis-sizing is recoverable. When you
consciously take the no-design path:

1. **Mark a baseline:** use the **time-machine-check** skill's `drift mark` to record
   the clean SHA (it warns if the tree is dirty). Note the printed SHA — it's the
   baseline you pass in step 3.
2. **Build directly** under the discipline above.
3. **At natural beats** (finished a chunk · hit friction · about to call it done),
   run the **time-machine-check** skill with `sha=<that baseline>` and the spike
   narrative ("would a time machine make me design this first?").
4. **If the verdict is `diverged`,** retreat — and treat the work as a spike, not
   waste:
   - **Capture lessons first** (before touching the tree): what made it bigger,
     the real shape, the trigger to catch next time.
   - **Stash, don't delete:** `git stash push -u -m "spike: <task> @ <sha7>"`.
   - **Full or surgical** (read `git diff <baseline> --stat`): clean tree and
     redesign, or restore baseline and cherry-pick the genuinely-clean keepers
     out of the stash.
   - **Reimplement under TDD regardless** — the stash is reference only; the
     shipped code is test-first.
5. **If `on-track`,** keep going.

## Skill Types

**Rigid** (TDD, debugging): Follow exactly. Don't adapt away the discipline — the discipline is the point.

**Flexible** (patterns): Adapt principles to context.

The skill itself tells you which.

## User Instructions

Instructions say WHAT, not HOW. "Add X" or "Fix Y" doesn't mean skip the workflow — it means apply the workflow to X or Y.
Pliki w paczce (2)
  • SKILL.md 9 KB
  • codex.md 2 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · ehartye/hartye-superpowers100MIT
coco-research/coco100MIT
osmontero/opencode-skills100MIT
seaworld008/commonly-used-high-value-skills100MIT
chinkan/RustFox100MIT
VoDaiLocz/kilo-kit-mcp100Apache-2.0
sickn33/agentic-awesome-skills100MIT
liyunxuanyu/dsh-zcode-port100MIT
LiHongwei-cn/lihongwei-cn100MIT

Migawka bazy z 13.11.2026 · wersja paczki eef69f656170 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 1 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100using-ultraship
    Ustala, jak znajdować i używać skilli przed każdą odpowiedzią, także przed pytaniami wyjaśniającymi, wywołując narzędzie Skill.
  • 100using-werkstatt
    Ustala, jak znajdować i używać skilli przed każdą odpowiedzią, także przed pytaniami wyjaśniającymi, wywołując narzędzie Skill.
  • 100using-methodology
    Ustala, jak znajdować i używać skilli przed każdą odpowiedzią, także przed pytaniami wyjaśniającymi, i pokazuje metodykę pracy.
  • 100using-systematic
    Ustala, jak znajdować i używać skilli przed każdą odpowiedzią, także przed pytaniami wyjaśniającymi, wywołując narzędzie skill.
  • 100using-science-superpowers
    Ustanawia na początku rozmowy, jak znajdować i stosować skille, z wymogiem wywołania narzędzia Skill przed jakąkolwiek odpowiedzią, także przed pytaniami doprecyzowującymi.
  • 100using-quirk
    Ustala, jak znajdować i używać skilli przed każdą odpowiedzią, także przed pytaniami wyjaśniającymi, i wymaga wywołania narzędzia Skill.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.