CCW · L2 · 1 / 23
Claude Code Workshop · Gruppo 1

L2 — Costruiamo.

Essedi Training Services · Workshop L2
Recap · L1 → Pre-L2

Da dove ripartiamo.

Lezione 1 · imparato
  • Pianifica prima di costruire — il valore sta nel piano
  • Il contesto decide la qualità dell'output
  • Plan mode: leggi la proposta, poi approvi
  • Ciò che si ripete va documentato
Pre-L2 · fatto da voi
  • Progetto reale su disco, workspace VS Code
  • Piano costruito con /grill-me — la prima skill
  • Scaffold con docs/ e CLAUDE.md — generato da Claude, non a mano
  • CLAUDE.md letto — oggi lo criticate voi
Piano ✓ · Struttura ✓ — oggi: costruzione.
La mappa del percorso

I mattoni di Claude Code.

Sei mattoni in quattro settimane. Il primo è posato — oggi ne posiamo due.
Piano + Approvazione Leggi il piano prima che Claude esegua. Il gate che vi mette in controllo. Lezione 1 ✓
Oggi CLAUDE.md La memoria del progetto. Introdotto in L1 — oggi lo scriviamo bene. Oggi · Lezione 2
Oggi Skills Procedure salvate che lanciate con /. Oggi le catturate dal build. Oggi · Lezione 2 → 3
Rules Regole che si caricano da sole quando servono. Lezione 3
MCPs Collegano Claude ai vostri strumenti reali. Lezione 3
Hooks Controlli automatici che bloccano gli errori. Lezione 4 · opz.
Recap veloce

Tre modi di usare Claude Code.

Dentro VS Code · dove lavorate voi
Estensione
Il pannello
La sessione a fianco dei vostri file. Vedete cosa fa Claude mentre lo fa. Il nostro standard nel corso.
Terminale integrato
La riga di comando
Lo stesso Claude nel terminale di VS Code, senza pannello. Utile quando prenderete confidenza.
App a sé
App desktop
L'app nativa
Claude Code nell'app di Claude, fuori da VS Code: per quando non avete l'editor aperto. Non dal browser.
Stesso Claude, stessi file. Cambia solo da dove gli parlate.
La sessione di oggi

Tre sezioni.

Sezione 1
I file sono la spina dorsale
Un progetto è fatto di file: CLAUDE.md, documenti, skill. È lì che vive tutto quello che Claude sa del vostro lavoro.
Sezione 2
Demo: dal piano agli asset
Costruiamo dal vivo un progetto vero per Essedi, un passo alla volta: fasi, mockup, costruzione, review.
Sezione 3
Effetto composto
Ogni passaggio che si ripete diventa una skill. E a fine sessione, quello che abbiamo imparato resta nei file.
Sezione 1 · I file sono la spina dorsale

La memoria di Claude sono i vostri file.

Claude non ricorda nulla tra una sessione e l'altra. Tutto quello che sa del vostro progetto lo legge dai file, ogni volta. Tre tipi, tre momenti di lettura:

CLAUDE.md
Caricato a inizio sessione, sempre nel contesto. Le istruzioni permanenti del progetto: cosa state costruendo, dove guardare, cosa non fare.
docs/
Letti quando servono. Il contesto di approfondimento: guide, regole lunghe, materiale di riferimento.
skills
Letti su richiesta, con /nome. Procedure salvate che potete rieseguire quando volete — come Grill Me.
Migliori i file, migliora Claude. Questo è il concetto di oggi.
Sezione 1 · I file sono la spina dorsale

Anatomia di un buon CLAUDE.md.

CONTESTO
Cos'è questo progetto e perché esiste. L'inquadramento che orienta ogni scelta di Claude.
FILE
Dove guardare: link a docs/ e ai file importanti. Si punta fuori, non si incolla dentro.
REGOLE
Cosa non fare mai. Limiti, sicurezza, stile. Le regole fisse che non si negoziano.
COMANDI
Per progetti più maturi: scorciatoie del progetto. Non oggi — lo vedrete più avanti.
Regola: ≤ 60 righe. Sempre nel contesto — ogni riga in più ruba spazio al lavoro vero.
→ CLAUDE.md parla a Claude. README.md parla alle persone.
→ Le regole più complesse possono stare in file di regole dedicati, caricati all'avvio come il CLAUDE.md — e come lui occupano contesto. Le vediamo in L3.
Sezione 1 · I file sono la spina dorsale

Globale e di progetto.

All'avvio Claude carica entrambi i CLAUDE.md nello stesso contesto: il vostro, personale, e quello del progetto. Uno vi segue ovunque, l'altro vale solo qui.

Globale · vi segue ovunque
~/.claude/CLAUDE.md

Le vostre preferenze personali, valide in ogni progetto: come lavorate, che tono preferite, le vostre abitudini.

Progetto · vale solo qui
CLAUDE.md

Le regole di questo progetto: cosa costruite, i vincoli, cosa non fare mai. Quello che avete appena visto.

In caso di conflitto

Il globale dice «rispondi in inglese», il progetto Essedi dice «rispondi in italiano» → qui vince l'italiano. Il più specifico batte il più generale.

Si caricano insieme all'avvio. In conflitto vince il più specifico: progetto > globale.
Sezione 1 · I file sono la spina dorsale

Perché snello vince.

01
Gonfio = meno efficace

Un CLAUDE.md troppo lungo mangia lo spazio che Claude usa per il lavoro vero. Meno spazio per il problema, più spazio per le istruzioni.

02
È un file vivo

Non è fatto per sempre. Si affina quando imparate qualcosa di nuovo sul progetto — non lasciatelo invecchiare.

03
Puntate fuori, non incollate dentro

Le regole lunghe vanno in docs/. Il CLAUDE.md indica dove guardare — non sostituisce la documentazione.

"Un CLAUDE.md ben curato vale più di dieci prompt perfetti."
Sezione 1 · I file sono la spina dorsale

L'output dell'AI è un punto di partenza.

Claude Code lavora con quello che gli date — e la direzione la date voi. Il CLAUDE.md che ha generato per il vostro progetto ne è la prova: è una bozza da affinare, non il prodotto finito.

"L'AI costruisce quello che descrivi. Se la descrizione è vaga, l'output è educatamente vago."
Il vostro lavoro è affinare il contesto — non solo eseguire.
Sezione 2 · Demo: dal piano agli asset

Quando le cose si rompono.

La maggior parte dei problemi con Claude Code non viene da Claude. Viene da come partiamo noi. Tre momenti tipici:

Attacchi un progetto complesso tutto in una volta
Un progetto grande costruito in un colpo solo diventa ingestibile: nessun punto di controllo lungo il percorso, e gli errori escono alla fine. Prima si divide in fasi, poi si procede una alla volta.
Costruisci senza aver detto cos'è "fatto"
Da una richiesta vaga esce un risultato vago — senza errori e senza avvisi. Sembra giusto, ma non è quello che volevate.
Fai partire il codice senza aver schizzato la forma
Le decisioni che non prendete voi le prende Claude, a modo suo. E correggerle dopo, a codice già scritto, costa il doppio.
Tre abitudini eliminano questi tre momenti. Le vedrete tutte nella demo.
Abitudine 1 Demo

Una fase alla volta.

Un progetto complesso non si costruisce in un colpo solo. Chiedete a Claude di dividere il piano in fasi — quante e quali le propone lui. Poi se ne costruisce una alla volta.

Fase 1
Costruisci e verifica
Un pezzo autonomo, portato a termine e controllato.
Fase 2
Poi la successiva
Parte da una base già solida, non dal caos.
Fase …
Fino in fondo
Tante fasi quante ne servono — lo decide il piano.
Fasi piccole, problemi piccoli: se qualcosa non va, lo scoprite alla fine di una fase — non alla fine di tutto.
È la prima mossa della demo — e la catturiamo come skill: dividi-in-fasi.
Abitudine 2 Demo

Definisci "fatto."

Prima di far costruire: scrivete 3 criteri concreti e verificabili. Nella demo lo facciamo a ogni fase.

Esempio: pagina case study
  • La pagina racconta sfida, soluzione e risultato dell'installazione
  • Il cliente è indicato per settore, mai per nome
  • Si apre nel browser ed è pronta da mostrare a un cliente
funziona sembra giusto
Se non riuscite a scrivere tre criteri, il compito non è ancora definito.
Abitudine 3 Demo

Schizza la forma prima del codice.

Prima uno schizzo ASCII — costa pochissimo e si corregge in secondi. Poi il mockup HTML — si vede davvero. Solo dopo la review si costruisce.

+----------------------------------------------+ | STUDIO LEGALE · 6 SALE + SALA CONSIGLIO | | Titolo del progetto | +----------------------+-----------------------+ | LA SFIDA | LA SOLUZIONE | | avvio lento, IT... | Teams Rooms, Poly... | +----------------------+-----------------------+ | IL RISULTATO · citazione del cliente | | [ specifiche: Teams · Poly · Shure · touch ]| +----------------------------------------------+
Vi obbliga a vedere le decisioni ancora da prendere — quando cambiarle costa ancora zero.
Sezione 2 · Buono a sapersi

Controlla cosa dipende da questo.

Quando cambiate qualcosa di condiviso — un nome di campo, un formato, dove stanno i file — le parti che si aspettavano il vecchio valore si rompono senza fare rumore.

Esempio

Rinominate il campo "Azienda" → "Account" nei contatti. Il report settimanale cerca ancora "Azienda" — torna vuoto. Nessun errore. Solo un report silenziosamente sbagliato.

Il riflesso utile: prima di considerarlo fatto, chiedete a Claude:

"Cos'altro in questo progetto usa questo?"
L'errore più ricorrente nel costruire. Si rompe in silenzio, un giorno dopo.
Il ciclo completo

In ogni fase, lo stesso loop.

Dividete il progetto in fasi. Dentro ogni fase gira sempre questo ciclo — e solo quando è chiuso si passa alla successiva.

Fase 1 Fase 2 Fase 3
Dentro ogni fase
Criterivoi
Schizzovoi
BuildClaude
Verifica ✓voi · gate
Dipendenzevoi
ciclo chiuso → si apre la fase successiva
Voi guidate e verificate (il gate), Claude costruisce. Fase dopo fase, fino al progetto completo.
Sezione 2 · Demo: dal piano agli asset Demo

La demo, passo per passo.

01
Apriamo il progetto — nuova sessione, leggiamo il piano già pronto.
02
Dividiamo il piano in fasi — e catturiamo il gesto come skill.
03
Criteri di "fatto" per la fase 1 — tre, concreti, verificabili.
04
Schizzo ASCII → mockup HTML → review — e anche questo diventa una skill.
05
Claude costruisce — noi verifichiamo i criteri e diamo feedback.
06
Skill di progetto — dai dati di un'installazione a tutti gli asset, in un comando.
07
Retrospettiva — salviamo nei file quello che abbiamo imparato oggi.
Questa slide è l'ancora: ci torniamo ogni volta che Claude sta lavorando.
Prima di costruire

Quanta autonomia date a Claude.

Il selettore di Plan Mode (Shift+Tab) ha più livelli. Ogni modalità decide quanto Claude fa da solo prima di fermarsi a chiedervi.

01
Plan mode

Esplora e propone un piano. Non tocca ancora nessun file. Per iniziare qualsiasi cosa di nuovo.

02
Manuale

Chiede approvazione prima di ogni modifica. La più prudente: vedete tutto, mentre imparate.

03
Edit automatically

Applica da sola le modifiche ai file; per i comandi chiede ancora. Per lavoro ripetitivo di cui vi fidate.

04
Bypass permissions

Non chiede più niente, nemmeno per i comandi delicati. Autonomia massima: la modalità della velocità, quando vi fidate del piano e dell'ambiente.

Una manopola di autonomia: più salite, più Claude va da solo. Scegliete in base a quanto conoscete il progetto e a quanta velocità vi serve.
Sezione 3 · Effetto composto

Avete già usato una skill.

/
Grill Me
L'avete installata in Pre-L2 e usata per costruire il piano del vostro progetto. Questo è esattamente il concetto.
Invocata con /grill-me · disponibile in ogni progetto
Cos'è una skill
Un'istruzione salvata e riutilizzabile, attivata su richiesta con /nome. Claude la legge al momento dell'invocazione — non prima, non sempre. È contesto on-demand.
L1 = pianificazione. Pre-L2 = prima skill. Oggi = catturate le prossime dal build.
Cattura mentre costruisci Demo

Una volta che si ripete, catturalo.

Nella demo l'abbiamo fatto due volte: un gesto appena eseguito, una frase a Claude — "trasformalo in una skill" — ed è salvato per sempre.

/1
dividi-in-fasi — prende un piano e lo divide in fasi di costruzione sensate. Nato dal primo passo della demo.
/2
mockup-prima — schizzo ASCII, poi mockup HTML, poi stop per la review. Nato dal secondo passo.
"Una volta che un processo si ripete, catturalo come skill."
Sezione 3 · Effetto composto

Le skill si compongono.

Una skill può richiamarne altre. Due gesti catturati oggi diventano un flusso di lavoro unico — lo chiediamo a Claude con una frase:

/dividi-in-fasi + /mockup-prima /esegui-piano
A
Skill globali

Valgono in tutti i vostri progetti. dividi-in-fasi e mockup-prima servono ovunque: vivono nella cartella .claude globale.

B
Skill di progetto

Valgono solo qui. La skill che genera gli asset di un'installazione conosce la voce di Essedi: vive dentro il progetto.

Lezione 3
Skill più potenti, regole, impostazioni globali, MCP: come questa composizione diventa un sistema.
Sezione 3 · Effetto composto Demo

Quello che imparate resta nei file.

A fine sessione, il feedback che avete dato non si butta: diventa regole nel CLAUDE.md, ritocchi alle skill, note nei docs. La sessione dopo parte già più avanti.

Il prompt di chiusura — da copiare

"Prima di chiudere: cosa abbiamo imparato oggi che vale la pena salvare? Proponi aggiornamenti a CLAUDE.md, alle regole o alle skill — la prossima sessione deve partire già più avanti."

Un agente documentato migliora a ogni sessione. Uno non documentato riparte sempre da zero.
Cosa abbiamo visto oggi

Tutto in una slide.

01
Tre modi di usare Claude Code — estensione e terminale dentro VS Code, o l'app desktop.
02
I file sono la spina dorsale — CLAUDE.md sempre nel contesto (≤60 righe), docs/ quando servono, skill su richiesta.
03
Fasi + loop di build — dividi in fasi; in ogni fase: criteri di "fatto" → schizzo → costruzione → verifica → dipendenze.
04
Le modalità di permesso — da Plan mode a Bypass permissions: quanta autonomia date a Claude.
05
Cattura le skill — ciò che si ripete diventa skill; le skill si richiamano tra loro; globali o di progetto.
06
Effetto composto — la retrospettiva di fine sessione salva ciò che si è imparato nei file: Claude migliora ogni volta.
Prossima fermata: L3 — skill più potenti, regole, impostazioni globali, MCP.