Salta al contenuto principale

Superpowers di obra: cosa contiene e come si installa

Superpowers è un metodo fatto di skill per Claude Code: come si installa, quali skill contiene davvero e come controllare le descrizioni che scrivi tu.

Cosa ne pensi di questo articolo?

Superpowers di obra: cosa contiene e come si installa
Sub-pageFoto:PixabayPexels

In Breve

Superpowers è un metodo fatto di skill per Claude Code: come si installa, quali skill contiene davvero e come controllare le descrizioni che scrivi tu.

Se ogni volta che chiedi a un assistente di correggere un bug devi ripetergli di cercare prima la causa, o di scrivere il test prima del codice, stai pagando a mano ciò che una skill può imporre da sola. Superpowers, il progetto di obra, è un insieme di skill di questo tipo per Claude Code: non un catalogo da sfogliare, ma un metodo di lavoro che l'assistente applica quando la situazione lo richiede. Qui ti dico che cosa contiene davvero, come si installa e dove ho visto le skill funzionare o non funzionare.

Indipendenza: non sono affiliato a obra né a Anthropic, e non ci sono link di affiliazione. Le affermazioni sul progetto vengono dal suo repository e dalla documentazione di Claude Code, lette il 2026-11-13; quando racconto un'esperienza mia la dichiaro come racconto, senza percentuali. Per il quadro generale della serie parti dalla guida di apertura; qui resta fuori Get Shit Done, che ha la sua pagina.

Che cos'è Superpowers, senza la parola marketplace

Il README lo descrive come una metodologia di sviluppo completa per gli assistenti di programmazione, costruita su skill componibili e su istruzioni iniziali che fanno sì che l'assistente le usi. Il repository è pubblicato con licenza MIT. Il marketplace, che spesso si usa come sinonimo, è un'altra cosa: è soltanto il canale da cui il plugin si installa, e il plugin contiene le skill. La differenza conta perché cambia l'aspettativa: non scegli skill una per una da uno scaffale, installi un metodo in cui le skill si richiamano a vicenda.

Le skill della versione 5.1.0, quella installata sulla macchina dove ho preparato l'articolo, sono quattordici, e il README ne aggiunge una quindicesima, diagnosing-superpowers, che nella 5.1.0 non c'è. Si dividono in tre famiglie: collaborazione (progettare, pianificare, eseguire, rivedere, chiudere un ramo), prova e debug (TDD, debug sistematico, verifica prima di dichiarare finito) e skill sulle skill (writing-skills, using-superpowers). Non c'è nessuna skill che si chiami code-reviewer, tdd-guide o refactor-cleaner: quei nomi, se li hai visti in giro, appartengono a skill e agenti scritti da altri o da me.

Come si installa

In Claude Code il plugin si installa dal marketplace ufficiale di Anthropic oppure da quello dell'autore. I comandi sono quelli del README, sezione Claude Code:

/plugin install superpowers@claude-plugins-official

/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace

Sono due alternative: la prima riga basta; le ultime due registrano prima il marketplace dell'autore e poi installano da lì. Sono comandi interni a Claude Code e non li ho eseguiti (schema da adattare). Si trova scritto altrove di clonare il repository dentro ~/.claude/skills/: non è la procedura che il README documenta per Claude Code. Il percorso documentato è il plugin, e le sue skill si richiamano con il nome del plugin come prefisso, perché la documentazione di Claude Code dice che le skill dei plugin hanno un proprio spazio di nomi.

Lo stesso README elenca l'installazione per altri ambienti, fra cui Codex, Cursor, Gemini CLI e GitHub Copilot CLI: Superpowers non dipende da Claude Code, anche se qui parliamo solo di quel caso. Come si aggiorna il plugin o si fissa una versione non l'ho verificato: se ti serve, cerca la procedura nella documentazione dei plugin di Claude Code.

Quando una skill parte, e che cosa fa

Ogni skill ha un frontmatter con nome e descrizione. Claude Code tiene sempre nel contesto la descrizione e carica il corpo solo quando decide che serve, come spiega l'articolo 02. Ecco le descrizioni vere di sette skill del plugin, copiate dai file, e che cosa impone ciascuna secondo il corpo del file.

SkillDescrizione (dal file, in inglese)Che cosa impone
brainstormingYou MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.Capire l'intento prima di costruire
writing-plansUse when you have a spec or requirements for a multi-step task, before touching codeUn piano a compiti piccoli prima del codice
test-driven-developmentUse when implementing any feature or bugfix, before writing implementation codeNessun codice di produzione senza un test che fallisce prima
systematic-debuggingUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesNessuna correzione senza aver indagato la causa
requesting-code-reviewUse when completing tasks, implementing major features, or before merging to verify work meets requirementsRevisione rispetto al piano, con gravità
verification-before-completionUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysProve prima di dire «fatto»
subagent-driven-developmentUse when executing implementation plans with independent tasks in the current sessionUn sub-agent per compito, con revisione in due stadi

Leggi la colonna centrale: quasi ogni descrizione dice quando usare la skill («Use when...») e non che cosa fa, e non è un caso. La skill writing-skills spiega perché: nei test dell'autore, quando la descrizione riassumeva il procedimento, Claude tendeva a seguire il riassunto invece di leggere il corpo della skill, e il corpo diventava documentazione saltata. Una descrizione che dice solo quando usarla costringe a leggere il resto. Attenzione, perché la specifica Agent Skills, che è un'altra fonte, chiede una descrizione che dica sia che cosa fa la skill sia quando usarla: è una scelta di progetto di Superpowers, motivata dai suoi test, e non un obbligo del formato. Le due eccezioni più evidenti, brainstorming e verification-before-completion, mostrano che l'autore stesso non rispetta la regola in modo rigido.

Una regola controllabile: lo script che legge le descrizioni

Le regole formali di writing-skills si possono controllare con poche righe: la descrizione comincia con «Use when», non supera i 500 caratteri (il limite che la skill raccomanda «se possibile»), ed è una frase sola. Lo script che segue applica quei tre controlli a tre campioni miei e alle skill del plugin; non capisce il significato delle frasi, quindi non sostituisce il giudizio, ma trova subito le descrizioni che sembrano riassunti.

"""Controlla la forma delle descrizioni delle skill (solo regole formali, non il significato)."""
import glob
import os
import re
import sys


def descrizione(percorso):
    testo = open(percorso, encoding="utf-8").read()
    frontmatter = re.match(r"---\n(.*?)\n---\n", testo, re.S).group(1)
    return re.search(r"^description:\s*(.+)$", frontmatter, re.M).group(1).strip()


def problemi(testo):
    trovati = []
    if not testo.lower().startswith("use when"):
        trovati.append("non comincia con 'Use when'")
    if len(testo) > 500:
        trovati.append(f"{len(testo)} caratteri (oltre 500)")
    if re.search(r"[.;] \S", testo):
        trovati.append("più di una frase: rischia di riassumere il procedimento")
    return trovati


campioni = {
    "campione-ok": "Use when a test fails only on CI and not on the developer machine",
    "campione-riassunto": "Use when investigating a bug. Drives a scientific-method loop (hypothesis, test, measure) and creates checkpoints between cycles.",
    "campione-vago": "Helps with debugging",
}
for nome, d in campioni.items():
    print(f"{nome}: {problemi(d) or 'ok'}")

print("--- skill del plugin")
for percorso in sorted(glob.glob(os.path.expanduser(sys.argv[1]))):
    nome = percorso.split("/")[-2]
    print(f"{nome}: {problemi(descrizione(percorso)) or 'ok'}")

# Uscita (python3 -I lint_descrizioni.py con il percorso delle skill del plugin 5.1.0):
# campione-ok: ok
# campione-riassunto: ['più di una frase: rischia di riassumere il procedimento']
# campione-vago: ["non comincia con 'Use when'"]
# --- skill del plugin
# brainstorming: ["non comincia con 'Use when'", 'più di una frase: rischia di riassumere il procedimento']
# dispatching-parallel-agents: ok
# executing-plans: ok
# finishing-a-development-branch: ok
# receiving-code-review: ok
# requesting-code-review: ok
# subagent-driven-development: ok
# systematic-debugging: ok
# test-driven-development: ok
# using-git-worktrees: ok
# using-superpowers: ok
# verification-before-completion: ['più di una frase: rischia di riassumere il procedimento']
# writing-plans: ok
# writing-skills: ok

L'uscita conferma ciò che la tabella suggeriva: dodici skill su quattordici passano, e le due che non passano sono brainstorming (comincia con «You MUST») e verification-before-completion (contiene un punto e virgola e il suo procedimento). Il campione «riassunto» ha il procedimento (ipotesi, prova, misura) scritto in descrizione: la regola lo segnala proprio per questo. Eseguito due volte, uscita identica; i risultati valgono per la versione 5.1.0.

Che cosa vuol dire «test prima del codice»: un esempio che puoi rifare

La skill test-driven-development enuncia la sua legge in una riga: nessun codice di produzione senza un test che fallisce prima; se hai scritto il codice prima del test, lo cancelli e riparti. È una regola dura, e il modo migliore di capirla è vederla su un caso piccolo. Il dominio è un calcolo di sconto per quantità: dieci per cento da dieci pezzi, venti per cento da cinquanta, errore sotto un pezzo. Prima scrivo i test, in un file test_sconto.py:

import unittest

from sconto import prezzo_scontato


class TestSconto(unittest.TestCase):
    def test_nessuno_sconto_sotto_dieci_pezzi(self):
        self.assertEqual(prezzo_scontato(9, 20.0), 180.0)

    def test_dieci_per_cento_sopra_dieci_pezzi(self):
        self.assertEqual(prezzo_scontato(25, 20.0), 450.0)

    def test_venti_per_cento_da_cinquanta_pezzi(self):
        self.assertEqual(prezzo_scontato(50, 20.0), 800.0)

    def test_quantita_non_valida(self):
        with self.assertRaises(ValueError):
            prezzo_scontato(0, 20.0)


if __name__ == "__main__":
    unittest.main()

Ogni test dice una regola con un numero che puoi controllare a mente: nove pezzi a venti euro fanno 180 senza sconto, venticinque ne fanno 450 con il dieci per cento, cinquanta ne fanno 800 con il venti, e zero pezzi è un errore. Si esegue prima che esista sconto.py, e deve fallire: è il rosso. Poi si scrive l'implementazione minima e si riesegue.

# sconto.py
def prezzo_scontato(quantita, prezzo_unitario):
    """Totale per `quantita` pezzi: -10% da 10 pezzi, -20% da 50 pezzi."""
    if quantita < 1:
        raise ValueError("la quantità deve essere almeno 1")
    if quantita >= 50:
        fattore = 0.80
    elif quantita >= 10:
        fattore = 0.90
    else:
        fattore = 1.0
    return round(quantita * prezzo_unitario * fattore, 2)

# Uscita di tdd_run.sh (rosso senza sconto.py, poi verde con sconto.py):
# == ROSSO
# ERROR: test_sconto (unittest.loader._FailedTest.test_sconto)
# ModuleNotFoundError: No module named 'sconto'
# Ran 1 test
# FAILED (errors=1)
# == VERDE
# test_dieci_per_cento_sopra_dieci_pezzi ... ok
# test_nessuno_sconto_sotto_dieci_pezzi ... ok
# test_quantita_non_valida ... ok
# test_venti_per_cento_da_cinquanta_pezzi ... ok
# Ran 4 tests
# OK

Il rosso qui è un errore di importazione, perché il modulo non esiste ancora: è la forma più rozza di test fallito, ma serve a dimostrare che il test non passa «per caso». Nel verde le soglie stanno nelle due condizioni quantita >= 50 e quantita >= 10, valutate dalla più alta alla più bassa; se le invertissi, i cinquanta pezzi prenderebbero il dieci per cento e il terzo test diventerebbe rosso, ed è proprio l'errore che il rosso iniziale permette di scoprire. Eseguito due volte con uscita identica; i tempi sono stati tolti perché variano. Questa è una mia dimostrazione su un progetto di prova: non prova nulla su ciò che Claude fa con la skill, per quello servono le sessioni vere. Sul mio progetto reale mi è capitato di usare la stessa disciplina per un servizio che calcola un livello di carriera, ed è lì che ho cominciato a fidarmene.

Errori che si fanno scrivendo skill

Le tre indicazioni che seguono vengono dall'esperienza e dalla documentazione, e le tengo separate perché hanno pesi diversi.

  • Una skill che riassume sé stessa nella descrizione. È l'errore documentato da writing-skills: la descrizione dice quando, il corpo dice come.
  • Una skill che duplica una funzione già integrata. La documentazione di Claude Code ricorda che le funzioni integrate, come i comandi /debug o /code-review, esistono già: controlla prima di scriverne una uguale.
  • Una skill che pretende di fare tutto. Il corpo cresce, la descrizione si allarga e il confronto con la richiesta diventa vago; spezzarla in compiti precisi è il rimedio che applico.

Sulla dimensione non ripeto la mia vecchia regola dei trecento righe, perché la misura la smentisce: nel plugin, test-driven-development ha 367 righe di corpo e writing-skills ne ha 651. La specifica Agent Skills raccomanda un corpo sotto le 500 righe e sotto i 5.000 token, ed è un criterio più onesto. Il limite non è un numero, è la domanda: il modello capisce ancora quando invocarla?

Quando non usarlo

Superpowers non è un'assicurazione universale. Per una richiesta da una riga, come cambiare un colore, l'attivazione di un metodo costa più di quanto vale; per un prototipo che butterai non ha senso imporre il test prima del codice, ed è lo stesso README, nell'elenco delle eccezioni di test-driven-development, a citare i prototipi usa e getta, il codice generato e i file di configurazione. Vale anche per le skill tue: scrivi una skill quando hai fatto la stessa cosa a mano più volte, non alla prima.

Domande frequenti

Che cos'è Superpowers?

È una metodologia di sviluppo per assistenti di programmazione, mantenuta da obra con licenza MIT. È fatta di skill componibili, ciascuna in una cartella con un file SKILL.md, che si attivano da sole nelle situazioni che descrivono: progettare, pianificare, scrivere test, fare debug, rivedere.

Quali skill conviene conoscere per prime?

Quelle che correggono un errore tipico: test-driven-development, systematic-debugging e verification-before-completion. La prima impone il test prima del codice, la seconda la ricerca della causa prima della correzione, la terza le prove prima di dichiarare un lavoro finito.

Posso scrivere una skill mia?

Sì: è una cartella con un file SKILL.md sotto .claude/skills/<nome>/ nel progetto o sotto ~/.claude/skills/<nome>/ per tutti i tuoi progetti, come dice la documentazione di Claude Code. Servono almeno un nome e una descrizione che dica quando usarla.

Superpowers funziona fuori da Claude Code?

Sì: il README elenca l'installazione anche per Codex, Cursor, Gemini CLI, GitHub Copilot CLI e altri ambienti. Le istruzioni di questa pagina riguardano però solo Claude Code.

Che cosa sai fare adesso

Sai che Superpowers è un metodo installato come plugin e non una cartella da clonare, e sai elencarne le skill reali senza inventarne di nuove. Sai leggere una descrizione di skill e riconoscere se dice quando usarla o se riassume il procedimento, e hai uno script per controllarlo. Hai visto il ciclo rosso-verde su un caso minuscolo. Il passo successivo è l'articolo 02, sul modo in cui le skill si caricano.

Torna alla guida di apertura Passa a Get Shit Done

Fonti

  • Superpowers, README del repository - definizione, licenza MIT, comandi di installazione, flusso di base, elenco delle skill e ambienti supportati, consultata il 2026-11-13
  • Claude Code: Skills - percorsi delle skill personali e di progetto, spazio di nomi delle skill dei plugin, consultata il 2026-11-13
  • Agent Skills: specification - raccomandazione sulla dimensione del corpo di SKILL.md, consultata il 2026-11-13: descrizione di massimo 1.024 caratteri che dice che cosa fa e quando usarla, corpo sotto le 500 righe e sotto i 5.000 token
  • Misure nel repository: python3 -I lint_descrizioni.py e bash tdd_run.sh su file di prova, plugin Superpowers 5.1.0 installato in locale, ciascuno eseguito due volte con uscita identica, 2026-11-13

Prova Questi Strumenti

Strumenti gratuiti correlati a questo argomento.

Commenti

Caricamento commenti...

Accedi per commentare

Articoli e strumenti nuovi anche su Telegram

Il canale Telegram segnala gli articoli e gli strumenti nuovi del sito.

Ti è piaciuto questo articolo?

Esplora altri contenuti sul blog o scopri i miei progetti