Compare commits

...
7 Commits
Author SHA1 Message Date
davideandClaude Sonnet 5.5 71286cf9b8 Aggiungi lo script per controllare le statistiche e riordina CLAUDE.md
controlla-statistiche.py confronta stelle, fork, licenza, versione,
installazioni e controlli di sicurezza delle schede con i dati attuali di
GitHub e skills.sh, senza modificare nulla. CLAUDE.md documenta lo script,
le convenzioni delle schede e gli argomenti Ufficio e Second brain.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-30 09:38:54 +01:00
davideandClaude Sonnet 5.5 5051b50902 Aggiungi le schede di claude-obsidian, ecc, pdf, pptx e xlsx
Nel README nascono gli argomenti Ufficio e Second brain (presenti in
entrambi i gruppi, anche se vuoti): pdf, pptx e xlsx vanno sotto Ufficio,
claude-obsidian, obsidian-skills e obsidian-wiki sotto Second brain.
Conoscenza e note resta per graphify; ecc si affianca a superpowers.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-30 09:38:54 +01:00
davideandClaude Sonnet 5.5 62caee979a Aggiungi la scheda di apple-design
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-19 09:37:01 +02:00
davideandClaude Sonnet 5.5 8a38f0a62a Aggiungi la scheda di superpowers e riorganizza il README per tipo e argomento
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-19 09:34:46 +02:00
davideandClaude Sonnet 5.5 38b1d95ceb Aggiungi la scheda di diagram-design
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-17 19:27:00 +02:00
davideandClaude Sonnet 5.5 05582b3c74 Aggiungi la scheda di retro
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-17 16:46:29 +02:00
davideandClaude Sonnet 5.5 ac81877e73 Metti in primo piano i metodi standard nell'installazione di obsidian-wiki
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 09:32:06 +02:00
13 changed files with 1768 additions and 40 deletions

No files matched your search

+18 -2
View File
@@ -4,12 +4,13 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
## Scopo del repository ## Scopo del repository
Un dizionario personale di skill per agenti AI, scritto in Markdown. Non è un progetto software: non ci sono comandi di build, lint o test. Le skill vengono aggiunte nel tempo, di solito con una richiesta come "aggiungi la skill X" o con un comando di installazione (`npx skills add ...`). Un dizionario personale di skill per agenti AI, scritto in Markdown. Non è un progetto software: non ci sono build, lint o test; l'unico programma è `scripts/controlla-statistiche.py` (passo 4). Le skill vengono aggiunte nel tempo, di solito con una richiesta come "aggiungi la skill X" o con un comando di installazione (`npx skills add ...`).
## Struttura ## Struttura
- `README.md` è l'indice: una tabella con una riga per skill, con il nome che rimanda alla scheda e una descrizione di una frase. Niente dettagli qui. - `README.md` è l'indice: una tabella con una riga per skill, con il nome che rimanda alla scheda e una descrizione di una frase. Niente dettagli qui.
- `skills/<nome-skill>.md` è la scheda di una skill. Il nome del file è il nome della skill. - `skills/<nome-skill>.md` è la scheda di una skill. Il nome del file è il nome della skill.
- `scripts/controlla-statistiche.py` confronta le statistiche delle schede con quelle attuali (passo 4).
[skills/find-skills.md](skills/find-skills.md) è la scheda di riferimento: ogni nuova scheda deve avere lo stesso livello di dettaglio, struttura e tono. [skills/find-skills.md](skills/find-skills.md) è la scheda di riferimento: ogni nuova scheda deve avere lo stesso livello di dettaglio, struttura e tono.
@@ -44,9 +45,24 @@ Sezioni, in quest'ordine:
Traduci e adatta il contenuto del `SKILL.md` in italiano invece di copiarlo; lascia in originale comandi, nomi e parole chiave di ricerca. Traduci e adatta il contenuto del `SKILL.md` in italiano invece di copiarlo; lascia in originale comandi, nomi e parole chiave di ricerca.
### Convenzioni delle schede
- I numeri di diffusione portano mese e anno (`Diffusione (ottobre 2026)`) e sono arrotondati con "circa".
- Dì sempre cosa non hai verificato: pagina senza controlli di sicurezza, avvisi senza spiegazione, file non letti, comandi non provati.
- Per plugin e raccolte (esempi: [ecc.md](skills/ecc.md), [obsidian-wiki.md](skills/obsidian-wiki.md)) aggiungi in *Cosa fa* una tabella delle skill o degli agenti inclusi, e in *Da sapere* hook, scritture fuori dal progetto e consumo di contesto. In *Installazione* metti per primo il metodo del plugin.
- Se la skill non può funzionare nelle app di chat (servono file locali, sottoagenti, hook), la sezione sulle app desktop lo dice in un avviso.
### 3. Aggiorna l'indice ### 3. Aggiorna l'indice
Aggiungi nel `README.md` la riga della skill con una descrizione di una frase. Aggiungi nel `README.md` la riga della skill con una descrizione di una frase:
- due gruppi, *Skill singole* e *Plugin, raccolte e strumenti*; nel secondo la tabella ha anche la colonna *Tipo*;
- dentro ogni gruppo, sottosezioni `###` per argomento (quelle già presenti), righe in ordine alfabetico; crea un argomento nuovo solo se nessuno calza;
- *Ufficio* (documenti, fogli di calcolo, presentazioni, posta, calendario) e *Second brain* (Obsidian, LLM Wiki e simili) esistono in entrambi i gruppi anche se vuoti: la sezione vuota riporta *Ancora nessuna skill.* al posto della tabella.
### 4. Tieni aggiornate le statistiche
`python3 scripts/controlla-statistiche.py [--tutto] [--soglia <%>] [scheda ...]` confronta stelle, fork, licenza, versione, installazioni e controlli di sicurezza con i dati attuali (serve `gh`) e mostra cosa aggiornare, senza modificare le schede: correggile a mano, mese della rilevazione compreso. Legge le frasi della sezione *Intestazione* (`circa N stelle`, `circa N installazioni`, `licenza X`, `versione X.Y.Z`, `Controlli di sicurezza su skills.sh`): se le cambi, controlla che lo script le legga ancora.
## Come lavorare qui ## Come lavorare qui
+81 -7
View File
@@ -2,15 +2,89 @@
Il mio dizionario delle skill per agenti AI (Claude Code, Codex, app di Claude e ChatGPT): per ognuna, una breve descrizione e un link alla scheda con cosa fa e come si installa. Il mio dizionario delle skill per agenti AI (Claude Code, Codex, app di Claude e ChatGPT): per ognuna, una breve descrizione e un link alla scheda con cosa fa e come si installa.
## Skill Le schede sono divise in due gruppi, e dentro ogni gruppo per argomento:
- **Skill singole:** fanno una cosa sola e si installano da sole.
- **Plugin, raccolte e strumenti:** insiemi di più skill, cataloghi o programmi che l'agente usa insieme alla skill.
## Skill singole
### Sviluppo software
| Skill | Descrizione | | Skill | Descrizione |
|---|---| |---|---|
| [claude-plugins-official](skills/claude-plugins-official.md) | Marketplace ufficiale di Anthropic per Claude Code: catalogo di plugin con integrazioni, analisi del codice e flussi di sviluppo. |
| [find-skills](skills/find-skills.md) | Permette all'agente di cercare e installare da solo altre skill con `npx skills`. |
| [graphify](skills/graphify.md) | Trasforma codice, documenti e media di un progetto in un grafo di conoscenza che l'agente interroga invece di rileggere i file. |
| [obsidian-skills](skills/obsidian-skills.md) | Raccolta ufficiale di sei skill per Obsidian: Markdown di Obsidian, Bases, Canvas, riga di comando, estrazione di pagine web e modelli. |
| [obsidian-wiki](skills/obsidian-wiki.md) | Framework di 39 skill che fa costruire all'agente un "secondo cervello": un vault Obsidian di note collegate che raccoglie documenti, sessioni e progetti e risponde con citazioni. |
| [ponytail](skills/ponytail.md) | Fa scrivere all'agente il codice più semplice e breve che funziona, evitando la sovraingegnerizzazione. | | [ponytail](skills/ponytail.md) | Fa scrivere all'agente il codice più semplice e breve che funziona, evitando la sovraingegnerizzazione. |
| [project-estimation](skills/project-estimation.md) | Stima durata, costi e risorse di un progetto con tecniche strutturate (PERT, bottom-up, per analogia). | | [retro](skills/retro.md) | Fa una retrospettiva su una sessione di codifica e propone come migliorare l'ambiente dell'agente (controlli automatici, standard, file di istruzioni) perché non ripeta gli stessi errori. |
### Design e diagrammi
| Skill | Descrizione |
|---|---|
| [apple-design](skills/apple-design.md) | Porta sul web i principi di design Apple: gesti, animazioni a molla, transizioni interrompibili, materiali traslucidi e tipografia. |
| [diagram-design](skills/diagram-design.md) | Fa disegnare all'agente diagrammi curati (45 tipi) come file HTML con SVG, nei colori e nei font del tuo sito, e rifà quelli in draw.io, Mermaid ed Excalidraw. |
| [ui-ux-pro-max](skills/ui-ux-pro-max.md) | Dà all'agente un archivio di stili, palette, font e regole di UX per progettare interfacce curate su web, mobile e desktop. | | [ui-ux-pro-max](skills/ui-ux-pro-max.md) | Dà all'agente un archivio di stili, palette, font e regole di UX per progettare interfacce curate su web, mobile e desktop. |
### Gestione dei progetti
| Skill | Descrizione |
|---|---|
| [project-estimation](skills/project-estimation.md) | Stima durata, costi e risorse di un progetto con tecniche strutturate (PERT, bottom-up, per analogia). |
### Second brain
Memoria a lungo termine dell'agente in note Markdown tue (vault Obsidian, LLM Wiki e simili).
*Ancora nessuna skill.*
### Ufficio
Documenti, fogli di calcolo, presentazioni, posta e calendario.
| Skill | Descrizione |
|---|---|
| [pdf](skills/pdf.md) | Fa leggere, unire, dividere, compilare, creare e ripulire (OCR) i file PDF, scegliendo lo strumento giusto per ogni compito. |
| [pptx](skills/pptx.md) | Fa creare, leggere e modificare presentazioni PowerPoint (`.pptx`, `.potx`), controllando ogni slide trasformata in immagine per correggere testo fuori dai bordi e sovrapposizioni. |
| [xlsx](skills/xlsx.md) | Fa creare, modificare e ripulire fogli Excel (`.xlsx`, `.xlsm`, `.csv`) con formule vere, ricalcolate e controllate; non scrive macro VBA. |
### Ecosistema delle skill
| Skill | Descrizione |
|---|---|
| [find-skills](skills/find-skills.md) | Permette all'agente di cercare e installare da solo altre skill con `npx skills`. |
## Plugin, raccolte e strumenti
### Sviluppo software
| Nome | Tipo | Descrizione |
|---|---|---|
| [ecc](skills/ecc.md) | Sistema con 71 agenti, 314 skill, hook e regole | Everything Claude Code: pianificazione, test first, revisori per linguaggio, hook di qualità e sicurezza, memoria tra le sessioni; più grande e invasivo di superpowers. |
| [superpowers](skills/superpowers.md) | Plugin con più skill | Metodologia di sviluppo per l'agente: brainstorming, piani, test first, debug sistematico e review, con skill che si attivano da sole. |
### Second brain
Memoria a lungo termine dell'agente in note Markdown tue (vault Obsidian, LLM Wiki e simili).
| Nome | Tipo | Descrizione |
|---|---|---|
| [claude-obsidian](skills/claude-obsidian.md) | Plugin con 15 skill | Fa dell'agente il custode di un "secondo cervello" in un vault Obsidian: cattura le fonti, le trasforma in note collegate con citazioni e risponde dalle tue note. |
| [obsidian-skills](skills/obsidian-skills.md) | Raccolta di 6 skill | Raccolta ufficiale per Obsidian: Markdown di Obsidian, Bases, Canvas, riga di comando, estrazione di pagine web e modelli. |
| [obsidian-wiki](skills/obsidian-wiki.md) | Framework di 39 skill | Fa costruire all'agente un "secondo cervello": un vault Obsidian di note collegate che raccoglie documenti, sessioni e progetti e risponde con citazioni. |
### Conoscenza e note
| Nome | Tipo | Descrizione |
|---|---|---|
| [graphify](skills/graphify.md) | Skill + programma Python | Trasforma codice, documenti e media di un progetto in un grafo di conoscenza che l'agente interroga invece di rileggere i file. |
### Ufficio
Documenti, fogli di calcolo, presentazioni, posta e calendario.
*Ancora nessuna skill.*
### Ecosistema di Claude Code
| Nome | Tipo | Descrizione |
|---|---|---|
| [claude-plugins-official](skills/claude-plugins-official.md) | Marketplace di plugin | Marketplace ufficiale di Anthropic per Claude Code: catalogo di plugin con integrazioni, analisi del codice e flussi di sviluppo. |
+170
View File
@@ -0,0 +1,170 @@
#!/usr/bin/env python3
"""Confronta le statistiche scritte nelle schede con quelle attuali.
Sola lettura: non modifica nessuna scheda, mostra solo che cosa è cambiato.
Per ogni scheda controlla, quando la scheda li riporta:
- stelle, fork, licenza e ultima versione del repository (GitHub, tramite `gh`)
- installazioni e controlli di sicurezza (pagina della skill su skills.sh)
Uso:
python3 scripts/controlla-statistiche.py # tutte le schede, solo le differenze
python3 scripts/controlla-statistiche.py --tutto # mostra anche i valori invariati
python3 scripts/controlla-statistiche.py --soglia 5 pdf # scarto minimo 5%, solo la scheda pdf
Serve `gh` con l'accesso effettuato (`gh auth login`). Uscita 1 se c'è qualcosa da aggiornare.
"""
import argparse
import json
import re
import subprocess
import sys
import urllib.request
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
SCHEDE = Path(__file__).resolve().parent.parent / "skills"
AUDITOR = ["Gen Agent Trust Hub", "Socket", "Snyk"]
MESI = ["gennaio", "febbraio", "marzo", "aprile", "maggio", "giugno", "luglio",
"agosto", "settembre", "ottobre", "novembre", "dicembre"]
def num_it(cifre, milioni=None):
"""'35.200' -> 35200; '3,9' + 'milioni' -> 3900000."""
if milioni:
return round(float(cifre.replace(",", ".")) * 1_000_000)
return int(cifre.replace(".", "").replace(",", ""))
def num_sksh(testo):
"""'219.7K' -> 219700; '1.4M' -> 1400000; '649' -> 649."""
mult = {"K": 1_000, "M": 1_000_000}.get(testo[-1].upper(), 1)
return round(float(testo.rstrip("KkMm")) * mult)
def fmt(n):
return f"{n:,}".replace(",", ".")
def gh(percorso):
r = subprocess.run(["gh", "api", percorso], capture_output=True, text=True)
return json.loads(r.stdout) if r.returncode == 0 else None
def pagina(url):
try:
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
html = urllib.request.urlopen(req, timeout=25).read().decode("utf-8", "replace")
except Exception:
return None
html = re.sub(r"<(script|style).*?</\1>", " ", html, flags=re.S)
return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", html))
def audit_scheda(testo):
"""Esiti dei controlli come li dice la scheda: {'Socket': 'pass' | 'warn'}."""
m = re.search(r"\*\*Controlli di sicurezza su skills\.sh:\*\*(.*)", testo)
if not m:
return {}
riga = re.sub(r"\([^)]*\)", "", m.group(1))
esiti = {}
for clausola in re.split(r"[;.]", riga):
nomi = [a for a in AUDITOR if a in clausola]
if not nomi:
continue
if re.search(r"avviso|segnala|non superat", clausola):
stato = "warn"
elif "supera" in clausola:
stato = "pass"
else:
continue
esiti.update({a: stato for a in nomi})
return esiti
def confronta(righe, nome, scheda, ora, soglia):
"""Aggiunge una riga numerica; segnala se lo scarto supera la soglia."""
scarto = (ora - scheda) / scheda * 100 if scheda else 100.0
esito = "DA AGGIORNARE" if abs(scarto) >= soglia else "ok"
righe.append((nome, fmt(scheda), fmt(ora), f"{scarto:+.1f}%", esito))
def controlla(percorso, soglia):
testo = percorso.read_text(encoding="utf-8")
righe = []
repo = re.search(r"\*\*Repository:\*\*\s*\[[^\]]*\]\(https://github\.com/([^/\s)]+/[^/\s)]+)\)", testo)
riga_repo = re.search(r"\*\*Repository:\*\*(.*)", testo)
riga_repo = riga_repo.group(1) if riga_repo else ""
# GitHub: stelle, fork, licenza, versione
if repo:
info = gh(f"repos/{repo.group(1)}")
if info is None:
righe.append(("repository", repo.group(1), "non raggiungibile", "", "DA CONTROLLARE"))
else:
if m := re.search(r"circa ([\d.,]+)( milioni)? stelle", testo):
confronta(righe, "stelle", num_it(*m.groups()), info["stargazers_count"], soglia)
if m := re.search(r"([\d.,]+)( milioni)? fork", testo):
confronta(righe, "fork", num_it(*m.groups()), info["forks_count"], soglia)
if m := re.search(r"licenza ([A-Za-z0-9.\-]+)", riga_repo):
ora = (info.get("license") or {}).get("spdx_id") or "nessuna"
esito = "ok" if ora.lower() == m.group(1).lower() else "DA AGGIORNARE"
righe.append(("licenza", m.group(1), ora, "", esito))
if m := re.search(r"versione v?(\d+(?:\.\d+)+)", riga_repo):
rel = gh(f"repos/{repo.group(1)}/releases/latest")
if rel:
ora = rel["tag_name"].lstrip("v")
esito = "ok" if ora == m.group(1) else "DA AGGIORNARE"
righe.append(("versione", m.group(1), ora, "", esito))
if info.get("archived"):
righe.append(("repository", "", "archiviato", "", "DA CONTROLLARE"))
# skills.sh: installazioni e controlli di sicurezza
sksh = re.search(r"\*\*Pagina su skills\.sh:\*\*\s*\[[^\]]*\]\((https://skills\.sh/[^)\s]+)\)", testo)
if sksh:
pg = pagina(sksh.group(1))
if pg is None:
righe.append(("skills.sh", sksh.group(1), "non raggiungibile", "", "DA CONTROLLARE"))
else:
m_sc = re.search(r"circa ([\d.,]+)( milioni)? installazioni", testo)
m_pg = re.search(r"([\d.,]+[KM]?) total installs", pg) or re.search(r"\bInstalls ([\d.,]+[KM]?)(?=\s)", pg)
if m_sc and m_pg:
confronta(righe, "installazioni", num_it(*m_sc.groups()), num_sksh(m_pg.group(1)), soglia)
attesi = audit_scheda(testo)
visti = {a: ("pass" if s == "Pass" else "warn")
for a, s in re.findall(r"(Gen Agent Trust Hub|Socket|Snyk) (Pass|Warn|Fail)", pg)}
for a in AUDITOR:
if a in attesi and a in visti:
esito = "ok" if attesi[a] == visti[a] else "DA AGGIORNARE"
righe.append((f"sicurezza: {a}", attesi[a], visti[a], "", esito))
return righe
def main():
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("schede", nargs="*", help="nomi delle schede da controllare (predefinito: tutte)")
ap.add_argument("--soglia", type=float, default=10.0, help="scarto %% oltre il quale segnalare (predefinito 10)")
ap.add_argument("--tutto", action="store_true", help="mostra anche i valori invariati")
args = ap.parse_args()
elenco = [p for p in sorted(SCHEDE.glob("*.md")) if not args.schede or p.stem in args.schede]
if not elenco:
sys.exit("nessuna scheda trovata")
with ThreadPoolExecutor(max_workers=6) as pool:
risultati = list(pool.map(lambda p: controlla(p, args.soglia), elenco))
da_aggiornare = 0
for percorso, righe in zip(elenco, risultati):
mostra = [r for r in righe if args.tutto or r[4] != "ok"]
da_aggiornare += sum(r[4] != "ok" for r in righe)
if not mostra:
continue
rilevazione = re.search(r"Diffusione \(([^)]+)\)", percorso.read_text(encoding="utf-8"))
print(f"{percorso.stem} (rilevazione: {rilevazione.group(1) if rilevazione else 'non indicata'})")
for nome, scheda, ora, scarto, esito in mostra:
print(f" {nome:<24} scheda {scheda:>12} ora {ora:>12} {scarto:>7} {esito}")
print(f"\n{len(elenco)} schede controllate, {da_aggiornare} voci da aggiornare (soglia {args.soglia:g}%)")
sys.exit(1 if da_aggiornare else 0)
if __name__ == "__main__":
main()
+129
View File
@@ -0,0 +1,129 @@
# apple-design
- **Autore:** Emil Kowalski
- **Repository:** [emilkowalski/skills](https://github.com/emilkowalski/skills)
- **Sorgente:** [skills/apple-design/SKILL.md](https://github.com/emilkowalski/skills/blob/main/skills/apple-design/SKILL.md)
- **Pagina su skills.sh:** [emilkowalski/skills/apple-design](https://skills.sh/emilkowalski/skills/apple-design)
- **Diffusione (ottobre 2026):** circa 222.900 installazioni; il repository ha circa 47.400 stelle su GitHub; prima rilevazione su skills.sh il 9 luglio 2026
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati, senza avvisi
- **Licenza:** non indicata nel README; da verificare nel repository
## A cosa serve
Porta sul web il modo in cui Apple progetta le interfacce e il movimento "fluido". Aiuta l'agente a costruire o rivedere interfacce che si muovono come quelle di iOS: gesti, animazioni a molla, sheet che si trascinano, transizioni che si possono interrompere e invertire in qualsiasi momento.
## Cosa fa
### Quando si attiva
Quando costruisci o rivedi:
- interfacce guidate da gesti, con drag, swipe e sheet;
- animazioni a molla (spring) e transizioni interrompibili;
- momentum e rimbalzo ai bordi;
- materiali traslucidi e profondità;
- tipografia e supporto a `prefers-reduced-motion`;
- più in generale, i principi di design dietro le interfacce in stile Apple.
Se la invochi senza una domanda precisa, risponde con un messaggio fisso di presentazione e aspetta la tua domanda.
### Come lavora
È una skill di conoscenza: non lancia comandi, ma dà all'agente regole e formule da applicare al codice. L'idea di fondo è che un'interfaccia sembra viva quando il movimento parte dal valore visibile in quel momento, eredita la velocità dell'utente, proietta il momentum in avanti e può essere afferrato e invertito in ogni istante.
Le regole principali, tutte con esempi di codice nel `SKILL.md`:
1. **Risposta immediata:** feedback al pointer-down, non al rilascio.
2. **Manipolazione diretta:** il contenuto segue il dito 1:1 con Pointer Events e `setPointerCapture`, tenendo conto del punto in cui l'hai afferrato.
3. **Interrompibilità:** si anima sempre dal valore presente, mai dal bersaglio. Per i gesti si evitano CSS transition e `@keyframes`. Quando un gesto si inverte si trasferisce la velocità; il movimento 2D si separa in molle indipendenti su X e Y.
4. **Molle al posto di durate fisse:** due parametri, *damping ratio* (1.0 = nessun rimbalzo) e *response* (in secondi). Il rimbalzo (circa 0,8) si usa solo se il gesto aveva momentum. Valori Apple citati: spostamento 1.0/0.4, rotazione 0.8/0.4, drawer 0.8/0.3.
5. **Passaggio di velocità:** la molla riparte dalla velocità di rilascio del dito.
6. **Proiezione del momentum:** il punto di arrivo si calcola dalla velocità con una decelerazione esponenziale (rate circa 0,998), poi si aggancia il bersaglio più vicino.
7. **Coerenza spaziale:** entrata e uscita sullo stesso percorso, `transform-origin` sul trigger, easing speculare per le transizioni reversibili.
8. **Rubber-banding:** resistenza progressiva ai bordi invece di un arresto netto.
9. **Dettagli dei gesti:** soglia di circa 10 px prima di scegliere una direzione, riconoscitori in parallelo, ritardi di disambiguazione minimi.
10. **Prestazioni:** si animano solo `transform` e `opacity`; `will-change` quando serve.
11. **Materiali e profondità:** `backdrop-filter` per barre e sheet traslucidi, scrim per i modali, bordi sfumati al posto di divisori netti, niente superfici chiare sovrapposte.
12. **Feedback multimodale:** visivo, audio e aptico sullo stesso frame, solo nei momenti che contano.
13. **Accessibilità:** `prefers-reduced-motion` (cross-fade al posto di slide e molle), `prefers-reduced-transparency`, `prefers-contrast: more`.
14. **Tipografia:** tracking che dipende dalla dimensione (per esempio `-0.02em` sui titoli, vicino a 0 sul corpo), interlinea inversamente proporzionale alla dimensione, gerarchia col peso, font di sistema come default.
15. **Otto principi di design:** scopo, controllo dell'utente, responsabilità, familiarità, flessibilità, semplicità (non minimalismo), cura del dettaglio, deliziare.
16. **Processo:** prototipi interattivi, interazione e visuale progettate insieme, test con persone reali, movimento rivisto al rallentatore.
Il file include anche una tabella di riferimento rapida (molla di default, molla da flick, proiezione del punto di arrivo, reversibilità, rubber-banding, materiali, reduced-motion) ed esempi di codice per `:active` con scale, Pointer Events, molle con Motion, proiezione del momentum, rubber-banding, media query per reduced-motion e una toolbar traslucida.
### Da sapere
- Le fonti dichiarate sono le sessioni WWDC, soprattutto *Designing Fluid Interfaces* (2018), più *The Details of UI Typography* (2020), *Designing Audio-Haptic Experiences* e *Principles of Great Design*.
- Gli esempi sono per il web (CSS, Pointer Events, `requestAnimationFrame`) e citano librerie come Motion/Framer Motion, Vaul ed Embla. Per React Native il repository ha un'altra skill, `animate-expo`.
- Non usa script né file esterni: il `SKILL.md` non cita allegati. I controlli di sicurezza di skills.sh sono tutti superati.
- Il repository contiene altre 14 skill (animazioni, Swift, librerie UI, ecc.): il comando del README le installa tutte, quello con `--skill` solo questa.
## Installazione
### Claude Code e Codex
Solo questa skill:
```bash
npx skills add emilkowalski/skills --skill apple-design -g -a codex -a claude-code
```
Tutte le skill del repository (è il comando del README, con `@latest`):
```bash
npx skills@latest add emilkowalski/skills
```
| Opzione | Significato |
|---|---|
| `--skill apple-design` | installa solo questa skill del repository |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente (`.claude/skills/`, `.agents/skills/`) |
| `-a <agente>` | agente di destinazione, ripetibile (`claude-code`, `codex`, ...) |
| `-y` | salta le domande di conferma |
| `--copy` | copia i file invece di creare collegamenti simbolici |
Il README non descrive un plugin per Claude Code né altri metodi. Dopo l'installazione riavvia la sessione. In Codex puoi richiamarla con `$apple-design` o vederla con `/skills`; Claude Code la usa da solo quando la richiesta è pertinente.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update apple-design # aggiornamento
npx skills remove apple-design # rimozione
```
### App desktop di Claude e ChatGPT
Queste app richiedono di caricare la skill come ZIP. Preparalo così:
```bash
git clone --depth 1 https://github.com/emilkowalski/skills.git
cd skills/skills && zip -r ~/apple-design.zip apple-design
```
Lo ZIP deve contenere la cartella `apple-design/` con dentro `SKILL.md`.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** la skill è solo conoscenza e non richiede strumenti, quindi funziona anche nelle app di chat. Le dà il meglio quando l'agente può modificare ed eseguire il codice di un progetto web.
## Fonti
- [README di emilkowalski/skills](https://github.com/emilkowalski/skills)
- [SKILL.md di apple-design](https://github.com/emilkowalski/skills/blob/main/skills/apple-design/SKILL.md)
- [apple-design su skills.sh](https://skills.sh/emilkowalski/skills/apple-design)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+192
View File
@@ -0,0 +1,192 @@
# claude-obsidian
- **Autore:** AgriciDaniel (con la community AI Marketing Hub Pro)
- **Repository:** [AgriciDaniel/claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian) (licenza MIT, versione 3.0.1)
- **Sorgenti:** cartella [skills/](https://github.com/AgriciDaniel/claude-obsidian/tree/main/skills), un `SKILL.md` per skill; il punto d'ingresso è [skills/wiki/SKILL.md](https://github.com/AgriciDaniel/claude-obsidian/blob/main/skills/wiki/SKILL.md)
- **Pagina su skills.sh:** [AgriciDaniel/claude-obsidian](https://skills.sh/AgriciDaniel/claude-obsidian)
- **Diffusione (ottobre 2026):** circa 6.500 installazioni complessive tramite `npx skills` su 15 skill (da 546 per `obsidian-markdown` a 297 per `wiki-cli`); il repository ha circa 16.000 stelle e 1.600 fork su GitHub
- **Controlli di sicurezza su skills.sh:** la pagina non riporta esiti per questo repository
> Non è una sola skill ma un **plugin di Claude Code con 15 skill** e 3 agenti, più un programma Python (`scripts/claude-obsidian.py`) che fa le scritture sul vault. Le skill sono pensate per funzionare insieme.
## A cosa serve
Fa dell'agente il custode di un "secondo cervello": un vault di [Obsidian](https://obsidian.md) fatto di note Markdown tue, sul tuo disco. Gli dai fonti (articoli, trascrizioni, appunti), lui le legge, scrive note collegate che citano la fonte e le archivia in un grafo di conoscenza. Poi risponde alle domande a partire da quelle note. Segue il pattern LLM Wiki di Karpathy: la conoscenza si compila una volta e si mantiene, invece di rifare ogni volta la stessa ricerca.
## Cosa fa
### Quando si attiva
Le skill partono quando la richiesta corrisponde alla loro descrizione, oppure con `/claude-obsidian:<skill>`. Per esempio:
- vuoi creare un vault, o adottarne uno che hai già ("set up a wiki", "second brain");
- vuoi dare in pasto all'agente fonti da trasformare in note;
- chiedi che cosa sai già su un argomento;
- vuoi salvare una risposta o un'intuizione come nota;
- vuoi controllare lo stato del vault (link rotti, pagine orfane);
- vuoi una ricerca web guidata, una board Canvas o una tabella Bases.
### Come lavora
1. **Cattura.** Le fonti vanno nella cartella `inbox/`. Ognuna viene conservata come copia intatta, identificata dal contenuto, prima di essere riassunta (`capture plan`, poi `capture apply`).
2. **Ancoraggio.** Le affermazioni importanti rimandano alle fonti che le sostengono; le prove deboli o in conflitto restano visibili.
3. **Accumulo.** Domande, ricerche e controlli attingono a ciò che il vault contiene già.
Come sceglie il vault, in quest'ordine: l'argomento `--vault`, la variabile `CLAUDE_OBSIDIAN_VAULT`, il file `.claude-obsidian.json` più vicino, un vault inizializzato non ambiguo nella cartella corrente o sopra. Se la scelta manca o è ambigua, si ferma senza scrivere. La cartella del plugin non viene mai usata come vault.
Creazione e adozione del vault sono prima un'anteprima, poi un'applicazione con l'hash del piano approvato:
```bash
CORE=/percorso/assoluto/scripts/claude-obsidian.py
python3 "$CORE" init /percorso/del/vault --generated-at <ISO-UTC> --operation-id init-reviewed
python3 "$CORE" init /percorso/del/vault --generated-at <ISO-UTC> --operation-id init-reviewed \
--approved-plan-sha256 <hash-rivisto> --apply
```
Per un vault Obsidian che hai già, `adopt` al posto di `init`: aggiunge solo i metadati e i file di base mancanti, senza toccare le tue note. `--force` va usato solo dopo aver controllato i conflitti.
### Le skill per gruppo
**Costruire e usare il vault (5)**
| Skill | A cosa serve |
|---|---|
| `wiki` | crea un vault nuovo o adotta uno esistente, controlla che sia pronto e smista le richieste alle altre skill |
| `wiki-ingest` | trasforma le fonti catturate in pagine collegate, con le fonti registrate |
| `wiki-query` | risponde dal contenuto del vault; in sola lettura |
| `save` | conserva una risposta o un'intuizione come nota, solo se glielo chiedi |
| `wiki-lint` | trova link rotti, pagine orfane, metadati mancanti e sezioni vuote |
**Estendere il flusso (7)**
| Skill | A cosa serve |
|---|---|
| `autoresearch` | ricerca sul web limitata da un budget, solo con il tuo consenso, unita al vault dopo revisione |
| `canvas` | crea e aggiorna board Canvas di Obsidian |
| `defuddle` | prepara la cattura pulita di una pagina web in Markdown; il pulitore è uno strumento esterno facoltativo |
| `wiki-fold` | riassume il registro delle operazioni in sintesi brevi e tracciabili |
| `wiki-mode` | decide come archiviare le note nuove: Generic, LYT, PARA o Zettelkasten |
| `wiki-retrieve` | ricerca locale BM25, con riordino facoltativo dei risultati |
| `wiki-cli` | legge e cerca tramite la riga di comando ufficiale di Obsidian |
**Riferimento (3)**
| Skill | A cosa serve |
|---|---|
| `obsidian-markdown` | Markdown di Obsidian corretto: link, incorporamenti, callout, proprietà |
| `obsidian-bases` | file `.base` nativi: tabelle, schede, filtri e formule |
| `think` | un ciclo di revisione strutturato per le decisioni difficili |
I tre agenti (`wiki-ingest`, `wiki-lint`, `verifier`) sono in sola lettura: restituiscono bozze e rapporti, e scrive nel vault solo il programma Python.
### Modalità di archiviazione
`wiki-mode` cambia dove finiscono le note nuove; cambiare modalità non sposta quelle esistenti.
| Modalità | Come archivia |
|---|---|
| Generic (predefinita) | fonti, concetti, entità e sessioni |
| LYT | Maps of Content e note atomiche collegate |
| PARA | Projects, Areas, Resources, Archives |
| Zettelkasten | ID stabili, note atomiche, molti collegamenti |
### Cosa legge davvero
| Ingresso | Supporto |
|---|---|
| File locali | copiati e identificati dal contenuto |
| Immagini | metadati, hash, dimensioni |
| PDF ed EPUB | solo metadati, hash e dimensione; nessuna estrazione del testo integrata |
| Pagine web e YouTube | preparate come piano da approvare; per scaricarle serve un esecutore separato |
| OCR | richiede uno strumento esterno configurato |
| Ricerca BM25 | locale e deterministica |
| Riordino o modelli remoti | facoltativi, con consenso esplicito |
### Da sapere
- **Scritture sicure:** legge ogni nota che toccherà e ne registra l'impronta SHA-256; gli aiutanti restituiscono solo bozze e Claude le fonde in un unico piano applicato come una sola transazione. Se una nota cambia nel frattempo, la scrittura si ferma invece di sovrascrivere. Un registro tiene i backup, e `transaction recover` annulla una scrittura interrotta. Non fa commit Git da solo.
- **Consensi separati:** ricerca web, checkpoint Git e qualunque dato inviato fuori dal computer sono passaggi a parte che richiedono approvazione. La configurazione di base non usa la rete.
- **Blocco:** coordina solo scrittori locali che cooperano; altri dispositivi ed editor esterni non lo condividono, quindi servono i backup.
- **Limiti dichiarati:** non registra le trascrizioni da solo, non è un servizio di sincronizzazione né un verificatore di fatti, e non sostituisce i backup.
- **Hook:** il README non ne menziona.
- **Requisiti:** Python 3.11 o più recente, Claude Code (o un altro agente compatibile con le Agent Skills), Bash per gli script di installazione; Obsidian per la parte visiva; Git solo per sviluppo o checkpoint.
- **Windows:** le scritture sul vault richiedono WSL; su Windows nativo si possono solo ispezionare e vedere le anteprime.
## Installazione
### Claude Code e Codex
**Plugin di Claude Code** (metodo consigliato):
```bash
claude plugin marketplace add AgriciDaniel/claude-obsidian
claude plugin install claude-obsidian@agricidaniel-claude-obsidian
claude plugin list
```
Poi apri la cartella che vuoi come vault e avvia Claude Code lì:
```text
claude
/claude-obsidian:wiki # crea o adotta il vault (mostra prima un'anteprima)
/claude-obsidian:wiki-ingest # trasforma il contenuto di inbox/ in note collegate
/claude-obsidian:wiki-query # fai una domanda, risposta dalle tue note
/claude-obsidian:save # conserva una buona risposta come nota
/claude-obsidian:wiki-lint # controllo: link rotti, orfane, lacune
```
Apri la stessa cartella in Obsidian con **Open folder as vault**. Le skill hanno il prefisso del plugin, per esempio `/claude-obsidian:wiki`.
**Codex e altri agenti** (OpenCode, Gemini, ZCode, Cursor, Windsurf): da un clone del repository, uno script collega le skill. Senza `--apply` mostra solo l'anteprima.
```bash
git clone https://github.com/AgriciDaniel/claude-obsidian.git
cd claude-obsidian
bash scripts/setup-multi-agent.sh --host codex # anteprima, non scrive
bash scripts/setup-multi-agent.sh --host codex --apply # collega le skill
bash scripts/setup-multi-agent.sh --check # verifica
```
| Opzione | Significato |
|---|---|
| `--host <agente>` | agente di destinazione: `codex`, `opencode`, `gemini`, `zcode`, `cursor`, `windsurf` (ripetibile) |
| `--apply` | applica le modifiche; senza, è solo un'anteprima |
| `--check` | controlla che i collegamenti funzionino |
| `--workspace <cartella>` | cartella di lavoro, obbligatoria per Cursor e Windsurf |
Lo script crea i collegamenti solo dove non c'è già niente e non sostituisce mai una skill o un collegamento esistente. Per Codex le skill finiscono in `~/.agents/skills/<nome>`. Dopo l'installazione riavvia la sessione.
Gestione:
```bash
claude plugin marketplace update agricidaniel-claude-obsidian # aggiornamento (1)
claude plugin update claude-obsidian@agricidaniel-claude-obsidian # aggiornamento (2)
claude plugin uninstall claude-obsidian@agricidaniel-claude-obsidian # rimozione (non toglie il vault)
claude plugin marketplace remove agricidaniel-claude-obsidian
```
Dopo l'aggiornamento riavvia Claude Code. Chi ha installato la 3.0.0 con il vecchio nome `agricidaniel-obsidian` deve reinstallare con il nome nuovo (guida `docs/namespace-migration.md`). Per gli altri agenti, rimuovi solo i collegamenti che lo script ti ha elencato.
Esiste anche `npx skills add AgriciDaniel/claude-obsidian` (la pagina su skills.sh lo elenca), ma l'installazione documentata dal progetto è quella sopra. Non ho verificato come si comporti il programma Python con questo metodo.
### App desktop di Claude e ChatGPT
La documentazione del progetto non dice niente sulle app desktop di Claude e ChatGPT. Il caricamento di una skill come ZIP segue la procedura generale:
1. Prepara lo ZIP con la cartella di una skill (per esempio `skills/wiki-query`), che deve contenere `SKILL.md`.
2. **Claude (desktop o web):** attiva l'esecuzione del codice in **Settings → Capabilities**, poi **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP; attiva l'interruttore.
3. **ChatGPT (desktop o web):** **Skills** nella barra laterale, **Create → Upload from your computer**, attendi l'analisi di sicurezza e richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** qui non ha senso usarla. Le skill chiamano lo script `scripts/claude-obsidian.py` per percorso assoluto e lavorano su un vault nel tuo disco, mentre le app di chat girano in un ambiente isolato senza accesso a questi file. Serve un agente che giri in locale, come Claude Code o Codex.
## Fonti
- [README di AgriciDaniel/claude-obsidian](https://github.com/AgriciDaniel/claude-obsidian)
- [docs/install-guide.md](https://github.com/AgriciDaniel/claude-obsidian/blob/main/docs/install-guide.md)
- [Cartella skills/](https://github.com/AgriciDaniel/claude-obsidian/tree/main/skills)
- [SKILL.md di wiki](https://github.com/AgriciDaniel/claude-obsidian/blob/main/skills/wiki/SKILL.md)
- [claude-obsidian su skills.sh](https://skills.sh/AgriciDaniel/claude-obsidian)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+152
View File
@@ -0,0 +1,152 @@
# diagram-design
- **Autore:** Cathryn Lavery (LittleMight)
- **Repository:** [cathrynlavery/diagram-design](https://github.com/cathrynlavery/diagram-design) (licenza MIT)
- **Sorgente:** [skills/diagram-design/SKILL.md](https://github.com/cathrynlavery/diagram-design/blob/main/skills/diagram-design/SKILL.md) (versione 2.6)
- **Sito e galleria:** [diagramdesign.dev](https://diagramdesign.dev) · [galleria dei diagrammi](https://cathrynlavery.github.io/diagram-design/)
- **Pagina su skills.sh:** [cathrynlavery/diagram-design/diagram-design](https://skills.sh/cathrynlavery/diagram-design/diagram-design)
- **Diffusione (ottobre 2026):** circa 14.300 installazioni; il repository ha circa 56.800 stelle su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati, senza avvisi
## A cosa serve
Fa disegnare all'agente diagrammi curati nello stile della tua grafica, invece dei soliti riquadri arrotondati generici. Ogni diagramma è un unico file HTML con SVG incorporato, che si apre con un doppio clic. Lo stile è editoriale e prevede un solo colore d'accento per uno o due elementi chiave, linee sottili, nessuna ombra e coordinate su una griglia di 4 pixel. Può prendere colori e font dal tuo sito e rifare in questo stile anche diagrammi già esistenti in draw.io, Mermaid ed Excalidraw.
## Cosa fa
### Quando si attiva
Quando chiedi un diagramma a parole, per esempio:
- "Fammi un diagramma di architettura della mia app: frontend, backend, database, cache Redis";
- "Mi serve un quadrante con i progetti del secondo trimestre per impatto e sforzo";
- "Dammi una sequenza di una chiamata con bearer token e refresh su 401";
- "Onboard diagram-design to https://tuosito.com" (per prendere palette e font del sito);
- "Redraw this drawio file for my deck" (rifare un diagramma esistente), oppure l'esportazione di un diagramma in PNG o SVG.
Il `SKILL.md` elenca 45 tipi di visual (il README dice 45; la descrizione del repository su GitHub dice 44). Tra i principali: architettura, flowchart, sequence, macchina a stati, ER, timeline, swimlane, quadrante, radar, ciclo, albero, organigramma, Venn, piramide/funnel, grafici (barre, linee, scatter, treemap, heatmap, waterfall), Gantt, Sankey, Wardley map, kanban, user journey, UML a classi, schema di database.
### Come lavora
1. **Controlla lo stile (primo uso in un progetto).** Se lo style guide è ancora quello predefinito, si ferma e ti chiede se personalizzarlo: da URL di un sito, da una skill installata, da una cartella locale o design system, incollando i token a mano, tenendo il predefinito, o caricando un profilo salvato.
2. **Sceglie il tipo.** Se conta il comportamento (code, colli di bottiglia, confini di fiducia, difese a strati), sceglie prima uno dei nove *semantic pattern* e poi il tipo di diagramma più vicino per il layout. Per un caso normale carica il `SKILL.md` e il riferimento di quel solo tipo.
3. **Dichiara il piano prima di disegnare:** tipo, formato, dimensione e cosa verrà tagliato per stare nei limiti. Salta la pausa solo se la richiesta specifica già tutto.
4. **Disegna** rispettando i limiti di complessità (al massimo 9 nodi, 12 frecce, 2 elementi con l'accento, 2 note), altrimenti propone di dividere in due diagrammi, e le sei regole obbligatorie sui connettori (solo angoli retti, spazio tra etichetta e linea, niente sovrapposizioni, punti di attacco distinti, nessun passaggio dietro a un riquadro, maschere prima dei nodi).
5. **Controlla il risultato** con una lista di verifica e con `python3 scripts/self_check.py <file>`, che controlla accessibilità dell'SVG, file autonomo e contenuto dentro il `viewBox`.
6. **Produce un unico file `.html`:** CSS incorporato, SVG in linea, nessuna immagine esterna. Ogni SVG ha `role="img"`, `<title>` e `<desc>`.
Il principio di fondo è che la mossa migliore è di solito togliere: se una tabella o un paragrafo spiegano la stessa cosa, la skill suggerisce di non disegnare.
### Personalizzare lo stile (onboarding)
Senza personalizzazione i diagrammi escono in nero e arancio ("tangerine"). Con *"onboard diagram-design to https://tuosito.com"* l'agente legge la home, ricava i colori e i font, li assegna ai ruoli (`paper`, `ink`, `muted`, `accent`, `link`, font del titolo, dei nodi e dei sottotitoli), ti mostra le differenze e, dopo la tua conferma, scrive i valori in `references/style-guide.md`. Controlla anche il contrasto WCAG AA e, se non basta, propone un valore corretto.
| Rilevato dal sito | Diventa |
|---|---|
| sfondo di `<body>` | `paper` |
| colore del testo principale | `ink` |
| testo secondario | `muted` |
| card o contenitori | `paper-2` |
| colore del marchio più usato | `accent` |
| font di `<h1>` / `<body>` / `<code>` | font del titolo / dei nodi / dei sottotitoli |
Per più clienti puoi salvare un **profilo** con nome (in `~/.diagram-design/profiles/`) e aggiungere a ogni progetto un file `.diagram-design` con `profile: <nome>`.
### Importare ed esportare
- **Import:** rifà (non converte) file `.drawio`, `.mmd`/`.mermaid` o blocchi Mermaid nel Markdown, e `.excalidraw`. Tiene i contenuti (componenti, relazioni, raggruppamenti, direzione) e scarta coordinate, colori e font della sorgente. Si regola con quattro opzioni: formato (`html`, `svg`, `png`, `html+png`), dimensione (`doc-inline`, `slide-16x9`, `social-og`, `print-a4-landscape`, `fit` e altre), livello di dettaglio (`faithful` fino a 24 nodi, `balanced` fino a 12, `simplified` fino a 7) e destinatari (`engineer`, `mixed`, `executive`, che cambiano le parole e non il numero di nodi). Alla fine riporta un elenco di cosa è stato unito, ridotto o scartato.
- **Export:** su richiesta, salva il solo diagramma come SVG o PNG (`scripts/export_svg.py`, `scripts/export_png.py`). L'export non parte mai da solo. Il PNG usa Playwright (`pip install playwright && playwright install chromium`).
- **Animazione (facoltativa):** modalità `none` (predefinita), `reveal`, `step`, `loop`, con il fotogramma statico sempre completo e controlli nascosti se il sistema chiede meno movimento.
### Da sapere
- **Rete:** per impostazione predefinita ogni diagramma carica i font Instrument Serif, Geist e Geist Mono da Google Fonts, che è l'unica richiesta di rete. Chiedendo "system fonts" il file non fa alcuna richiesta. L'onboarding da sito fa scaricare all'agente alcune pagine di quel sito, e solo se lo chiedi. Secondo PRIVACY.md non ci sono server, account né telemetria.
- **Script eseguiti:** richiede Python 3 per `self_check.py` e per gli estrattori degli import (`drawio_extract.py`, `mermaid_extract.py`, `excalidraw_extract.py`). Il PNG richiede anche Playwright con Chromium. Il README e il `SKILL.md` descrivono gli script come locali; i file importati vanno trattati come dati non fidati, e la skill lo prevede.
- **Limiti dichiarati nel README:** la qualità dipende dal modello e lo stesso prompt può dare layout diversi; il risultato non è un formato sorgente modificabile (niente testo da confrontare in una pull request né canvas da trascinare). Per documenti in Git che cambiano a ogni sprint, il README consiglia Mermaid. Non va usata per elenchi, confronti di soli attributi o diagrammi con una sola forma.
- **Comandi in più solo con il plugin:** `/diagram-design:export-diagram`, `import-drawio`, `import-mermaid`, `import-excalidraw`, `profile` e `doctor` (in Pi senza prefisso). Con `npx skills` si installa solo la skill, senza questi comandi; si può chiedere tutto anche a parole.
- **Fonte ufficiale:** il README avverte che le versioni ufficiali vengono solo da questo repository; elenchi con altro nome sono copie non ufficiali.
## Installazione
Il README raccomanda il marketplace quando l'agente ne ha uno, perché dà aggiornamenti e comandi; `npx skills` installa solo la skill. Non usarli entrambi sullo stesso agente.
### Claude Code
Nella sessione, come due messaggi separati:
```text
/plugin marketplace add cathrynlavery/diagram-design
/plugin install diagram-design@diagram-design
```
Per gli aggiornamenti automatici: `/plugin` → **Marketplaces** → **diagram-design** → **Enable auto-update** (per i marketplace di terze parti è disattivato di default); poi `/reload-plugins` quando richiesto.
### Codex
```bash
codex plugin marketplace add cathrynlavery/diagram-design
codex plugin add diagram-design@diagram-design
```
Si aggiorna all'avvio; per forzarlo: `codex plugin marketplace upgrade diagram-design` e una nuova sessione.
### Claude Code e Codex (solo la skill)
```bash
npx skills add cathrynlavery/diagram-design -g -a claude-code -a codex
```
| Opzione | Significato |
|---|---|
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente |
| `-a <agente>` | agente di destinazione, ripetibile |
| `--copy` | copie indipendenti invece dei collegamenti simbolici (con più agenti il programma chiede il metodo e consiglia i collegamenti) |
| `-y` | salta le domande di conferma |
Il comando installa l'intera cartella della skill (`references/`, `assets/`, `scripts/`). Dopo l'installazione riavvia la sessione. Si può richiamare chiedendo un diagramma a parole; Claude Code la usa da solo quando la richiesta è pertinente.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update diagram-design # aggiornamento
npx skills remove diagram-design # rimozione
```
Per il plugin usa i comandi `plugin` del rispettivo agente. Il README segnala che un'installazione con `npx skills` esistente non passa da sola al marketplace: va rimossa prima di reinstallare con il plugin.
### App desktop di Claude e ChatGPT
Il README non documenta il caricamento come ZIP nelle app desktop di Claude e ChatGPT (PRIVACY.md cita ChatGPT tra gli agenti in cui la skill può essere installata, senza istruzioni). Si può provare con lo ZIP della sola cartella della skill:
```bash
git clone --depth 1 https://github.com/cathrynlavery/diagram-design.git
cd diagram-design/skills && zip -r ~/diagram-design.zip diagram-design
```
Lo ZIP deve contenere la cartella `diagram-design/` con dentro `SKILL.md`, `references/`, `assets/` e `scripts/`.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** la skill è pensata per agenti che lavorano su file locali. Nelle app di chat non ho verificato se la dimensione dello ZIP, gli script Python, il controllo con `self_check.py` e l'export PNG (che richiede Playwright) funzionino, e probabilmente l'onboarding da un sito e il profilo salvato in `~/.diagram-design/` non sono utilizzabili. Il disegno vero e proprio dei diagrammi in HTML dovrebbe restare possibile.
## Fonti
- [README di cathrynlavery/diagram-design](https://github.com/cathrynlavery/diagram-design)
- [SKILL.md di diagram-design](https://github.com/cathrynlavery/diagram-design/blob/main/skills/diagram-design/SKILL.md)
- [PRIVACY.md di diagram-design](https://github.com/cathrynlavery/diagram-design/blob/main/PRIVACY.md)
- [diagram-design su skills.sh](https://skills.sh/cathrynlavery/diagram-design/diagram-design)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+203
View File
@@ -0,0 +1,203 @@
# ecc (Everything Claude Code)
- **Autore:** Affaan Mustafa (affaan-m)
- **Repository:** [affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code) (il nome canonico indicato dal progetto è `affaan-m/ECC`; licenza MIT, versione 2.2.3 del 1 ottobre 2026)
- **Sorgenti:** [README](https://github.com/affaan-m/everything-claude-code), [AGENTS.md](https://github.com/affaan-m/everything-claude-code/blob/main/AGENTS.md), cartelle `agents/`, `skills/`, `hooks/`, `rules/`
- **Pagina su skills.sh:** [affaan-m/ecc](https://skills.sh/affaan-m/ecc)
- **Diffusione (ottobre 2026):** circa 1,4 milioni di installazioni complessive su skills.sh, che elenca 330 skill; il repository ha circa 292.900 stelle e 43.300 fork su GitHub
- **Controlli di sicurezza su skills.sh:** la pagina del repository non riporta esiti
- **Canali ufficiali** (indicati dal progetto): il repository GitHub, i pacchetti npm `ecc-universal` e `ecc-agentshield`, la GitHub App, il plugin `ecc@ecc` e il sito ecc.tools. Il progetto avverte che copie non ufficiali possono contenere malware.
> Non è una skill ma un **sistema di ottimizzazione per agenti di sviluppo**: 71 agenti, 314 skill, 98 comandi, hook, regole e uno scanner di sicurezza. I numeri sono quelli della pagina GitHub alla versione 2.2.3; skills.sh ne conta 330 e altre fonti, di versioni diverse, ne danno altri. Esistono molti fork (per esempio [unju-ai/ecc](https://github.com/unju-ai/ecc) o [ysyecust/everything-claude-code](https://github.com/ysyecust/everything-claude-code), quest'ultimo adattato al C++20); questa scheda riguarda solo il repository di affaan-m.
## A cosa serve
Dà all'agente un flusso di lavoro di ingegneria software strutturato: pianificare prima di costruire, scrivere i test per primi, farsi rivedere il codice da un agente con contesto pulito, verificare, e ricordare quanto imparato tra le sessioni. Invece di aggiungere una sola metodologia, offre un catalogo molto ampio di specialisti (revisori e risolutori di errori di build per ogni linguaggio) e di automazioni, da cui scegliere ciò che serve. È un'alternativa più grande e più invasiva di [superpowers](superpowers.md).
## Cosa fa
### Quando si attiva
I componenti partono in modi diversi:
- **agenti:** l'agente principale li delega quando il compito corrisponde (per esempio un revisore di Go dopo una modifica a codice Go);
- **skill:** si attivano quando la richiesta corrisponde alla loro descrizione;
- **comandi:** li lanci tu (`/ecc:plan`, `/code-review`...);
- **hook:** scattano da soli prima e dopo gli strumenti dell'agente e a inizio e fine sessione;
- **regole:** sono sempre caricate, se le copi nella cartella delle regole.
### Come lavora
Il flusso di sviluppo indicato dal progetto:
1. **Pianifica** le funzioni complesse prima di scrivere codice (`/ecc:plan "..."`, agente `planner`).
2. **Test per primi:** prima un test che fallisce, poi il codice minimo per farlo passare, poi il rifacimento; obiettivo di copertura dell'80% o più con test unitari, di integrazione ed E2E (agente `tdd-guide`).
3. **Revisione** con contesto pulito (`/code-review`), più revisori per linguaggio e per sicurezza (`security-reviewer`) prima dei commit.
4. **Documentazione** aggiornata nel posto giusto (`doc-updater`), poi commit con messaggi in stile *conventional commits*.
Principi dichiarati: delegare i compiti di dominio ad agenti specializzati e lanciare in parallelo quelli indipendenti; sicurezza prima di tutto (convalida degli ingressi, niente segreti scritti nel codice, query parametrizzate); immutabilità (creare nuovi oggetti invece di modificare quelli esistenti).
Comandi principali:
```text
/ecc:plan "..." # pianificazione
/code-review # revisione con contesto pulito
/build-fix /refactor-clean /security-scan
/context-budget /save-session /resume-session
/skill-create /mcp /evolve
agentshield scan --path . # audit della configurazione dell'agente
```
I comandi sono mantenuti per compatibilità: il progetto dice che i nuovi flussi vanno scritti come skill.
### Cosa contiene
| Cartella | Contenuto |
|---|---|
| `agents/` | 71 sottoagenti specializzati |
| `skills/` | 314 skill di flusso di lavoro e di conoscenza di dominio: la superficie principale |
| `commands/` | 98 comandi, mantenuti per compatibilità |
| `hooks/` | automazioni a eventi |
| `rules/` | regole sempre valide, comuni e per linguaggio |
| `scripts/` | utilità Node.js multipiattaforma |
| `mcp-configs/` | 14 configurazioni di server MCP |
| `tests/` | batteria di test del progetto |
**Agenti, per gruppo** (l'elenco completo è in `agents/`):
| Gruppo | Agenti |
|---|---|
| Flusso base | `planner`, `architect`, `tdd-guide`, `code-reviewer`, `security-reviewer`, `spec-miner` (ricava specifiche da progetti esistenti), `doc-updater`, `refactor-cleaner`, `e2e-runner` (Playwright), `docs-lookup` (documentazione via Context7) |
| Linguaggi e framework | revisori e, dove serve, risolutori di errori di build per C/C++, F#, Go, Kotlin, Python/Django/FastAPI, Java/Spring, Rust, PyTorch, TypeScript/JavaScript, React, Vue, Swift, Flutter/Dart, C#/.NET, PHP, HarmonyOS e database (PostgreSQL/Supabase) |
| Analisi della qualità | `silent-failure-hunter` (errori ingoiati), `type-design-analyzer`, `pr-test-analyzer`, `code-explorer`, `code-simplifier`, `comment-analyzer`, `agent-evaluator` |
| Prestazioni e architettura | `performance-optimizer`, `code-architect`, `a11y-architect` (accessibilità WCAG 2.2), `harness-optimizer`, `loop-operator` |
| Reti | `network-architect`, `homelab-architect`, `network-config-reviewer`, `network-troubleshooter` |
| ML | `mle-reviewer`, `rag-pipeline-reviewer` |
| Pubblicazione open source | `opensource-forker`, `opensource-sanitizer`, `opensource-packager` |
| Altri ambiti | `healthcare-reviewer`, `chief-of-staff` (smista e scrive la posta), `marketing-agent`, `seo-specialist`, `bengali-reviewer`, `conversation-analyzer` |
| GAN harness | `gan-planner`, `gan-generator`, `gan-evaluator` |
L'elenco delle skill non l'ho trovato in forma ordinata: i documenti letti citano solo i linguaggi e i framework coperti (Go, Python, Perl, Swift, TypeScript, HarmonyOS/ArkTS, Django, NestJS, Spring Boot, Laravel). Non ho letto i singoli `SKILL.md`.
### Hook installati
Secondo `hooks/README.md`:
| Momento | Cosa fanno |
|---|---|
| Prima di uno strumento | blocca `npm run dev` e simili fuori da tmux; ricorda tmux per i comandi lunghi; ricorda di rivedere le modifiche prima del push; controllo prima del commit (analizza i file in stage, convalida i messaggi di commit, cerca `console.log`, `debugger` e segreti, e blocca sui problemi gravi); avvisa per file `.md` o `.txt` non standard; suggerisce `/compact` ogni circa 50 chiamate; valuta le regole locali di Hookify |
| Dopo uno strumento | registra l'URL della PR dopo `gh pr create`; analisi in background dopo le build; controlli rapidi di qualità; formatta i file JS/TS con Prettier; esegue `tsc --noEmit` dopo le modifiche a `.ts`/`.tsx`; avvisa dei `console.log` |
| Inizio sessione | carica il contesto precedente, riconosce il gestore dei pacchetti |
| Prima della compattazione | salva lo stato |
| Fine sessione | salva il riepilogo della sessione, estrae schemi per l'apprendimento continuo, registra una stima dei costi, mostra una notifica sul desktop (macOS) |
Si regolano con variabili d'ambiente: `ECC_HOOK_PROFILE` (`minimal`, `standard` predefinito, `strict`), `ECC_DISABLED_HOOKS` (elenco di identificatori separati da virgole, per esempio `pre:bash:tmux-reminder,post:edit:typecheck`), `ECC_HOOKS_ENABLED` come interruttore generale e `ECC_GATEGUARD=off` per spegnere solo GateGuard.
### Da sapere
- **Invasivo:** installa hook che girano a ogni comando e a ogni modifica, scrivono script sotto `~/.claude/` e salvano lo stato delle sessioni (riepiloghi, schemi appresi, stime dei costi). La documentazione degli hook non dice dove finiscano questi file né cosa contengano, e non descrive chiamate di rete.
- **Contesto:** regole e server MCP consumano la finestra di contesto. Il progetto consiglia poche regole (le regole comuni più un solo linguaggio), meno di 10 server MCP e meno di 80 strumenti attivi. Il plugin non attiva da solo i server MCP inclusi.
- **Un solo metodo di installazione per strumento:** sovrapporne più di uno duplica skill, comandi e hook (errori come "Duplicate hooks file"). Se usi il plugin, non copiare a mano `hooks/hooks.json` nelle impostazioni.
- **Impostazioni consigliate dal progetto:** modello Sonnet come predefinito, sforzo medio, compattazione del contesto al 50% invece che al 95%.
- **Requisiti:** Node.js 18 o più recente; per il plugin di Claude Code anche Git e Claude Code 2.1 o più recente nel `PATH`. Alcune funzioni facoltative su Windows nativo e macOS richiedono Bash, Python o WSL.
- **Servizi a pagamento:** il progetto si finanzia con sponsor e un livello a pagamento, *ECC Pro* (GitHub App ospitata con analisi dei repository privati e verifiche sulle PR). Il resto è libero.
- **Sicurezza:** include AgentShield (scanner delle configurazioni degli agenti, con analisi approfondita facoltativa basata su Opus), GateGuard e un controllo della catena di fornitura nella CI. Sono dichiarazioni del progetto: non le ho verificate.
- **Maturità e supporto:** Claude Code è il riferimento stabile; Codex e Qoder hanno plugin nativi con meno hook; Cursor e OpenCode sono adattatori in beta; GitHub Copilot ha solo istruzioni in chat e skill/agenti in beta nella CLI; Gemini, Zed, Antigravity, Qwen, Hermes, OpenClaw, Kimi, CodeBuddy e JoyCode sono sperimentali. Il progetto non dichiara parità di funzioni fuori da Claude Code.
- **Memoria condivisa (Memory Vault):** passaggio di consegne tra strumenti in Markdown, installato a parte da npm. La memoria richiamata va trattata come contesto non verificato, non come istruzioni.
- **Fonti non lette per intero:** ho letto il README quasi per intero, ma non le guide collegate (installazione dettagliata, risoluzione dei problemi, Windows) né i singoli file di skill e agenti.
## Installazione
### Claude Code e Codex
**Claude Code, installazione guidata** (consigliata dal progetto):
```bash
npx ecc-universal@2.2.3 setup
```
**Claude Code, comandi del plugin:**
```text
/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc
```
**Codex, plugin nativo:**
```bash
codex plugin marketplace add affaan-m/ECC
codex plugin add ecc@ecc
codex plugin list --json
```
**Più strumenti insieme** (Claude Code, Codex, Kimi Code), con procedura guidata:
```bash
npx ecc-universal@2.2.3 install --guided
```
**Installazione manuale o minima**, da una copia del repository:
```bash
./install.sh --profile minimal --target claude
./install.sh --profile full --enable-hooks
```
| Opzione | Significato |
|---|---|
| `--profile minimal` / `--profile full` | insieme ridotto o completo di componenti |
| `--target claude` | strumento di destinazione |
| `--enable-hooks` / `--no-hooks` | una delle due va indicata se l'installazione aggiungerebbe hook |
Altre vie descritte dal progetto: Qoder CLI (`qoder plugins install .`), Cursor, OpenCode e altri tramite adattatori; non le ho provate.
**Regole:** i plugin di Claude Code non le distribuiscono. Copia `rules/common` più un solo pacchetto per il tuo linguaggio in `~/.claude/rules/ecc/`, e tienile poche perché sono sempre caricate.
Dopo l'installazione riavvia la sessione. Non fare due installazioni diverse sullo stesso strumento.
Gestione: il progetto indica i comandi `list-installed`, `doctor`, `repair` e `uninstall --dry-run` per vedere, riparare o togliere un'installazione, e dice che rilanciare l'installazione guidata aggiorna ECC o ne cambia l'ambito e il profilo degli hook. La sintassi esatta non l'ho verificata. Per il plugin vale il gestore dei plugin dell'agente (`/plugin` in Claude Code); per un aggiornamento di versione cambia il numero nel comando `npx`.
```bash
npx skills add affaan-m/ecc # solo le skill, senza agenti, hook e regole
```
Quest'ultimo comando è la forma standard dello strumento `skills` per i repository di skill, che skills.sh elenca per questo progetto: non l'ho provato e porta solo le skill, non l'insieme intero.
### App desktop di Claude e ChatGPT
Queste app caricano una skill alla volta come ZIP; il plugin completo non si può installare, e perdi agenti, hook e regole, che sono la parte principale. Per provare una singola skill:
```bash
git clone --depth 1 https://github.com/affaan-m/ECC.git
cd ECC/skills && zip -r ~/<nome-skill>.zip <nome-skill>
```
Lo ZIP deve contenere la cartella della skill con dentro `SKILL.md`.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** qui non ha senso usarlo come sistema. ECC lavora con sottoagenti, hook, regole e comandi su un progetto locale, e le app di chat non li hanno. Una singola skill di conoscenza può funzionare, ma senza il resto del flusso; non ho verificato come reagiscono le app a una skill che presuppone altri componenti.
## Fonti
- [README di affaan-m/everything-claude-code](https://github.com/affaan-m/everything-claude-code)
- [AGENTS.md](https://github.com/affaan-m/everything-claude-code/blob/main/AGENTS.md)
- [hooks/README.md](https://github.com/affaan-m/everything-claude-code/blob/main/hooks/README.md)
- [Cartella agents/](https://github.com/affaan-m/everything-claude-code/tree/main/agents)
- [Release del progetto](https://github.com/affaan-m/everything-claude-code/releases)
- [ecc su skills.sh](https://skills.sh/affaan-m/ecc)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+49 -31
View File
@@ -96,49 +96,67 @@ Il README riporta un confronto su un vault reale di 38 pagine con Claude Sonnet:
### Claude Code e Codex ### Claude Code e Codex
Percorso consigliato dal progetto, con la CLI Python (installa le skill in tutti gli agenti rilevati, comprese Claude Code e Codex): Il percorso più semplice è quello standard, senza Python: installa solo le skill. Poi, in qualsiasi progetto, di' **"set up my wiki"**: la skill `wiki-setup` chiede dove creare il vault e scrive la configurazione in `~/.config/obsidian-wiki/config`.
```bash **Plugin di Claude Code** (solo Claude Code), nella sessione:
pip install obsidian-wiki
obsidian-wiki setup --vault ~/brain ```text
/plugin marketplace add Ar9av/obsidian-wiki
/plugin install obsidian-wiki@obsidian-wiki
``` ```
Poi apri un progetto nell'agente e di': **"set up my wiki"**. I comandi hanno il prefisso del plugin, per esempio `/obsidian-wiki:wiki-ingest`.
| Opzione o comando | Significato | **`npx skills`** (Claude Code e Codex), serve Node.js:
```bash
npx skills add Ar9av/obsidian-wiki -g -a claude-code -a codex
```
| Opzione | Significato |
|---|---| |---|---|
| `uv tool install obsidian-wiki` / `pipx install obsidian-wiki` | alternative a `pip`; non usare `uvx` perché i collegamenti delle skill punterebbero a un ambiente temporaneo (se serve, `uvx obsidian-wiki setup --copy`) | | `--skill <nome>` | installa solo la skill indicata (ripetibile); senza, propone tutte |
| `--vault <percorso>` | cartella del vault (nuova o già vault Obsidian); se manca te la chiede | | `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente |
| `--no-hooks` | non registra i due hook di sessione | | `-a <agente>` | agente di destinazione, ripetibile |
| `--copy` | copia i file delle skill invece di creare collegamenti simbolici | | `-y` | salta le domande di conferma |
| `--project .` | aggiunge anche skill locali e `AGENTS.md` al progetto corrente |
| `--timezone <fuso>` | fuso orario per le date scritte nel vault |
Alternative: Dopo l'installazione riavvia la sessione; in Codex le skill si richiamano con `$nome` (per esempio `$wiki-query`) e si vedono con `/skills`.
- **Plugin per Claude Code** (senza Python, solo skill: niente hook né CLI): Limiti di questi due metodi, uguali per entrambi:
```text - non c'è la CLI `obsidian-wiki` (niente `doctor`, `sessions-build`, `sessions-query`, API Python); le skill di ingest hanno un'alternativa con `sha256sum` al posto di `cache-check`;
/plugin marketplace add Ar9av/obsidian-wiki - non ci sono gli hook di sessione (né il riepilogo all'avvio né il suggerimento a fine sessione); `wiki-setup` può comunque installare quello di fine sessione, dopo averti chiesto conferma;
/plugin install obsidian-wiki@obsidian-wiki - il progetto dichiara deprecata la via `npx skills`, perché non scrive la configurazione globale né collega le skill agli altri agenti.
```
I comandi hanno il prefisso del plugin, per esempio `/obsidian-wiki:wiki-ingest`. Poi di' "set up my wiki" per impostare il vault. Gestione:
- **Clone del repository:** `git clone https://github.com/Ar9av/obsidian-wiki.git && cd obsidian-wiki && bash setup.sh`.
- **Skills CLI** (`npx skills add Ar9av/obsidian-wiki -g -a claude-code -a codex`): il progetto la dichiara **deprecata**, perché installa solo le skill nell'agente corrente senza scrivere la configurazione globale né i collegamenti agli altri agenti.
Verifica e gestione: ```text
/plugin marketplace update obsidian-wiki # aggiornamento del plugin
```bash /plugin uninstall obsidian-wiki@obsidian-wiki # rimozione del plugin
obsidian-wiki doctor # controlla installazione e stato del vault
obsidian-wiki info # mostra i percorsi risolti
obsidian-wiki hooks status # gli hook sono registrati e raggiungibili?
obsidian-wiki hooks uninstall # toglie solo gli hook di questo progetto
pip install -U obsidian-wiki # aggiornamento (con uv: uv tool upgrade obsidian-wiki; con pipx: pipx upgrade obsidian-wiki)
obsidian-wiki setup # da rilanciare dopo l'aggiornamento per avere le skill nuove
``` ```
Per il plugin: `claude plugin marketplace update obsidian-wiki`, poi `claude plugin update obsidian-wiki@obsidian-wiki` e riavvio di Claude Code. Il progetto non documenta nei file che ho letto un comando di disinstallazione completo della CLI (collegamenti simbolici, configurazione): non l'ho verificato. In Claude Code, `/plugin uninstall obsidian-wiki@obsidian-wiki` rimuove il plugin. Dopo l'installazione riavvia la sessione; in Codex le skill si richiamano con `$nome` (per esempio `$wiki-query`) e si vedono con `/skills`. ```bash
npx skills list -g # skill installate
npx skills update # aggiornamento
npx skills remove <nome> # rimozione
```
Per il plugin il progetto indica `claude plugin marketplace update obsidian-wiki`, poi `claude plugin update obsidian-wiki@obsidian-wiki` e il riavvio di Claude Code.
### CLI Python (completa, facoltativa)
Aggiunge la CLI `obsidian-wiki`, l'API Python, gli hook di sessione e il collegamento delle skill a tutti gli agenti rilevati. Il progetto la consiglia, ma richiede Python:
```bash
pipx install obsidian-wiki # oppure: uv tool install obsidian-wiki
obsidian-wiki setup --vault ~/brain
obsidian-wiki doctor # controlla installazione e stato del vault
```
- Su Debian e Raspberry Pi OS `pip install` fuori da un ambiente virtuale dà l'errore `externally-managed-environment`: usa `pipx` (`sudo apt install pipx && pipx ensurepath`, poi riapri il terminale) o `uv`. Non usare `uvx`: i collegamenti delle skill punterebbero a un ambiente temporaneo (se serve, `uvx obsidian-wiki setup --copy`).
- Il `setup` registra due hook di Claude Code, che leggono i dati delle conversazioni: salta con `--no-hooks`, rimuovili con `obsidian-wiki hooks uninstall`.
- Altre opzioni: `--vault <percorso>`, `--copy` (copia le skill invece di collegarle), `--project .` (aggiunge skill locali e `AGENTS.md` al progetto), `--timezone <fuso>`. Alternativa al `pipx`: `git clone https://github.com/Ar9av/obsidian-wiki.git && cd obsidian-wiki && bash setup.sh`.
- Aggiornamento: `pipx upgrade obsidian-wiki` (o `uv tool upgrade obsidian-wiki`), poi di nuovo `obsidian-wiki setup`. Il progetto non documenta nei file che ho letto un comando di disinstallazione completo (collegamenti simbolici, configurazione): non l'ho verificato.
### App desktop di Claude e ChatGPT ### App desktop di Claude e ChatGPT
+171
View File
@@ -0,0 +1,171 @@
# pdf
- **Autore:** Anthropic
- **Repository:** [anthropics/skills](https://github.com/anthropics/skills), la raccolta di skill di esempio di Anthropic
- **Sorgente:** [skills/pdf/SKILL.md](https://github.com/anthropics/skills/blob/main/skills/pdf/SKILL.md), con le guide [forms.md](https://github.com/anthropics/skills/blob/main/skills/pdf/forms.md) e [reference.md](https://github.com/anthropics/skills/blob/main/skills/pdf/reference.md) e una cartella `scripts/`
- **Pagina su skills.sh:** [anthropics/skills/pdf](https://skills.sh/anthropics/skills/pdf)
- **Diffusione (ottobre 2026):** circa 219.700 installazioni (su skills.sh dal 20 gennaio 2026); il repository ha circa 184.900 stelle e 21.900 fork su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub e Socket superati; Snyk segnala un avviso (la pagina non spiega il motivo)
- **Licenza:** proprietaria (termini in `LICENSE.txt`). Il README del repository precisa che le skill per i documenti (`docx`, `pdf`, `pptx`, `xlsx`) sono *source-available*, non open source, e che le skill del repository sono dimostrative: conviene provarle bene prima di affidarsi a loro.
## A cosa serve
Dà all'agente un metodo per lavorare sui file PDF: leggerli, unirli e dividerli, compilarli, crearne di nuovi e ripulire quelli scansionati. Invece di improvvisare ogni volta con la libreria che gli viene in mente, sceglie lo strumento indicato per ciascun compito.
## Cosa fa
### Quando si attiva
Ogni volta che la richiesta riguarda un file PDF o la sua creazione:
- leggere o estrarre testo e tabelle, leggere i metadati;
- unire più PDF in uno, dividerne uno in più file, ruotare le pagine;
- aggiungere una filigrana;
- creare un PDF nuovo;
- compilare un modulo;
- proteggere con password o togliere la password;
- estrarre le immagini incorporate;
- fare l'OCR di un PDF scansionato per renderlo ricercabile.
### Come lavora
L'agente sceglie lo strumento in base al compito:
| Compito | Strumento | Come |
|---|---|---|
| Unire | pypdf | aggiunge le pagine di ogni file a un unico file di uscita |
| Dividere | pypdf | scrive una pagina per file |
| Estrarre il testo | pdfplumber | testo pagina per pagina, con il layout |
| Estrarre le tabelle | pdfplumber | tabelle pagina per pagina; si possono convertire in pandas ed esportare in Excel |
| Creare PDF | reportlab | `Canvas` per impaginazioni semplici, `Platypus` per documenti di più pagine con testo che scorre |
| Unire da riga di comando | qpdf | opzione `--empty --pages` |
| OCR | pytesseract | prima converte le pagine in immagini con pdf2image |
| Compilare moduli | pdf-lib o pypdf | segue `forms.md` |
Esempio di unione, dalla guida:
```python
from pypdf import PdfWriter, PdfReader
writer = PdfWriter()
for pdf_file in ["doc1.pdf", "doc2.pdf", "doc3.pdf"]:
reader = PdfReader(pdf_file)
for page in reader.pages:
writer.add_page(page)
with open("merged.pdf", "wb") as output:
writer.write(output)
```
Altre operazioni previste:
- **Strumenti da riga di comando:** `pdftotext` (poppler-utils) per estrarre il testo, anche con il layout o solo un intervallo di pagine; `qpdf` per unire, dividere per intervallo, ruotare pagine e togliere una password; `pdftk` se è installato.
- **Filigrane:** carica una pagina di filigrana e la sovrappone a ogni pagina.
- **Immagini:** `pdfimages` esporta le immagini incorporate.
- **Password:** copia le pagine in un nuovo file e lo cifra con password utente e proprietario.
- **Pedici e apici:** nei PDF creati con reportlab non usa i caratteri Unicode per pedici e apici, perché i font integrati non li hanno e compaiono come quadrati neri; usa i marcatori `<sub>` e `<super>` dentro i `Paragraph`.
- **Casi avanzati:** `reference.md` copre pypdfium2, pdf-lib per JavaScript e la risoluzione dei problemi. Non l'ho letto per intero.
### Compilare i moduli
Il flusso è in `forms.md` e dipende dal tipo di PDF. Il primo passo è controllare se il modulo ha campi compilabili (`scripts/check_fillable_fields.py`).
**PDF con campi compilabili:**
1. `extract_form_field_info.py` elenca i campi (identificatore, pagina, posizione, tipo: testo, casella, gruppo di opzioni, scelta).
2. `convert_pdf_to_images.py` crea un'immagine per pagina, per capire a cosa serve ogni campo.
3. Si scrive `field_values.json` con i valori da inserire.
4. `fill_fillable_fields.py` compila il modulo; se segnala errori, si correggono e si rilancia.
**PDF senza campi compilabili:**
1. `extract_form_structure.py` estrae etichette, linee, caselle e righe.
2. Due approcci: *strutturale* (preferito, se ci sono etichette di testo utili) o *visivo* (per le scansioni, con ingrandimenti fatti con ImageMagick); si possono combinare.
3. `check_bounding_boxes.py` valida i riquadri, perché riquadri sovrapposti o troppo piccoli rovinano il testo.
4. `fill_pdf_form_with_annotations.py` scrive il testo come annotazioni.
5. Si controlla il risultato rendendolo di nuovo in immagini.
Avvertenze della guida: i passi vanno fatti in ordine; identificatori e valori devono coincidere con quelli estratti; l'estrazione strutturale riconosce solo le caselle quadrate; i sistemi di coordinate dei campi compilabili e dell'approccio strutturale hanno origini diverse, e mescolarli sposta il testo; il risultato va sempre controllato a vista.
### Da sapere
- **Requisiti:** librerie Python pypdf, pdfplumber, reportlab, pandas (per esportare le tabelle), pytesseract e pdf2image (per l'OCR); strumenti poppler-utils e qpdf, pdftk facoltativo; ImageMagick per l'approccio visivo dei moduli. Per l'OCR serve anche il programma Tesseract (installato a parte; la guida non lo spiega).
- **Script eseguiti:** per i moduli l'agente lancia gli script della cartella `scripts/` (otto file Python). Non li ho letti uno per uno.
- **Nessun accesso esterno** dichiarato: lavora sui file locali.
- **Limite di fedeltà:** estrazione e OCR non sono perfette su layout complessi o scansioni di bassa qualità; l'autore invita a verificare il risultato.
## Installazione
### Claude Code e Codex
```bash
npx skills add anthropics/skills --skill pdf -g -a codex -a claude-code
```
| Opzione | Significato |
|---|---|
| `--skill pdf` | installa solo questa skill del repository |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente (`.claude/skills/`, `.agents/skills/`) |
| `-a <agente>` | agente di destinazione, ripetibile (`claude-code`, `codex`, ...) |
| `-y` | salta le domande di conferma |
| `--copy` | copia i file invece di creare collegamenti simbolici |
Non ho trovato il comando esatto sulla pagina di skills.sh: è la forma standard dello strumento `skills`, la stessa usata per le altre schede.
Alternativa solo per Claude Code, dal marketplace di Anthropic (installa tutte le skill per i documenti: `docx`, `pdf`, `pptx`, `xlsx`):
```text
/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills
```
Dopo l'installazione riavvia la sessione. Claude Code la usa da solo quando la richiesta è pertinente, oppure puoi citarla ("usa la skill PDF per estrarre i campi del modulo `percorso/file.pdf`"). In Codex la richiami con `$pdf` o la vedi con `/skills`.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update pdf # aggiornamento
npx skills remove pdf # rimozione
```
```text
/plugin uninstall document-skills@anthropic-agent-skills # rimozione del plugin
```
### App desktop di Claude e ChatGPT
Queste app richiedono di caricare la skill come ZIP. Preparalo così:
```bash
git clone --depth 1 https://github.com/anthropics/skills.git
cd skills/skills && zip -r ~/pdf.zip pdf
```
Lo ZIP deve contenere la cartella `pdf/` con dentro `SKILL.md` (e gli altri file della cartella: `forms.md`, `reference.md`, `scripts/`).
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** nelle app di chat la skill gira in un ambiente isolato con esecuzione del codice. Funziona solo se lì sono disponibili le librerie e gli strumenti elencati sopra (non l'ho verificato), e legge solo i file che alleghi alla conversazione. Il README del repository dice che le skill di esempio sono già disponibili sui piani a pagamento di Claude.ai, ma non specifica se `pdf` sia tra queste.
## Fonti
- [README di anthropics/skills](https://github.com/anthropics/skills)
- [SKILL.md di pdf](https://github.com/anthropics/skills/blob/main/skills/pdf/SKILL.md)
- [forms.md di pdf](https://github.com/anthropics/skills/blob/main/skills/pdf/forms.md)
- [Cartella skills/pdf](https://github.com/anthropics/skills/tree/main/skills/pdf) e [scripts/](https://github.com/anthropics/skills/tree/main/skills/pdf/scripts)
- [pdf su skills.sh](https://skills.sh/anthropics/skills/pdf)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+166
View File
@@ -0,0 +1,166 @@
# pptx
- **Autore:** Anthropic
- **Repository:** [anthropics/skills](https://github.com/anthropics/skills), la raccolta di skill di esempio di Anthropic
- **Sorgente:** [skills/pptx/SKILL.md](https://github.com/anthropics/skills/blob/main/skills/pptx/SKILL.md), con `LICENSE.txt` e una cartella `scripts/`
- **Pagina su skills.sh:** [anthropics/skills/pptx](https://skills.sh/anthropics/skills/pptx)
- **Diffusione (ottobre 2026):** circa 245.300 installazioni (su skills.sh dal 20 gennaio 2026); il repository ha circa 184.900 stelle e 21.900 fork su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub e Snyk superati; Socket segnala un avviso (la pagina non spiega il motivo)
- **Licenza:** proprietaria (termini in `LICENSE.txt`). Il README del repository precisa che le skill per i documenti (`docx`, `pdf`, `pptx`, `xlsx`) sono *source-available*, non open source, e che le skill del repository sono dimostrative: conviene provarle bene prima di affidarsi a loro.
## A cosa serve
Fa creare, leggere e modificare presentazioni PowerPoint all'agente, controllando poi il risultato slide per slide. Non si limita a scrivere un file: lo trasforma in immagini, cerca testo che esce dai bordi, sovrapposizioni e problemi di spaziatura, e li corregge prima di consegnare.
## Cosa fa
### Quando si attiva
Ogni volta che la richiesta riguarda un file `.pptx` o `.potx`:
- creare una presentazione nuova (slide, pitch deck);
- leggere o estrarre il testo di una presentazione;
- modificarne una esistente: duplicare o riordinare slide, cambiare i contenuti;
- partire da un modello (`.potx`), lavorare con layout, note del relatore e commenti.
### Come lavora
L'agente sceglie il percorso in base al compito:
| Compito | Come |
|---|---|
| Creare | scrive uno script **pptxgenjs** (libreria JavaScript) che genera il file |
| Modificare o usare un modello | decomprime il file, modifica l'XML delle slide e lo ricomprime |
| Leggere | estrae il testo con **markitdown** (un blocco per slide) o costruisce una griglia di miniature per vedere i layout |
Alternativa nominata per la creazione: **python-pptx**, con limiti nella duplicazione delle slide, nella formattazione del testo e in alcuni tipi di immagine.
**Script di aiuto** (cartella `scripts/`):
| Script | A cosa serve |
|---|---|
| `thumbnail.py` | griglia di miniature con etichette; ogni presentazione deve avere un prefisso suo, così le griglie non si sovrascrivono |
| `add_slide.py` | duplica slide o layout e gestisce da solo la contabilità interna del pacchetto |
| `clean.py` | toglie slide, immagini e relazioni non più referenziate; va lanciato quando l'elenco delle slide è definitivo |
| `validate.py` | controlla schema, relazioni, tipi di contenuto e grafici; con `--original` per le presentazioni nate da un modello |
| `soffice.py` | avvolge LibreOffice per la conversione senza interfaccia |
**Controllo di qualità**, in quattro passi:
1. controlla il contenuto con markitdown: testo mancante, refusi, segnaposto dimenticati;
2. esegue la validazione (con `--original` se parte da un modello);
3. converte in PDF e poi in immagini JPEG e ispeziona ogni slide: bordi, sovrapposizioni, spaziatura, allineamento, contrasto;
4. dopo le correzioni rigenera PDF e immagini dal file modificato e ricontrolla solo le slide cambiate.
### Regole per modificare
- prima tutte le modifiche strutturali (aggiungere, togliere, riordinare), poi i contenuti, perché duplicare una slide ne copia lo stato attuale;
- le slide non si copiano a mano, ma con `add_slide.py`;
- l'XML si legge con `defusedxml.minidom` e non con `ElementTree`, per non perdere gli spazi dei nomi;
- gli spazi non usati di un modello vanno rimossi del tutto, con le immagini che contengono;
- un paragrafo per ogni voce di elenco, con i puntini ereditati dal layout.
### Trappole di pptxgenjs che la skill segnala
- imposta il layout prima di aggiungere le slide: quello predefinito è 10" × 5,625", non il formato panoramico;
- colori esadecimali senza `#` e senza cifre di trasparenza, altrimenti il file si corrompe;
- non riusare gli stessi oggetti di opzioni tra le chiamate, perché la libreria li modifica;
- gli scostamenti delle ombre non possono essere negativi;
- si usa `charSpacing`, non `letterSpacing`;
- gli elenchi puntati con l'opzione `bullet`, non con caratteri letterali;
- un'istanza del generatore per ogni file di uscita;
- niente sfumature: si usa un'immagine con la sfumatura;
- i grafici restano nativi (quelli in pila non accettano le etichette `outEnd`; i grafici combinati con assi secondari richiedono due voci per `valAxes` e `catAxes`);
- non riordinare mai i figli di `<p:presentation>`;
- validare dopo ogni generazione e correggere il problema nel generatore, non nel file.
### Indicazioni di design
- una palette adatta all'argomento, con un colore dominante e un accento deciso;
- un elemento visivo per slide (immagine, grafico, icona, forma) e layout vari;
- caratteri sicuri per il corpo del testo (Arial, Calibri, Cambria, Times New Roman e simili);
- titoli da 36-44 pt, intestazioni di sezione da 20-24 pt, testo da 14-16 pt, didascalie da 10-12 pt;
- margini di almeno 0,5" e distanze di 0,3-0,5";
- da evitare: righe decorative sotto i titoli, barre o strisce colorate, sfondi color crema, testo centrato nel corpo, testo che esce dalla forma.
### Da sapere
- **Requisiti:** Node.js con pptxgenjs, Python con markitdown, Pillow, defusedxml e lxml, LibreOffice e Poppler (`pdftoppm`). La skill indica anche react-icons, react, react-dom e sharp tra i pacchetti usati (per le icone). pptxgenjs è dato come già installato nell'ambiente previsto.
- **Script eseguiti:** i cinque della cartella `scripts/`, più i comandi di LibreOffice e `pdftoppm`. Non ho letto i file Python: GitHub non mostrava il contenuto di `scripts/`.
- **Nessun accesso esterno** dichiarato: lavora sui file locali.
- **Qualità del risultato:** il controllo è visivo e lo fa il modello guardando le immagini; non sostituisce una rilettura tua.
## Installazione
### Claude Code e Codex
```bash
npx skills add anthropics/skills --skill pptx -g -a codex -a claude-code
```
| Opzione | Significato |
|---|---|
| `--skill pptx` | installa solo questa skill del repository |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente (`.claude/skills/`, `.agents/skills/`) |
| `-a <agente>` | agente di destinazione, ripetibile (`claude-code`, `codex`, ...) |
| `-y` | salta le domande di conferma |
| `--copy` | copia i file invece di creare collegamenti simbolici |
Non ho trovato il comando esatto sulla pagina di skills.sh: è la forma standard dello strumento `skills`, la stessa usata per le altre schede.
Alternativa solo per Claude Code, dal marketplace di Anthropic (installa tutte le skill per i documenti: `docx`, `pdf`, `pptx`, `xlsx`):
```text
/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills
```
Dopo l'installazione riavvia la sessione. Claude Code la usa da solo quando la richiesta è pertinente. In Codex la richiami con `$pptx` o la vedi con `/skills`.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update pptx # aggiornamento
npx skills remove pptx # rimozione
```
```text
/plugin uninstall document-skills@anthropic-agent-skills # rimozione del plugin
```
### App desktop di Claude e ChatGPT
Queste app richiedono di caricare la skill come ZIP. Preparalo così:
```bash
git clone --depth 1 https://github.com/anthropics/skills.git
cd skills/skills && zip -r ~/pptx.zip pptx
```
Lo ZIP deve contenere la cartella `pptx/` con dentro `SKILL.md` e la cartella `scripts/`.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** nelle app di chat la skill gira in un ambiente isolato con esecuzione del codice. Funziona solo se lì sono disponibili pptxgenjs, LibreOffice e Poppler (non l'ho verificato), e legge solo i file che alleghi alla conversazione. Il README del repository dice che le skill di esempio sono già disponibili sui piani a pagamento di Claude.ai, ma non specifica se `pptx` sia tra queste.
## Fonti
- [README di anthropics/skills](https://github.com/anthropics/skills)
- [SKILL.md di pptx](https://github.com/anthropics/skills/blob/main/skills/pptx/SKILL.md)
- [Cartella skills/pptx](https://github.com/anthropics/skills/tree/main/skills/pptx)
- [pptx su skills.sh](https://skills.sh/anthropics/skills/pptx)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+136
View File
@@ -0,0 +1,136 @@
# retro
- **Autore:** Matt Pocock
- **Repository:** [mattpocock/skills](https://github.com/mattpocock/skills) (licenza MIT)
- **Sorgente:** [skills/engineering/retro/SKILL.md](https://github.com/mattpocock/skills/blob/main/skills/engineering/retro/SKILL.md)
- **Documentazione della skill:** [docs/engineering/retro.md](https://github.com/mattpocock/skills/blob/main/docs/engineering/retro.md)
- **Pagina su skills.sh:** [mattpocock/skills/retro](https://skills.sh/mattpocock/skills/retro)
- **Diffusione (ottobre 2026):** circa 242.000 installazioni; il repository ha circa 294.700 stelle su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati, senza avvisi
## A cosa serve
Fa una retrospettiva su una sessione di lavoro con l'agente e propone come migliorare l'**ambiente** in cui l'agente lavora, così la volta dopo va meglio. Non corregge il codice: parte da un momento in cui l'agente ha faticato (un file trovato dopo venti chiamate, un errore che un controllo automatico avrebbe fermato, una regola che il revisore ha lasciato passare) e chiede cosa, nel repository, l'ha permesso. La risposta è un elenco di modifiche candidate, dalla più grave alla meno grave.
## Cosa fa
### Quando si attiva
Solo quando la richiami tu con `/retro`: nel `SKILL.md` c'è `disable-model-invocation: true`, e anche `agents/openai.yaml` imposta `allow_implicit_invocation: false`, quindi l'agente non la usa da solo.
Ha senso a fine di una sessione più difficile del dovuto: l'agente ha cercato a lungo qualcosa, ha fatto un errore che uno strumento avrebbe intercettato, o gli mancava un'informazione. Dopo una sessione liscia c'è poco da imparare. Se vuoi un giudizio sul codice prodotto, serve invece la skill `code-review` dello stesso repository.
### Come lavora
1. **Carica la guida di stile.** Richiama la skill `writing-for-agents` del repository, che spiega come scrivere file di istruzioni per gli agenti.
2. **Legge le fonti primarie della sessione** che indichi, cercando se serve nei log delle sessioni sulla macchina. Se non ne indichi una, usa la sessione corrente.
3. **Cerca candidati di miglioramento** in sette categorie (tabella sotto). Prima di proporre un controllo legge quello che il repository ha già (gli script `lint`/`check` di `package.json`, il workflow di CI): un controllo esistente ma scollegato o rotto è il risultato, non una reinvenzione.
4. **Te li presenta in ordine di gravità.** Propone soltanto: non modifica niente finché non scegli un candidato.
| Categoria | Cosa guarda | Si usa quando |
|---|---|---|
| Navigation | quanto è stato facile trovare i file giusti; dipendenze nascoste; un *navigation pointer* (rimando da un file che l'agente legge già) | la sessione ha impiegato molto a trovare un'informazione |
| Automated checks | lint, tipi, test, controlli sul filesystem; un repository senza alcuna protezione (né pre-commit hook né job di CI con lint/typecheck/test) è già un risultato | l'agente ha sbagliato in un modo che un controllo automatico avrebbe intercettato |
| Coding standards | una nuova regola per l'agente revisore, o chiarirne/toglierne una esistente | il revisore non ha notato un errore |
| Global AGENTS.md | istruzioni da spostare negli standard o in un controllo | `AGENTS.md` è molto lungo, nel repository o a livello globale |
| Tool economy | chiamate costose da snellire; strumenti (CLI, MCP) che consumano troppi token | l'agente ha fatto una chiamata costosa |
| No-ops | righe nei file di istruzioni che non cambiano il comportamento | i file di istruzioni sono grandi e ingombranti |
| Information access | più accesso alle informazioni: log del server di sviluppo scritti su file, accesso in sola lettura a servizi esterni | all'agente mancava un'informazione fondamentale |
### Idee guida (sezione "Reference" del SKILL.md)
- **Standard al revisore, non a chi implementa.** L'agente che implementa ha la maggiore pressione sul contesto (esplora, scrive, corregge); il revisore riceve solo un diff, quindi ha spazio per applicare gli standard.
- **Prima si classifica la violazione.** Una violazione *meccanica* (schema sintattico fisso, API vietata, forma di un import, regola sulla posizione dei file) merita un controllo deterministico: una regola del linter, un pre-commit hook o un job di CI. `CODING_STANDARDS.md` è riservato ai veri giudizi (coerenza tra file, "in linea con lo stile circostante").
- **Dove va cosa.** `CLAUDE.md`/`AGENTS.md` finiscono nel contesto di ogni agente, quindi si usano pochissimo, di solito solo per i navigation pointer. `CODING_STANDARDS.md` si legge in fase di revisione (oltre le 1.000 righe conviene rimandare a una cartella di documenti). I documenti sono riferimenti richiamati dagli altri file. Le skill servono per i documenti la cui descrizione deve stare nel contesto, o per i comandi lanciati dall'utente.
### Da sapere
- **Propone, non esegue.** Non scrive regole né installa hook da sola; non c'è una modalità di prova. Un controllo proposto è codice come un altro: provalo sul repository prima di lasciare che blocchi i merge.
- **Limiti dichiarati nella documentazione:** giudica sulla sola sessione letta, quindi può dare troppo peso a ciò di cui parlava quella sessione, e non verifica i controlli proposti in passato (potare le regole che scattano troppo spesso resta compito tuo). Scarta ogni candidato che non riesci a collegare a un momento preciso della sessione.
- **Non è un sistema di memoria:** non ricorda cosa è successo, cambia l'ambiente perché l'errore non si ripeta.
- **Dipende da `writing-for-agents`,** che vive nello stesso repository (`skills/productivity/writing-for-agents`). Installando solo `retro` quella skill manca; cosa faccia `retro` in quel caso non è documentato.
- **Legge i log delle tue sessioni:** può cercare nei file di sessione sulla macchina, quindi accede a conversazioni che possono contenere dati riservati.
- Nella catena di lavoro del repository è l'ultimo passo: `grill-with-docs → to-spec → to-tickets → implement → code-review → retro`. Non serve eseguire l'intera catena per usarla.
## Installazione
Il README del repository raccomanda **un solo metodo per agente**: installare sia il plugin sia le skill singole darebbe ogni skill due volte. Il plugin e `npx skills add mattpocock/skills` portano tutte le skill del repository; per averne solo alcune, vedi il comando con `--skill` più sotto.
### Claude Code
```bash
claude plugin install mattpocock-skills@claude-plugins-official
```
Il plugin si aggiorna da solo. Poi riavvia la sessione e scrivi `/retro`.
### Codex
```bash
codex plugin marketplace add mattpocock/skills
codex plugin add mattpocock-skills@mattpocock
```
Si aggiorna da solo all'avvio.
### Claude Code e Codex (solo le skill che servono)
```bash
npx skills add mattpocock/skills --skill retro --skill writing-for-agents -g -a claude-code -a codex
```
| Opzione | Significato |
|---|---|
| `--skill retro --skill writing-for-agents` | installa `retro` e la guida di stile che richiama al primo passo |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente |
| `-a <agente>` | agente di destinazione, ripetibile |
| `-y` | salta le domande di conferma |
Con questo metodo gli aggiornamenti sono manuali. Il README consiglia anche di includere `setup-matt-pocock-skills` e di lanciare `/setup-matt-pocock-skills` una volta per repository (chiede quale issue tracker usi, quali etichette applichi ai ticket e dove salvare i documenti); è pensata per le altre skill della raccolta e il README non dice che `retro` ne abbia bisogno.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update retro # aggiornamento (oppure: npx skills@latest update)
npx skills remove retro writing-for-agents # rimozione
```
Per il plugin, la rimozione e l'elenco usano i comandi `plugin` del rispettivo agente (non indicati nel README del repository).
### App desktop di Claude e ChatGPT
Queste app richiedono di caricare la skill come ZIP. Preparalo così:
```bash
git clone --depth 1 https://github.com/mattpocock/skills.git
cd skills/skills && zip -r ~/retro.zip engineering/retro productivity/writing-for-agents
```
Lo ZIP deve contenere cartelle con dentro `SKILL.md`; carica `retro` e `writing-for-agents` come due skill separate (se l'app accetta una sola cartella per ZIP, fai due ZIP, uno per cartella).
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** `retro` serve a rivedere sessioni di codifica e ad agire sull'ambiente di un repository (log delle sessioni, `CLAUDE.md`, CI). Nelle app di chat non ha accesso al tuo repository né ai log, quindi può al più analizzare ciò che le incolli. Il README non documenta l'uso nelle app desktop, e non ho verificato come gestiscano le impostazioni di invocazione manuale del `SKILL.md`.
## Fonti
- [README di mattpocock/skills](https://github.com/mattpocock/skills)
- [SKILL.md di retro](https://github.com/mattpocock/skills/blob/main/skills/engineering/retro/SKILL.md)
- [Documentazione di retro](https://github.com/mattpocock/skills/blob/main/docs/engineering/retro.md)
- [agents/openai.yaml di retro](https://github.com/mattpocock/skills/blob/main/skills/engineering/retro/agents/openai.yaml)
- [retro su skills.sh](https://skills.sh/mattpocock/skills/retro)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+144
View File
@@ -0,0 +1,144 @@
# superpowers
- **Autore:** Jesse Vincent (obra)
- **Repository:** [obra/superpowers](https://github.com/obra/superpowers)
- **Sorgente:** [skills/using-superpowers/SKILL.md](https://github.com/obra/superpowers/blob/main/skills/using-superpowers/SKILL.md) (la skill che fa partire tutte le altre)
- **Pagina su skills.sh:** [obra/superpowers/using-superpowers](https://skills.sh/obra/superpowers/using-superpowers)
- **Diffusione (ottobre 2026):** circa 266.000 installazioni di using-superpowers su skills.sh; il repository ha circa 301.600 stelle su GitHub
- **Controlli di sicurezza su skills.sh:** Socket e Snyk superati; Gen Agent Trust Hub segnala un avviso (la pagina non spiega il motivo)
- **Licenza:** MIT
## A cosa serve
Dà all'agente un metodo di sviluppo software completo, invece di lasciarlo scrivere codice a tentativi. È una raccolta di skill componibili (brainstorming, piani, test, debug, review) più una skill iniziale che obbliga l'agente a usarle. Il flusso di lavoro è obbligatorio, non un suggerimento.
## Cosa fa
### Quando si attiva
Le skill partono da sole. `using-superpowers` va caricata all'inizio di ogni conversazione e impone di controllare le skill prima di qualsiasi risposta o azione, anche prima di una domanda di chiarimento. Poi, per esempio:
- chiedi di costruire qualcosa: parte `brainstorming`;
- segnali un bug: parte `systematic-debugging`;
- chiedi di implementare una funzione: si lavora con `test-driven-development`.
Se l'agente è avviato come subagent per un compito preciso, ignora `using-superpowers`.
### Come lavora
Il flusso di base, secondo il README:
1. **brainstorming:** prima di costruire, chiarisce cosa vuoi e perché, poi ti restituisce ciò che ha capito perché tu lo corregga.
2. **using-git-worktrees:** dopo l'approvazione del design crea uno spazio di lavoro isolato su un nuovo branch e verifica che i test di partenza passino.
3. **writing-plans:** divide il lavoro in task da 2-5 minuti, con percorsi dei file, codice completo e passi di verifica.
4. **subagent-driven-development** o **executing-plans:** esegue il piano, con un subagent per task e una review dopo ciascuno, oppure direttamente con un'unica review finale.
5. **test-driven-development:** impone il ciclo RED-GREEN-REFACTOR.
6. **requesting-code-review:** controlla il lavoro rispetto al piano e segnala i problemi per gravità.
7. **finishing-a-development-branch:** verifica i test, propone le opzioni (merge, PR, tenere, scartare) e pulisce il worktree.
Regole di `using-superpowers`:
- se una skill è pertinente, l'agente la invoca, annuncia che la usa e la segue alla lettera; se ha una checklist, crea un todo per ogni voce;
- le skill di processo (brainstorming, systematic-debugging) hanno la precedenza su quelle di implementazione (come frontend-design): prima si decide l'approccio, poi si esegue;
- una tabella di "red flags" elenca le scuse con cui l'agente tenderebbe a saltare le skill ("è solo una domanda semplice", "conosco già quella skill", "è eccessivo") e le smentisce;
- le tue istruzioni (CLAUDE.md, AGENTS.md, GEMINI.md, richieste dirette) prevalgono sulle skill, e le skill sulle abitudini predefinite dell'agente. Le skill si saltano solo se lo dici esplicitamente.
### Skill incluse
| Gruppo | Skill |
|---|---|
| Testing | test-driven-development |
| Debug | systematic-debugging, verification-before-completion, diagnosing-superpowers |
| Collaborazione | brainstorming, writing-plans, executing-plans, dispatching-parallel-agents, requesting-code-review, receiving-code-review, using-git-worktrees, finishing-a-development-branch, subagent-driven-development |
| Meta | writing-skills, using-superpowers |
L'elenco viene dalla pagina GitHub del repository.
### Filosofia
- test sempre scritti prima del codice;
- metodo sistematico invece di tentativi a caso;
- la semplicità come obiettivo principale;
- prove invece di affermazioni: verificare prima di dichiarare che qualcosa funziona.
### Da sapere
- Non è una skill singola ma una metodologia: va installata come plugin (o come insieme di skill) e funziona al meglio negli agenti che lavorano in locale e sanno lanciare subagent e creare worktree git.
- Il README non indica requisiti tecnici (versioni, dipendenze); chiede solo una delle piattaforme supportate e, per alcune, il riavvio delle sessioni dopo l'installazione.
- Se usi più piattaforme, va installato separatamente su ciascuna.
- Su Muse gli hook richiedono un'approvazione alla prima installazione; su Grok Build CLI il comando di installazione usa `--trust`. In generale un plugin può portare hook e script: controlla la fonte prima di installare.
- L'avviso di Gen Agent Trust Hub su skills.sh non è spiegato: non so a cosa si riferisca.
## Installazione
### Claude Code e Codex
**Claude Code**, dal marketplace ufficiale:
```text
/plugin install superpowers@claude-plugins-official
```
oppure dal marketplace di Superpowers:
```text
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
```
| Comando | Significato |
|---|---|
| `/plugin install superpowers@claude-plugins-official` | installa il plugin dal marketplace ufficiale di Anthropic |
| `/plugin marketplace add obra/superpowers-marketplace` | aggiunge il marketplace dell'autore |
| `/plugin install superpowers@superpowers-marketplace` | installa il plugin da quel marketplace |
**Codex App:** apri **Plugins** nella barra laterale, trova Superpowers nella sezione *Coding*, clicca `+` e segui le istruzioni.
**Codex CLI:** apri `/plugins`, cerca `superpowers` e scegli `Install Plugin`.
Dopo l'installazione riavvia la sessione. Non serve richiamare le skill a mano: `using-superpowers` le attiva da sola quando la richiesta è pertinente.
Gestione: il README dice che gli aggiornamenti dipendono dalla piattaforma e spesso sono automatici, ma non dà comandi per Claude Code e Codex. Per elencare, aggiornare o rimuovere il plugin usa il gestore dei plugin dell'agente (`/plugin` in Claude Code, `/plugins` in Codex); i comandi esatti non li ho verificati.
**Altre installazioni:** su skills.sh il comando per la sola skill iniziale è:
```bash
npx skills add https://github.com/obra/superpowers --skill using-superpowers
```
Installa però solo `using-superpowers`, non le altre skill: per l'intero insieme usa i plugin qui sopra. Il README elenca anche comandi per altri agenti, per esempio `gemini extensions install https://github.com/obra/superpowers` (Gemini CLI), `/add-plugin superpowers` (Cursor), `copilot plugin marketplace add obra/superpowers-marketplace` seguito da `copilot plugin install superpowers@superpowers-marketplace` (GitHub Copilot CLI), `devin plugins install obra/superpowers` (Devin CLI), `pi install git:github.com/obra/superpowers` (Pi). Nel README trovi anche Antigravity, Factory Droid, Grok Build CLI, Kimi Code, OpenCode, Qwen Code, Hermes Agent e Muse.
### App desktop di Claude e ChatGPT
Queste app caricano una skill alla volta come ZIP; il plugin completo non si può installare. Per provare almeno la skill iniziale:
```bash
git clone --depth 1 https://github.com/obra/superpowers.git
cd superpowers/skills && zip -r ~/using-superpowers.zip using-superpowers
```
Lo ZIP deve contenere la cartella `using-superpowers/` con dentro `SKILL.md`. Se vuoi anche le altre, crea uno ZIP per ciascuna (per esempio `brainstorming`) e caricale una per una.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** Superpowers è pensato per agenti che lavorano su un progetto locale, con worktree git, subagent e test da eseguire. Nelle app di chat queste cose mancano: la skill può al massimo guidare la conversazione (brainstorming, piani), ma non il flusso completo. Non ho verificato come reagiscono le app a una skill che rimanda ad altre skill non caricate.
## Fonti
- [README di obra/superpowers](https://github.com/obra/superpowers)
- [SKILL.md di using-superpowers](https://github.com/obra/superpowers/blob/main/skills/using-superpowers/SKILL.md)
- [using-superpowers su skills.sh](https://skills.sh/obra/superpowers/using-superpowers)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)
+157
View File
@@ -0,0 +1,157 @@
# xlsx
- **Autore:** Anthropic
- **Repository:** [anthropics/skills](https://github.com/anthropics/skills), la raccolta di skill di esempio di Anthropic
- **Sorgente:** [skills/xlsx/SKILL.md](https://github.com/anthropics/skills/blob/main/skills/xlsx/SKILL.md), con `LICENSE.txt` e una cartella `scripts/`
- **Pagina su skills.sh:** [anthropics/skills/xlsx](https://skills.sh/anthropics/skills/xlsx)
- **Diffusione (ottobre 2026):** circa 190.400 installazioni (su skills.sh dal 19 gennaio 2026); il repository ha circa 184.900 stelle e 21.900 fork su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub e Snyk superati; Socket segnala un avviso (la pagina non spiega il motivo). La pagina avverte inoltre che `SKILL.md` contiene direttive di shell che possono eseguire comandi di sistema, da controllare prima di installare.
- **Licenza:** proprietaria (termini in `LICENSE.txt`). Il README del repository precisa che le skill per i documenti (`docx`, `pdf`, `pptx`, `xlsx`) sono *source-available*, non open source, e che le skill del repository sono dimostrative: conviene provarle bene prima di affidarsi a loro.
## A cosa serve
Fa creare, modificare, leggere e ripulire fogli di calcolo Excel all'agente, con formule vere (non risultati incollati) e senza errori nei calcoli. Un foglio che l'agente produce da solo si ricalcola quando cambiano i dati, ha una formattazione professionale e viene controllato prima di essere consegnato.
## Cosa fa
### Quando si attiva
Quando un foglio di calcolo è l'ingresso o il risultato principale del lavoro, in formato `.xlsx`, `.xlsm`, `.xltx`, `.csv` o `.tsv`:
- creare una cartella di lavoro nuova;
- modificare un file esistente, aggiungere colonne, calcolare formule, formattare, fare grafici;
- pulire dati disordinati e trasformarli in un foglio ben fatto;
- convertire tra formati tabellari.
Non si attiva quando il risultato è un documento Word, un rapporto HTML, uno script a sé, una pipeline su database o un'integrazione con Google Sheets.
### Come lavora
1. **Sceglie lo strumento:**
- `openpyxl` per creare e modificare file con formule e formattazione;
- `pandas` (`read_excel`, `to_excel`) per importare ed esportare molti dati;
- `markitdown file.xlsx` per una lettura rapida in sola lettura (non mostra le coordinate delle celle).
Per leggere sia le formule sia i valori di un modello servono due caricamenti del file con `load_workbook`. Le librerie sono già installate: la skill dice di non lanciare `pip install` se non fallisce un `import`.
2. **Scrive formule, non risultati:** il foglio deve ricalcolarsi se cambiano gli ingressi.
3. **Ricalcola e controlla.** `openpyxl` salva le formule senza i valori già calcolati, quindi lancia:
```bash
python scripts/recalc.py output.xlsx [secondi_di_attesa]
```
(30 secondi per impostazione predefinita). LibreOffice ricalcola il file e lo script restituisce un JSON con `status`, `total_formulas`, `total_errors` e `error_summary`. Un'uscita senza errori non garantisce un foglio corretto: la skill dice di provare a mano alcune formule.
4. **Consegna** senza errori di formula; se il file ne aveva già, controlla l'originale prima di dare la colpa al proprio lavoro.
### Regole per ogni risultato
- carattere professionale (Arial o Times New Roman), salvo indicazioni diverse;
- nomi dei fogli, intestazioni e formule come li chiedi tu, alla lettera;
- ipotesi e numeri scritti a mano documentati nel file, con la fonte quando possibile;
- se modifica un file esistente: adotta le sue convenzioni, scrive solo nelle celle di ingresso previste e non tocca le formule esistenti.
### Formule: cosa usa e cosa evita
| Tipo | Funzioni |
|---|---|
| Preferite (Excel 2007) | `SUMIFS`, `INDEX`, `MATCH`, `IFERROR`, `SUMPRODUCT` |
| Più recenti, con prefisso `_xlfn.` | `TEXTJOIN`, `CONCAT`, `IFS`, `SWITCH`, `MAXIFS`, `MINIFS` |
| Da evitare | `XLOOKUP`, `XMATCH`, `SORT`, `FILTER`, `UNIQUE`, `SEQUENCE` (ordina e filtra in Python) |
### Trappole di openpyxl che la skill segnala
- `data_only=True` toglie le formule: salvare quel file le sostituisce per sempre con i valori.
- Nelle celle unite si scrive solo in quella in alto a sinistra.
- I file `.xlsm` vanno aperti con `keep_vba=True`, altrimenti perdono le macro.
- I nomi dei fogli con spazi vanno tra apici nei riferimenti tra fogli.
- Salvare di nuovo una cartella che rimanda ad altri file ne toglie i collegamenti: prima copia i valori.
### Convenzioni dei modelli finanziari
Valgono salvo diversa indicazione tua o del file:
| Elemento | Convenzione |
|---|---|
| Colori | blu per gli ingressi scritti a mano, nero per le formule, verde per i collegamenti ad altri fogli, rosso per quelli ad altri file, sfondo giallo per le ipotesi chiave |
| Numeri | formato valuta con le unità nelle intestazioni, zeri come trattino, negativi tra parentesi, percentuali salvate come frazioni, multipli come `0.0x`, anni salvati come testo |
| Struttura | un'ipotesi per cella con etichetta, formule coerenti tra i periodi, divisori protetti dallo zero |
### Da sapere
- **Macro VBA: non le scrive.** La skill non tratta la scrittura né la modifica di codice VBA. Dice soltanto di conservare le macro esistenti aprendo i `.xlsm` con `keep_vba=True`. Per VBA servono altre skill.
- **Grafici e tabelle pivot:** la descrizione dice che copre i grafici, ma il testo non dà indicazioni specifiche su grafici o tabelle pivot.
- **Requisiti:** Python con openpyxl, pandas e markitdown (preinstallati negli ambienti previsti) e LibreOffice (`soffice`), che la skill configura da sola negli ambienti isolati tramite `scripts/office/soffice.py`.
- **Script eseguiti:** `scripts/recalc.py` e `scripts/office/soffice.py`. Non li ho letti uno per uno, e non ho potuto vedere il contenuto della cartella `scripts/` su GitHub.
- **Nessun accesso esterno** dichiarato: lavora sui file locali.
## Installazione
### Claude Code e Codex
```bash
npx skills add anthropics/skills --skill xlsx -g -a codex -a claude-code
```
| Opzione | Significato |
|---|---|
| `--skill xlsx` | installa solo questa skill del repository |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente (`.claude/skills/`, `.agents/skills/`) |
| `-a <agente>` | agente di destinazione, ripetibile (`claude-code`, `codex`, ...) |
| `-y` | salta le domande di conferma |
| `--copy` | copia i file invece di creare collegamenti simbolici |
La pagina di skills.sh indica la forma `npx skills add https://github.com/anthropics/skills --skill xlsx`; la sintassi con `anthropics/skills` è equivalente.
Alternativa solo per Claude Code, dal marketplace di Anthropic (installa tutte le skill per i documenti: `docx`, `pdf`, `pptx`, `xlsx`):
```text
/plugin marketplace add anthropics/skills
/plugin install document-skills@anthropic-agent-skills
```
Dopo l'installazione riavvia la sessione. Claude Code la usa da solo quando la richiesta è pertinente. In Codex la richiami con `$xlsx` o la vedi con `/skills`.
Gestione:
```bash
npx skills list -g # skill installate
npx skills update xlsx # aggiornamento
npx skills remove xlsx # rimozione
```
```text
/plugin uninstall document-skills@anthropic-agent-skills # rimozione del plugin
```
### App desktop di Claude e ChatGPT
Queste app richiedono di caricare la skill come ZIP. Preparalo così:
```bash
git clone --depth 1 https://github.com/anthropics/skills.git
cd skills/skills && zip -r ~/xlsx.zip xlsx
```
Lo ZIP deve contenere la cartella `xlsx/` con dentro `SKILL.md` e la cartella `scripts/`.
**Claude (desktop o web)**
1. Attiva l'esecuzione del codice in **Settings → Capabilities**.
2. Vai in **Customize → Skills → + → Create skill → Upload a skill** e scegli lo ZIP.
3. Attiva l'interruttore della skill.
**ChatGPT (desktop o web)**
1. Vai in **Skills** nella barra laterale, poi **Create → Upload from your computer**, e scegli lo ZIP o la cartella.
2. Attendi l'analisi di sicurezza di ChatGPT.
3. Richiamala con `@` nella chat.
Le skill personali caricate su desktop e web non si sincronizzano: vanno caricate su ciascuna.
> **Limite:** nelle app di chat la skill gira in un ambiente isolato con esecuzione del codice. Funziona solo se lì sono disponibili openpyxl, pandas e LibreOffice (non l'ho verificato), e legge solo i file che alleghi alla conversazione. Il README del repository dice che le skill di esempio sono già disponibili sui piani a pagamento di Claude.ai, ma non specifica se `xlsx` sia tra queste.
## Fonti
- [README di anthropics/skills](https://github.com/anthropics/skills)
- [SKILL.md di xlsx](https://github.com/anthropics/skills/blob/main/skills/xlsx/SKILL.md)
- [Cartella skills/xlsx](https://github.com/anthropics/skills/tree/main/skills/xlsx)
- [xlsx su skills.sh](https://skills.sh/anthropics/skills/xlsx)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
- [Skills in ChatGPT – OpenAI Help Center](https://help.openai.com/en/articles/20001066-skills-in-chatgpt)