Compare commits

..
9 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
davideandClaude Sonnet 5.5 c09f4b1f7e Aggiorna le schede con le novità di ottobre 2026
Ponytail 5 (regole, review, audit, installazione), graphify v0.9.91,
catalogo di claude-plugins-official e numeri aggiornati delle altre schede.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 09:26:03 +02:00
davideandClaude Sonnet 5.5 d9585e303a Aggiungi la scheda di obsidian-wiki e aggiorna l'installazione di obsidian-skills
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-16 09:23:21 +02:00
20 changed files with 2020 additions and 96 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
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
- `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.
- `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.
@@ -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.
### 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
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
+81 -6
View File
@@ -2,14 +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.
## 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 |
|---|---|
| [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. |
| [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. |
### 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)
+4 -4
View File
@@ -4,7 +4,7 @@
- **Repository:** [anthropics/claude-plugins-official](https://github.com/anthropics/claude-plugins-official) (licenza Apache-2.0; ogni plugin ha la sua licenza)
- **Catalogo online:** [claude.com/plugins](https://claude.com/plugins)
- **Documentazione:** [Discover and install prebuilt plugins](https://code.claude.com/docs/en/discover-plugins)
- **Diffusione (settembre 2026):** circa 36.700 stelle e 4.100 fork su GitHub
- **Diffusione (ottobre 2026):** circa 39.500 stelle e 4.400 fork su GitHub
> Non è una singola skill ma il **marketplace ufficiale di plugin per Claude Code**: un catalogo da cui installare plugin. Ogni plugin può contenere skill, agenti, comandi, hook, server MCP e server LSP.
@@ -29,10 +29,10 @@ Le skill di un plugin prendono come prefisso il nome del plugin: per esempio `co
Il repository ha due cartelle:
- `plugins/`: 39 plugin sviluppati e mantenuti da Anthropic;
- `plugins/`: 40 plugin sviluppati e mantenuti da Anthropic;
- `external_plugins/`: 14 plugin di partner e della comunità, approvati dopo una revisione di qualità e sicurezza.
Il catalogo può indicare anche plugin ospitati in altri repository: per esempio `atlassian`, `figma`, `notion` e `vercel` sono nella documentazione ma non in queste cartelle.
Il catalogo (`.claude-plugin/marketplace.json`) elenca in tutto 315 plugin (ottobre 2026): 53 puntano alle due cartelle (`math-proof` è nella cartella ma non ancora nel catalogo), gli altri 262 sono ospitati in altri repository. Per esempio `atlassian`, `figma`, `notion` e `vercel` sono nella documentazione ma non in queste cartelle.
Principali categorie, secondo la documentazione ufficiale:
@@ -44,7 +44,7 @@ Principali categorie, secondo la documentazione ufficiale:
| Flussi di sviluppo | `commit-commands`, `pr-review-toolkit`, `agent-sdk-dev`, `plugin-dev` | commit, push e PR; agenti per revisionare le PR; strumenti per Claude Agent SDK; strumenti per creare plugin |
| Stili di risposta | `explanatory-output-style`, `learning-output-style` | spiegazioni didattiche sulle scelte di implementazione; modalità di apprendimento interattiva |
Altri plugin di Anthropic presenti nel repository, non descritti nella documentazione citata: `claude-code-setup`, `claude-md-management`, `claude-security`, `code-modernization`, `code-review`, `code-simplifier`, `cwc-makers`, `example-plugin`, `feature-dev`, `frontend-design`, `hookify`, `math-olympiad`, `mcp-server-dev`, `mcp-tunnels`, `playground`, `project-artifact`, `ralph-loop`, `receipts`, `session-report`, `skill-creator`.
Altri plugin di Anthropic presenti nel repository, non descritti nella documentazione citata: `claude-code-setup`, `claude-md-management`, `claude-security`, `code-modernization`, `code-review`, `code-simplifier`, `cwc-makers`, `example-plugin`, `feature-dev`, `frontend-design`, `hookify`, `math-olympiad`, `math-proof`, `mcp-server-dev`, `mcp-tunnels`, `playground`, `project-artifact`, `ralph-loop`, `receipts`, `session-report`, `skill-creator`.
Plugin esterni nel repository: `asana`, `context7`, `discord`, `fakechat`, `firebase`, `github`, `gitlab`, `imessage`, `laravel-boost`, `linear`, `playwright`, `serena`, `telegram`, `terraform`.
+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)
+1 -1
View File
@@ -4,7 +4,7 @@
- **Repository:** [vercel-labs/skills](https://github.com/vercel-labs/skills)
- **Sorgente:** [skills/find-skills/SKILL.md](https://github.com/vercel-labs/skills/blob/main/skills/find-skills/SKILL.md)
- **Pagina su skills.sh:** [vercel-labs/skills/find-skills](https://skills.sh/vercel-labs/skills/find-skills)
- **Diffusione (settembre 2026):** circa 3,5 milioni di installazioni; il repository ha circa 32.300 stelle su GitHub
- **Diffusione (ottobre 2026):** circa 3,9 milioni di installazioni; il repository ha circa 35.200 stelle 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)
## A cosa serve
+6 -4
View File
@@ -5,9 +5,9 @@
- **Sorgente:** [graphify/skill.md](https://github.com/Graphify-Labs/graphify/blob/v8/graphify/skill.md) (versione per Claude Code; le versioni per gli altri agenti sono in `graphify/skill-<agente>.md`, le guide di dettaglio in `graphify/skills/<agente>/references/`)
- **Pacchetto Python:** `graphifyy` (con due y); il comando si chiama `graphify`
- **Pagina su skills.sh:** [graphify-labs/graphify/graphify](https://skills.sh/graphify-labs/graphify/graphify)
- **Versione:** v0.9.66 (22 settembre 2026)
- **Diffusione (settembre 2026):** circa 7.900 installazioni tramite `npx skills` (su skills.sh dal 7 aprile 2026); il repository ha circa 120.700 stelle e 11.700 fork su GitHub. La maggior parte degli utenti installa tramite il pacchetto Python, che skills.sh non conta.
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub e Snyk superati; Socket segnala un avviso (la pagina non spiega il motivo)
- **Versione:** v0.9.91 (14 ottobre 2026)
- **Diffusione (ottobre 2026):** circa 9.700 installazioni tramite `npx skills` (su skills.sh dal 7 aprile 2026); il repository ha circa 127.000 stelle e 12.300 fork su GitHub. La maggior parte degli utenti installa tramite il pacchetto Python, che skills.sh non conta.
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati (a settembre Socket segnalava un avviso)
> Esistono siti di terzi con nomi simili. Questa scheda si basa solo sul repository ufficiale Graphify-Labs/graphify.
@@ -75,7 +75,7 @@ graphify extract ./src --code-only # solo codice, nessuna chiamata ester
### Supporto
- **Codice:** circa 37 linguaggi, tra cui Python, TypeScript, JavaScript, Go, Rust, Java, C/C++, C#, Ruby, PHP, Swift e Kotlin, più Terraform e i file di configurazione dei pacchetti.
- **Codice:** circa 40 linguaggi, tra cui Python, TypeScript, JavaScript, Go, Rust, Java, C/C++, C#, Ruby, PHP, Swift e Kotlin, più Terraform e i file di configurazione dei pacchetti.
- **Documenti:** Markdown, reStructuredText, HTML, YAML, testo, PDF, DOCX e XLSX.
- **Media:** immagini, audio e video, e anche URL di YouTube (richiede l'extra `video`).
@@ -86,6 +86,8 @@ graphify extract ./src --code-only # solo codice, nessuna chiamata ester
- **Chiavi API:** dentro l'agente la skill usa solo Gemini o l'agente stesso. Il comando da terminale `graphify extract --backend <fornitore>`, pensato per l'automazione, secondo il README supporta anche Anthropic, OpenAI, DeepSeek, Kimi, Bedrock e Ollama in locale.
- **Costi:** un corpus di solo codice non costa token per la costruzione. Con documenti e immagini senza chiave Gemini, l'estrazione consuma token della sessione dell'agente.
- **Modifiche al sistema e al progetto:** la skill installa pacchetti Python da sola e crea `graphify-out/` nel progetto. L'integrazione "sempre attiva" modifica `CLAUDE.md` o `AGENTS.md` e aggiunge hook che spingono l'agente a interrogare il grafo prima di leggere o cercare nei file (vedi sotto).
- **File nel progetto:** se la cartella è dentro un repository git, la skill avvisa che `graphify-out/` compare in `git status`, a meno che sia già ignorata.
- **Graphify Cloud:** il README promuove anche un servizio a pagamento con prova gratuita di 14 giorni (grafo sempre aggiornato su più repository, collegamenti con Sentry e Jira). Non serve per usare la skill, che resta locale.
- **Grafo da aggiornare:** il grafo è una fotografia del codice. Va aggiornato con `--update`, `graphify update`, `--watch` o l'hook sui commit.
## Installazione
+36 -32
View File
@@ -4,7 +4,7 @@
- **Repository:** [kepano/obsidian-skills](https://github.com/kepano/obsidian-skills) (licenza MIT)
- **Sorgenti:** cartella [skills/](https://github.com/kepano/obsidian-skills/tree/main/skills), un `SKILL.md` per skill
- **Pagina su skills.sh:** [kepano/obsidian-skills](https://skills.sh/kepano/obsidian-skills)
- **Diffusione (settembre 2026):** circa 378.700 installazioni complessive tramite `npx skills`; il repository ha circa 48.800 stelle e 3.500 fork su GitHub
- **Diffusione (ottobre 2026):** circa 396.200 installazioni complessive tramite `npx skills`; il repository ha circa 49.600 stelle e 3.500 fork su GitHub
- **Controlli di sicurezza su skills.sh:** `obsidian-markdown` supera Gen Agent Trust Hub, Socket e Snyk; `obsidian-cli` supera Socket e Snyk, mentre Gen Agent Trust Hub segnala un avviso (la pagina non spiega il motivo). Le altre skill non le ho controllate.
> Non è una sola skill ma una **raccolta di sei skill**. Con lo stesso nome esistono altri repository non ufficiali (per esempio [tpitsunov/obsidian-skills](https://github.com/tpitsunov/obsidian-skills) e [adriangrantdotorg/Obsidian-Skills](https://github.com/adriangrantdotorg/Obsidian-SKILLS)): questa scheda riguarda solo quello di kepano.
@@ -19,12 +19,12 @@ Insegna all'agente a lavorare con [Obsidian](https://obsidian.md): scrivere note
| Skill | Installazioni | Cosa fa |
|---|---|---|
| `obsidian-markdown` | ~86.900 | scrive e modifica note nel Markdown di Obsidian |
| `obsidian-cli` | ~76.100 | comanda Obsidian dal terminale, anche per sviluppare plugin e temi |
| `obsidian-bases` | ~74.900 | crea e modifica file `.base` (viste a database sulle note) |
| `json-canvas` | ~69.900 | crea e modifica file `.canvas` (lavagne con nodi e collegamenti) |
| `defuddle` | ~69.600 | estrae Markdown pulito dalle pagine web |
| `knap` | ~1.300 | genera documenti Markdown da modelli e dati JSON o CSV |
| `obsidian-markdown` | ~90.500 | scrive e modifica note nel Markdown di Obsidian |
| `obsidian-cli` | ~79.000 | comanda Obsidian dal terminale, anche per sviluppare plugin e temi |
| `obsidian-bases` | ~77.900 | crea e modifica file `.base` (viste a database sulle note) |
| `json-canvas` | ~72.700 | crea e modifica file `.canvas` (lavagne con nodi e collegamenti) |
| `defuddle` | ~72.600 | estrae Markdown pulito dalle pagine web |
| `knap` | ~3.700 | genera documenti Markdown da modelli e dati JSON o CSV |
### obsidian-markdown
@@ -134,26 +134,17 @@ defuddle parse https://example.com --md --json | knap render modello.md --data -
## Installazione
### Claude Code come plugin
### Da terminale con `npx skills` (Claude Code, Codex, OpenCode)
Nella sessione di Claude Code:
```
/plugin marketplace add kepano/obsidian-skills
/plugin install obsidian@obsidian-skills
```
Il plugin si chiama `obsidian` e comprende tutte le skill. Gestione con `/plugin marketplace update obsidian-skills` e `/plugin uninstall obsidian@obsidian-skills`.
### Claude Code e Codex con `npx skills`
Tutte le skill:
Serve Node.js. Tutte le skill, per Claude Code e Codex, a livello globale:
```bash
npx skills add kepano/obsidian-skills -g -a claude-code -a codex
npx skills add https://github.com/kepano/obsidian-skills -g -a claude-code -a codex
```
Solo alcune, ripetendo `--skill`:
Il README mostra prima la forma SSH (`npx skills add git@github.com:kepano/obsidian-skills.git`), che richiede una chiave configurata su GitHub; la forma HTTPS qui sopra non ne ha bisogno.
Solo alcune skill, ripetendo `--skill`:
```bash
npx skills add kepano/obsidian-skills --skill obsidian-markdown --skill obsidian-bases -g -a claude-code -a codex
@@ -162,25 +153,38 @@ npx skills add kepano/obsidian-skills --skill obsidian-markdown --skill obsidian
| Opzione | Significato |
|---|---|
| `--skill <nome>` | installa solo la skill indicata; senza, lo strumento propone tutte e sei |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente, per esempio dentro il vault |
| `-g` | globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente, per esempio dentro il vault |
| `-a <agente>` | agente di destinazione, ripetibile |
| `-y` | salta le domande di conferma |
Gestione con `npx skills list -g`, `npx skills update` e `npx skills remove <nome>`.
Gestione: `npx skills list -g`, `npx skills update`, `npx skills remove <nome>`. Dopo l'installazione riavvia la sessione; in Codex le skill si richiamano con `$<nome>`, per esempio `$obsidian-markdown`.
### Installazione manuale
Come indicato nel README:
- **Claude Code:** copia il contenuto del repository nella cartella `.claude` alla radice del vault.
- **Codex:** copia la cartella `skills/` in `~/.codex/skills`.
### Da terminale con `git clone` (installazione manuale)
```bash
git clone --depth 1 https://github.com/kepano/obsidian-skills.git
cp -r obsidian-skills/skills/* ~/.codex/skills/
```
Dopo l'installazione riavvia la sessione. In Codex puoi richiamare le skill con `$<nome>`, per esempio `$obsidian-markdown`.
- **Codex:** `mkdir -p ~/.codex/skills && cp -r obsidian-skills/skills/* ~/.codex/skills/`
- **Claude Code:** copia il contenuto del repository in una cartella `.claude` alla radice del vault (o della cartella in cui usi Claude Code).
- **OpenCode:** clona l'intero repository, non solo `skills/`, in `~/.opencode/skills/obsidian-skills`, così che il percorso sia `~/.opencode/skills/obsidian-skills/skills/<skill>/SKILL.md`:
```bash
git clone https://github.com/kepano/obsidian-skills.git ~/.opencode/skills/obsidian-skills
```
OpenCode le trova da solo, senza toccare `opencode.json`; riavvialo per attivarle.
### Claude Code come plugin
Dentro una sessione di Claude Code:
```
/plugin marketplace add kepano/obsidian-skills
/plugin install obsidian@obsidian-skills
```
Il plugin si chiama `obsidian` e comprende tutte le skill. Aggiornamento: `/plugin marketplace update obsidian-skills`; rimozione: `/plugin uninstall obsidian@obsidian-skills`.
### App desktop di Claude e ChatGPT
+203
View File
@@ -0,0 +1,203 @@
# obsidian-wiki
- **Autore:** Ar9av
- **Repository:** [Ar9av/obsidian-wiki](https://github.com/Ar9av/obsidian-wiki) (licenza MIT)
- **Sorgenti:** cartella [.skills/](https://github.com/Ar9av/obsidian-wiki/tree/main/.skills), un `SKILL.md` per skill; l'elenco commentato è in [docs/skills.md](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/skills.md)
- **Pagina su skills.sh:** [Ar9av/obsidian-wiki](https://skills.sh/Ar9av/obsidian-wiki)
- **Diffusione (ottobre 2026):** circa 97.200 installazioni complessive tramite `npx skills` su 44 skill; il repository ha circa 3.600 stelle e 361 fork su GitHub
- **Controlli di sicurezza su skills.sh:** per `wiki-ingest`, Gen Agent Trust Hub e Snyk segnalano un avviso (la pagina non spiega il motivo) e Socket è elencato senza esito. La pagina riassuntiva del repository non riporta audit e la sua sezione `/audits` dà errore 404. Le altre skill non le ho controllate.
> Non è una sola skill ma un **framework di 39 skill** (skills.sh ne elenca 44, tra cui `data-ingest`, `ingest-url`, `obsidian-wiki-ingest` e `wiki-quick-chat-capture`, che non compaiono nella cartella `.skills/` né nella documentazione; non ho verificato perché), più una CLI e un'API Python facoltative. Le skill sono pensate per funzionare insieme, attorno a un'unica cartella di note.
## A cosa serve
Dà all'agente una memoria a lungo termine fatta di note Markdown che sono tue: un "secondo cervello" in formato vault di [Obsidian](https://obsidian.md). Risolve il problema di rifare da zero un lavoro già fatto perché la risposta era finita in una chat dimenticata. Segue l'idea del [gist LLM Wiki di Karpathy](https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f): la conoscenza si compila una volta e si mantiene aggiornata, invece di rifare ogni volta la stessa domanda a un LLM o una ricerca RAG.
## Cosa fa
### Quando si attiva
Le skill partono quando la richiesta corrisponde alla loro descrizione, oppure con un comando `/nome-skill` (nei client che li supportano, come Claude Code):
- vuoi inizializzare il sistema ("set up my wiki");
- vuoi "dare in pasto" all'agente documenti, PDF, esportazioni di chat, trascrizioni, immagini o URL;
- vuoi salvare la conversazione corrente o la conoscenza del progetto in cui stai lavorando;
- chiedi che cosa sai già su un argomento, o vuoi un riepilogo di quanto hai imparato in un periodo;
- vuoi ritrovare una vecchia sessione con l'agente o recuperare quanto emerso nelle sessioni passate;
- vuoi tenere in ordine il vault (link rotti, duplicati, tag incoerenti).
### Come lavora
1. **Imposta il vault.** `wiki-setup` chiede dove creare il vault e dove sono i documenti sorgente, poi crea cartelle, `index.md`, `log.md`, `hot.md`, il manifest `.manifest.json` e la configurazione di Obsidian. Con la CLI Python lo stesso risultato si ottiene con `obsidian-wiki setup`.
2. **Distilla le fonti** (`wiki-ingest`). Non riassume: integra la conoscenza nelle pagine già presenti, segnala le contraddizioni e aggiorna i collegamenti. Tre modalità: *append* (predefinita, tratta solo fonti nuove o modificate, verificate con un hash tramite `obsidian-wiki cache-check`), *full* (rifà tutto) e *raw* (promuove le bozze messe in `_raw/` e le archivia in `_raw/_archived/`). Il testo delle fonti è trattato come dato non fidato: la skill dice di non eseguire comandi trovati nei documenti.
3. **Sincronizza i progetti** (`wiki-update`). Dalla cartella di un repository confronta lo stato con l'ultimo commit sincronizzato, ricava che cosa varrebbe la pena ricordare tra tre mesi e lo scrive nel vault. Funziona da qualsiasi progetto.
4. **Risponde alle domande** (`wiki-query`). È in sola lettura: scrive soltanto una riga in `log.md`. Parte da `hot.md` e `index.md`, poi legge le sezioni e solo in ultimo le pagine intere, così il costo resta quasi costante al crescere del vault. La risposta cita le pagine con `[[wikilink]]`, elenca le lacune e dichiara quanti candidati ha visto e letto.
5. **Mantiene il vault in ordine** con `wiki-lint`, `wiki-dedup`, `cross-linker`, `tag-taxonomy`, `wiki-synthesize` e `wiki-status`.
Esempi dal README:
```text
/wiki-ingest ~/research
/wiki-update # distilla il repository in cui ti trovi
/wiki-capture # salva questa conversazione
/wiki-history-ingest claude # estrae il sapere dalle tue vecchie sessioni con Claude
/wiki-query what do I know about rate limiting?
/wiki-narrate MCP security # briefing con citazioni su un argomento
/wiki-digest week # che cosa ho imparato questa settimana?
```
### Le skill per gruppo
| Gruppo | Skill |
|---|---|
| Impostazione | `wiki-setup`, `wiki-switch` (più vault con nome), `daily-update` |
| Alimentare il vault | `wiki-ingest`, `wiki-capture` (con `--quick` mette in `_raw/` in meno di 60 secondi), `wiki-update`, `wiki-research` (ricerca web autonoma), `wiki-history-ingest` e le sei skill `claude-`, `codex-`, `copilot-`, `hermes-`, `openclaw-`, `pi-history-ingest`, `wiki-agent` |
| Interrogarlo | `wiki-query`, `wiki-narrate`, `wiki-digest`, `wiki-context-pack` (porzione di contesto limitata in token per un altro agente), `memory-bridge` (che cosa ha scritto ogni strumento) |
| Ritrovare le sessioni | `session-brain`, `session-search` |
| Manutenzione | `wiki-status`, `wiki-lint`, `wiki-dedup`, `cross-linker`, `tag-taxonomy`, `wiki-synthesize`, `wiki-stage-commit`, `wiki-rebuild` |
| Vedere e spostare | `graph-colorize`, `wiki-dashboard`, `wiki-export`, `wiki-import`, `obsidian-layout-adjustment` |
| Estendere | `llm-wiki` (il riferimento del metodo), `skill-creator`, `vault-skill-factory`, `impl-validator`, `code-understand` |
Le due skill sulle sessioni non toccano il vault: scrivono un indice a parte in `~/.claude/session-brain/`. Regola pratica del progetto: `wiki-history-ingest` per conservare la conoscenza come pagine permanenti, `session-brain` per ritrovare la sessione in cui è successo qualcosa.
### Come tiene la conoscenza affidabile
- Ogni affermazione è marcata come estratta dalla fonte, `^[inferred]` oppure `^[ambiguous]`; `wiki-lint` segnala le pagine che scivolano nella speculazione.
- Un manifest registra ogni fonte già letta, così la seconda esecuzione tratta solo la differenza.
- `index.md`, `log.md`, `hot.md`, il profilo del proprietario e l'indice dei todo (sotto `_meta/`) passano da un unico writer con blocco, per evitare che agenti in parallelo si sovrascrivano.
- Con `WIKI_STAGED_WRITES=true` le pagine nuove finiscono prima in `_staging/` e le promuovi tu con `/wiki-stage-commit`.
- Più vault: `@nome` davanti alla richiesta la indirizza a un vault con nome (`@work update wiki`) senza cambiare quello predefinito.
### Parti facoltative
- **CLI Python** `obsidian-wiki`: `setup`, `doctor`, `info`, `hooks status|install|uninstall`, `cache-check`, `cache-update`, `sessions-build`, `sessions-query`, `sessions-show`, `sessions-clusters` e altri (elenco completo nella [guida alla CLI](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/cli.md), che ho letto solo in parte).
- **API Python:** `from obsidian_wiki import Memory`, con `remember`, `add`, `search`, `recap`. Dice di non richiedere chiavi API, modello di embedding né rete.
- **Esportazione del grafo** in `graph.json`, GraphML, Neo4j Cypher, Postgres SQL, `graph.html` interattivo o pacchetto OKF.
- **Estensione per il browser** e **servizio Docker** raggiungibile via HTTP/MCP (`obsidian-wiki serve`, ascolta solo in locale per impostazione predefinita). Li ho visti solo nell'indice della documentazione, non ne ho letto le guide.
- **Ricerca semantica QMD** e **sincronizzazione su GitHub**, da attivare nella configurazione.
### Risultati dichiarati
Il README riporta un confronto su un vault reale di 38 pagine con Claude Sonnet: 81 s contro 19 s per rispondere e 44% contro 83% di risposte corrette, a costo API invariato. Il campione è minuscolo (4 domande, 2 condizioni, 2 ripetizioni) e gli autori lo definiscono indicativo; in una delle prove "con il tool" il modello ha ignorato la CLI e ha sbagliato. Il confronto con altri strumenti nel README è una valutazione del progetto stesso.
### Da sapere
- **Hook di sessione:** `obsidian-wiki setup` registra due hook di Claude Code, uno che all'avvio inserisce nel contesto la memoria del vault e uno a fine sessione che chiede di eseguire `/wiki-capture --quick` se hai modificato file o lanciato almeno 4 comandi. Si salta con `--no-hooks`, si rimuove con `obsidian-wiki hooks uninstall`, e `WIKI_STOP_CAPTURE=false` lo disattiva per una singola sessione. Il plugin di Claude Code non li installa.
- **Cronologia delle sessioni:** le skill `*-history-ingest` e `session-brain` leggono le sessioni passate (`~/.claude`, `~/.codex`, `~/.copilot`, ecc.), che possono contenere segreti o dati sensibili. Anche `wiki-update` legge README, sorgenti, log di git e file `.claude/` del progetto.
- **Scritture fuori dal vault:** `setup` crea collegamenti simbolici delle skill nelle cartelle di tutti gli agenti rilevati (`~/.claude`, `~/.codex`, `~/.gemini`, ecc.) e file di regole sempre attive nel progetto (`CLAUDE.md`, `AGENTS.md`, `GEMINI.md`...). Scrive anche la configurazione in `~/.config/obsidian-wiki/config` e un profilo di scrittura `WRITING.md`.
- **Installazione dell'hook da parte dell'agente:** `wiki-setup` può scaricare con `curl` lo script `wiki-stop-capture.sh` dal repository e aggiungerlo a `~/.claude/settings.json`; chiede conferma prima ("Want to auto-capture findings at session end?").
- **Setup guidato dall'agente:** dando all'agente solo l'URL del repository, esegue lui i comandi indicati nelle istruzioni. Conviene leggerle prima.
- **Uscita dei dati:** il README dice che nulla lascia il computer. Fanno eccezione le funzioni che attivi tu: sincronizzazione GitHub, servizio HTTP/MCP e estensione browser, che può anche compilare form web con dati del vault.
- **Prompt injection:** le skill di ingest dichiarano le fonti dati non fidati, ma la politica di sicurezza del progetto riconosce l'ingestione di contenuti non controllati come il punto di rischio principale (scritture fuori dal vault, segreti nel vault o in `log.md`, istruzioni nascoste nei documenti). Il progetto non considera una vulnerabilità un agente che fa ciò che gli hai permesso di fare.
- **Requisiti:** Python per la CLI e l'API (versione non indicata nei documenti che ho letto). Obsidian è facoltativo, serve per grafo e navigazione. Docker solo per il servizio.
- **Maturità:** l'autore lo definisce "early".
## Installazione
### 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`.
**Plugin di Claude Code** (solo Claude Code), nella sessione:
```text
/plugin marketplace add Ar9av/obsidian-wiki
/plugin install obsidian-wiki@obsidian-wiki
```
I comandi hanno il prefisso del plugin, per esempio `/obsidian-wiki:wiki-ingest`.
**`npx skills`** (Claude Code e Codex), serve Node.js:
```bash
npx skills add Ar9av/obsidian-wiki -g -a claude-code -a codex
```
| Opzione | Significato |
|---|---|
| `--skill <nome>` | installa solo la skill indicata (ripetibile); senza, propone tutte |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente |
| `-a <agente>` | agente di destinazione, ripetibile |
| `-y` | salta le domande di conferma |
Dopo l'installazione riavvia la sessione; in Codex le skill si richiamano con `$nome` (per esempio `$wiki-query`) e si vedono con `/skills`.
Limiti di questi due metodi, uguali per entrambi:
- 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`;
- 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;
- il progetto dichiara deprecata la via `npx skills`, perché non scrive la configurazione globale né collega le skill agli altri agenti.
Gestione:
```text
/plugin marketplace update obsidian-wiki # aggiornamento del plugin
/plugin uninstall obsidian-wiki@obsidian-wiki # rimozione del plugin
```
```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
Il README non documenta l'uso nelle app desktop. Ogni skill va caricata come ZIP separato, con la cartella della skill che contiene `SKILL.md`:
```bash
git clone --depth 1 https://github.com/Ar9av/obsidian-wiki.git
cd obsidian-wiki/.skills && zip -r ~/wiki-query.zip wiki-query
```
**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 usarla. Le skill leggono e scrivono un vault sul tuo disco, usano la CLI `obsidian-wiki`, il file di configurazione in `~/.config/obsidian-wiki/` e gli hook, e le app di chat lavorano in un ambiente isolato senza accesso a queste cose. Serve un agente che giri in locale, come Claude Code o Codex.
## Fonti
- [README di Ar9av/obsidian-wiki](https://github.com/Ar9av/obsidian-wiki)
- [docs/installation.md](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/installation.md)
- [docs/skills.md](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/skills.md)
- [docs/session-brain.md](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/session-brain.md)
- [docs/cli.md](https://github.com/Ar9av/obsidian-wiki/blob/main/docs/cli.md)
- [SECURITY.md](https://github.com/Ar9av/obsidian-wiki/blob/main/SECURITY.md)
- [SKILL.md di wiki-setup](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/wiki-setup/SKILL.md)
- [SKILL.md di wiki-ingest](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/wiki-ingest/SKILL.md)
- [SKILL.md di wiki-update](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/wiki-update/SKILL.md)
- [SKILL.md di wiki-query](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/wiki-query/SKILL.md)
- [SKILL.md di wiki-history-ingest](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/wiki-history-ingest/SKILL.md)
- [SKILL.md di llm-wiki](https://github.com/Ar9av/obsidian-wiki/blob/main/.skills/llm-wiki/SKILL.md) (letto solo in parte)
- [obsidian-wiki su skills.sh](https://skills.sh/Ar9av/obsidian-wiki)
- [wiki-ingest su skills.sh](https://skills.sh/Ar9av/obsidian-wiki/wiki-ingest)
- [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)
+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)
+49 -45
View File
@@ -4,96 +4,96 @@
- **Repository:** [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail) (licenza MIT)
- **Sorgente:** [skills/ponytail/SKILL.md](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md)
- **Pagina su skills.sh:** [dietrichgebert/ponytail/ponytail](https://skills.sh/dietrichgebert/ponytail/ponytail)
- **Diffusione (settembre 2026):** circa 63.600 installazioni tramite `npx skills` (su skills.sh dal 12 giugno 2026); il repository ha circa 144.800 stelle e 7.800 fork su GitHub
- **Diffusione (ottobre 2026):** circa 92.300 installazioni tramite `npx skills` (su skills.sh dal 12 giugno 2026); il repository ha circa 164.600 stelle e 8.900 fork su GitHub. Ultima versione rilevata: 5.2.0 (13 ottobre 2026)
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati
## A cosa serve
Fa scrivere all'agente il codice più semplice e breve che funziona, evitando soluzioni sovraingegnerizzate. L'idea è far ragionare l'agente come "lo sviluppatore senior più pigro della stanza": il codice migliore è quello che non scrivi.
Fa scrivere all'agente la modifica più piccola che risolve davvero il compito, evitando soluzioni sovraingegnerizzate. L'idea è far ragionare l'agente come "lo sviluppatore senior più pigro della stanza": il codice migliore è quello che non scrivi. Pigro sulla soluzione, mai sulla modifica: deve comunque completare tutto ciò che il compito richiede.
## Cosa fa
### Quando si attiva
Quando scrivi "ponytail", "be lazy", "lazy mode", "simplest solution", "minimal solution", "yagni", "do less" o "shortest path", oppure quando ti lamenti di codice sovraingegnerizzato, gonfio, pieno di boilerplate o di dipendenze inutili.
Su qualsiasi compito di programmazione (scrivere, correggere, rifattorizzare, rivedere, scegliere dipendenze) e quando scrivi "ponytail", "be lazy", "simplest solution", "yagni" o ti lamenti di codice sovraingegnerizzato o gonfio.
Una volta attiva resta accesa in ogni risposta, finché non scrivi "stop ponytail", "normal mode" o `/ponytail off`.
Una volta attiva resta accesa per tutta la sessione, finché non scrivi "stop ponytail" o "normal mode" (o `/ponytail off`).
### Come lavora
Prima di scrivere codice, l'agente sale una "scala" di sette gradini e si ferma al primo che risolve il problema:
1. **Capisce prima di scrivere.** Legge il compito e il codice coinvolto, elenca tutto ciò che la modifica deve toccare (chiamanti, test, fixture, configurazione, esportazioni) e controlla che cosa potrebbe rompere per gli utenti. Questo è l'ambito; le funzionalità in più no.
2. **Sale una "scala"** e si ferma al primo gradino che funziona del tutto:
1. Serve davvero? Funzionalità, opzioni e flessibilità non richieste si saltano e si nominano in una riga. A una richiesta vaga ("costruiscimi X") risponde con la versione minima che fa il lavoro principale.
2. Esiste già nel codice del progetto? Lo riusa come fa il codice circostante.
3. Lo fanno la libreria standard o la piattaforma? Le usa, a meno che il progetto abbia un componente suo.
4. Lo fa una dipendenza già installata? La usa; non ne aggiunge una per poche righe.
5. Si può fare in una riga leggibile a colpo d'occhio?
6. Altrimenti, il minimo codice che funziona.
3. **Lascia un controllo.** La logica nuova non banale (un ramo, un ciclo, un parser, soldi o sicurezza, uno script nuovo) esce con un piccolo test o un controllo basato su `assert`. Le modifiche banali non ne hanno bisogno.
4. **Chiude con uno o due righe:** che cosa ha saltato o non ha verificato, e ogni rischio da conoscere.
1. Serve davvero? (YAGNI)
2. Esiste già nel codice del progetto?
3. Lo fa già la libreria standard?
4. Lo offre già la piattaforma (browser, sistema operativo, framework)?
5. Lo fa una dipendenza già installata?
6. Si può fare in una riga?
7. Solo allora scrive il minimo indispensabile.
Altre regole: niente astrazioni, wrapper, opzioni o codice "per il futuro" non richiesti; meglio cancellare che aggiungere; un commento solo per il perché che il codice non mostra. Nella correzione di un bug cerca prima tutti i chiamanti della funzione e corregge la causa una volta sola nel codice condiviso. Il codice spostato o unito conserva validazione e gestione degli errori. Una scorciatoia con un limite noto riceve un commento nella forma `shortcut: <il limite>, <quando passare a una soluzione migliore>`.
Altre regole:
**Cosa non taglia mai:** validazione ai confini di fiducia, gestione degli errori che evita perdite di dati, sicurezza, accessibilità, la calibrazione che richiede l'hardware reale e tutto ciò che hai chiesto esplicitamente.
- niente astrazioni "per il futuro" né boilerplate;
- meglio cancellare che aggiungere, meglio noioso che ingegnoso;
- meno file possibile e modifica più corta possibile;
- correggere la causa, non il sintomo;
- le scorciatoie volute vanno segnate con un commento che dice il compromesso.
**Cosa non semplifica mai:** validazione degli input, gestione degli errori che evita perdite di dati, sicurezza, accessibilità e funzionalità chieste esplicitamente.
**Formato delle risposte:** prima il codice, poi al massimo tre righe brevi, nella forma "saltato X, da aggiungere quando Y". Per esempio, a "aggiungi una cache per le risposte API" risponde con `@lru_cache(maxsize=1000)` sulla funzione e "saltata una classe di cache dedicata, da aggiungere quando lru_cache non basta più".
Esempio dal README: per "aggiungi un selettore di data al frontend" senza la skill l'agente scrive 335 righe tra libreria e calendario fatto a mano; con ponytail riusa il componente `Input` del progetto con `type="date"` (il browser fornisce il calendario) in un file da 10 righe.
### Livelli di intensità
| Livello | Comportamento |
|---|---|
| `lite` | fa quello che chiedi, ma indica in una riga l'alternativa più semplice; scegli tu |
| `full` | applica la scala in modo rigido (predefinito) |
| `ultra` | estremista YAGNI: prima cancella, poi aggiunge; consegna la soluzione in una riga e mette in discussione il resto |
| `lite` | fa quello che chiedi, ma indica in una riga l'alternativa più piccola; scegli tu |
| `full` | applica le regole sopra (predefinito) |
| `ultra` | mette in discussione anche la richiesta: prima di costruire contesta ciò che il bisogno non giustifica |
| `off` | disattiva |
Il livello predefinito si cambia con la variabile d'ambiente `PONYTAIL_DEFAULT_MODE` o nel file `~/.config/ponytail/config.json`.
Il livello predefinito si cambia con la variabile d'ambiente `PONYTAIL_DEFAULT_MODE` o con il campo `defaultMode` in `~/.config/ponytail/config.json`.
### Comandi
Il plugin completo comprende sei skill, richiamabili con i comandi `/` in Claude Code e OpenCode, oppure con `@` in Codex:
Il plugin completo comprende sei skill, richiamabili con i comandi `/` in Claude Code e negli altri agenti che le supportano (in Codex con `$ponytail:<nome>`, per esempio `$ponytail:ponytail-review`):
| Comando | Funzione |
|---|---|
| `/ponytail [lite\|full\|ultra\|off]` | attiva la modalità o ne cambia il livello |
| `/ponytail-review` | cerca la sovraingegnerizzazione nelle modifiche correnti |
| `/ponytail-audit` | cerca codice superfluo in tutto il repository |
| `/ponytail-debt` | raccoglie le scorciatoie rimandate |
| `/ponytail-gain` | mostra i dati di impatto |
| `/ponytail [lite\|full\|ultra\|off]` | attiva la modalità o ne cambia il livello; senza argomento la accende se è spenta, altrimenti mostra il livello |
| `/ponytail-review` | rivede le modifiche correnti come lo sviluppatore senior che viene chiamato quando qualcosa si rompe: errori, sicurezza, carico reale, codice a rischio senza test, punti lenti e cosa tagliare. Ogni segnalazione dice che cosa fa il codice, cosa va storto, come correggerlo e cosa succede se non lo fai. Puoi indicare l'obiettivo: `uncommitted`, `staged`, `branch` o il link a una PR |
| `/ponytail-audit` | lo stesso controllo su tutto il repository: ne mappa il codice e ordina i problemi per priorità |
| `/ponytail-debt` | raccoglie in un registro i commenti `shortcut:` rimandati |
| `/ponytail-gain` | mostra i dati di impatto misurati nel benchmark |
| `/ponytail-help` | guida ai comandi |
### Risultati dichiarati e verificati
- **Secondo l'autore**, misurato su un repository FastAPI + React: circa il 54% di codice in meno (fino al 94% nei casi più sovraingegnerizzati), costo più basso del 20% circa, esecuzione più veloce del 27% circa, nessun taglio su sicurezza, validazione e accessibilità.
- **Secondo un test indipendente di JetBrains** (luglio 2026, 80 compiti con Claude Code e Sonnet 5): codice più corto del 15,4% (dato non statisticamente significativo), costo più basso del 10,3% (significativo), qualità invariata. Il guadagno è maggiore dove l'agente tende a costruire troppo e quasi nullo nei compiti già snelli. Il test riguardava compiti di analisi dati, non frontend, e non verificava sicurezza e accessibilità.
- **Secondo l'autore** (Ponytail 5, benchmark in Claude Code con Opus 5.5: 39 compiti, compreso un repository reale FastAPI + React, 5 esecuzioni ciascuno, con e senza la skill): circa 53% di codice in meno, 41% di tempo in meno, 26% di costo in meno e 45% di token in meno. Il 98% della logica a rischio esce con un test, contro il 68% senza la skill. Sui sei compiti di sicurezza (SQL injection, path traversal, token falsificati, limitazione delle richieste, righe CSV malformate, cache) ha superato tutte le 30 esecuzioni.
- **Secondo un test indipendente di JetBrains** (luglio 2026, 80 compiti con Claude Code e Sonnet 5, su una versione precedente): codice più corto del 15,4% (dato non statisticamente significativo), costo più basso del 10,3% (significativo), qualità invariata. Il guadagno è maggiore dove l'agente tende a costruire troppo e quasi nullo nei compiti già snelli. Il test riguardava compiti di analisi dati, non frontend, e non verificava sicurezza e accessibilità.
### Da sapere
- **Senza hook non si attiva da sola:** il plugin funziona grazie a un hook che inietta le regole all'inizio di ogni sessione. Nel test di JetBrains, installata come semplice skill senza hook, non si è mai attivata in dieci sessioni. Per questo conviene installarla come plugin (vedi sotto); altrimenti va richiamata a mano ogni volta.
- **Aspettative:** su compiti normali conta su un risparmio intorno al 10%, non sul 54% dichiarato.
- **Hook:** il plugin esegue script all'avvio di ogni sessione in Claude Code, Codex e Cursor.
- **Aspettative:** i numeri dell'autore sono i suoi; su compiti normali, indipendentemente, conta su un risparmio intorno al 10%.
- **Hook:** il plugin per Claude Code e Codex (e gli hook per Cursor) esegue due piccoli script Node.js all'avvio e durante la sessione. Serve `node` nel `PATH`; senza, le skill funzionano ma ogni chiamata dell'hook mostra un errore innocuo `node: command not found`. In Codex vanno approvati da `/hooks`.
- **Senza hook niente attivazione automatica:** nel test di JetBrains, installata come semplice skill senza hook, la versione allora corrente non si è mai attivata in dieci sessioni. Con il solo `npx skills` conviene aggiungere anche `AGENTS.md` del repository al progetto, oppure usare il plugin.
- **File lasciati fuori dal plugin:** scrive un file di stato (`~/.claude/.ponytail-active`), `~/.config/ponytail/config.json`, uno script per la barra di stato in `~/.claude/` e, se accetti il suggerimento, una voce `statusLine` in `~/.claude/settings.json`.
- **Provenienza:** il README avverte di installarlo solo da `DietrichGebert/ponytail` su GitHub o da `@dietrichgebert/ponytail` su npm; il progetto non distribuisce mai file `.exe` o `.dll`.
## Installazione
### Claude Code (plugin, consigliato)
Nella sessione di Claude Code:
Nella sessione di Claude Code, **come due messaggi separati** (il README avverte che altrimenti l'installazione non funziona):
```
/plugin marketplace add DietrichGebert/ponytail
```
```
/plugin install ponytail@ponytail
```
Installa le sei skill e l'hook di avvio. Poi:
Installa le sei skill e gli hook. Poi:
```
/plugin marketplace update ponytail # aggiornamento
/plugin remove ponytail # rimozione (comando indicato nel README)
/plugin remove ponytail # rimozione
```
### Codex (plugin, consigliato)
@@ -105,9 +105,9 @@ codex plugin marketplace add DietrichGebert/ponytail
codex plugin add ponytail@ponytail
```
Rimozione: `codex plugin remove ponytail`.
Poi apri `codex`, vai su `/hooks`, controlla e approva i due hook, e avvia una nuova conversazione. Lo stesso comando vale per l'app desktop di Codex: riavviala dopo l'installazione. Rimozione: `codex plugin remove ponytail`.
Per eliminare anche i file di stato che il plugin lascia sul sistema, il README indica di eseguire `node scripts/uninstall.js` dalla cartella del repository.
Per eliminare anche i file di stato lasciati fuori dal plugin, esegui `node scripts/uninstall.js` dalla cartella del repository **prima** del comando di rimozione (lo script è un file del plugin, e rimuovendolo prima sparirebbe), oppure da un clone separato.
### Claude Code e Codex (solo skill, senza hook)
@@ -117,14 +117,18 @@ In alternativa, con lo strumento `skills`:
npx skills add DietrichGebert/ponytail --skill ponytail -g -a claude-code -a codex
```
Per averle tutte e sei: `--skill '*'`.
| Opzione | Significato |
|---|---|
| `--skill ponytail` | installa solo la skill principale; `--skill '*'` le installa tutte e sei |
| `--skill ponytail` | installa solo la skill principale; `--skill '*'` le installa tutte e sei senza domande |
| `-g` | installazione globale (`~/.claude/skills/`, `~/.codex/skills/`); senza, solo nel progetto corrente |
| `-a <agente>` | agente di destinazione, ripetibile |
| `-y` | salta le domande di conferma |
Così non c'è l'hook: la skill va richiamata a mano (per esempio scrivendo "ponytail" o "lazy mode"). Gestione con `npx skills list -g`, `npx skills update ponytail` e `npx skills remove ponytail`.
Così non ci sono gli hook né le regole sempre attive: per averle copia `AGENTS.md` del repository nel progetto, altrimenti richiama la skill a mano (per esempio scrivendo "ponytail"). Gestione con `npx skills list -g`, `npx skills update ponytail` e, per rimuovere tutte e sei, `npx skills remove ponytail ponytail-audit ponytail-debt ponytail-gain ponytail-help ponytail-review` (con gli stessi `-a` e `-g` dell'installazione).
Per gli altri agenti (Cursor, Copilot, Gemini, OpenCode, Windsurf e altri) il progetto ha una guida per ciascuno in [INSTALL.md](https://github.com/DietrichGebert/ponytail/blob/main/INSTALL.md); in genere basta copiare `AGENTS.md` nel progetto.
### App desktop di Claude e ChatGPT
@@ -144,7 +148,7 @@ Nelle app non ci sono hook, quindi la skill va richiamata esplicitamente in ogni
- [README di DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- [SKILL.md di ponytail](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail/SKILL.md)
- [SKILL.md di ponytail-help](https://github.com/DietrichGebert/ponytail/blob/main/skills/ponytail-help/SKILL.md)
- [INSTALL.md di ponytail](https://github.com/DietrichGebert/ponytail/blob/main/INSTALL.md)
- [ponytail su skills.sh](https://skills.sh/dietrichgebert/ponytail/ponytail)
- [Ponytail Skill for Claude Code: Does It Really Cut Tokens – JetBrains](https://blog.jetbrains.com/ai/2026/07/ponytail-skill-claude-tested/)
- [Use skills in Claude – Claude Help Center](https://support.claude.com/en/articles/12512180-use-skills-in-claude)
+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)
+1 -1
View File
@@ -4,7 +4,7 @@
- **Repository:** [aj-geddes/useful-ai-prompts](https://github.com/aj-geddes/useful-ai-prompts) (licenza MIT), una raccolta di oltre 260 skill e 488 prompt
- **Sorgente:** [skills/project-estimation/SKILL.md](https://github.com/aj-geddes/useful-ai-prompts/blob/main/skills/project-estimation/SKILL.md)
- **Pagina su skills.sh:** [aj-geddes/useful-ai-prompts/project-estimation](https://skills.sh/aj-geddes/useful-ai-prompts/project-estimation)
- **Diffusione (settembre 2026):** circa 645 installazioni (su skills.sh dal 21 gennaio 2026); il repository ha circa 344 stelle su GitHub
- **Diffusione (ottobre 2026):** circa 649 installazioni (su skills.sh dal 21 gennaio 2026); il repository ha circa 363 stelle su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati
> Esiste un'altra skill con lo stesso nome, di [szkocot/skills](https://github.com/szkocot/skills): stima software per ruolo con esportazione in Excel e Jira, ma con 4 installazioni e il controllo Snyk non superato. Questa scheda riguarda solo la versione di aj-geddes.
+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)
+1 -1
View File
@@ -5,7 +5,7 @@
- **Sorgente:** [.claude/skills/ui-ux-pro-max/SKILL.md](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill/blob/main/.claude/skills/ui-ux-pro-max/SKILL.md)
- **Pagina su skills.sh:** [nextlevelbuilder/ui-ux-pro-max-skill/ui-ux-pro-max](https://skills.sh/nextlevelbuilder/ui-ux-pro-max-skill/ui-ux-pro-max)
- **Versione:** v2.15.0 (13 agosto 2026)
- **Diffusione (settembre 2026):** circa 367.600 installazioni tramite `npx skills` (su skills.sh dal 19 gennaio 2026); il repository ha circa 130.000 stelle e 13.800 fork su GitHub
- **Diffusione (ottobre 2026):** circa 398.400 installazioni tramite `npx skills` (su skills.sh dal 19 gennaio 2026); il repository ha circa 136.300 stelle e 14.500 fork su GitHub
- **Controlli di sicurezza su skills.sh:** Gen Agent Trust Hub, Socket e Snyk superati
## A cosa serve
+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)