CCW · Lesson 3 · Internal review · not participant-facing

L3 Live Session Plan
Skills, Rules & MCPs

Full build plan for the July 16 live session: teaching map, timing, demo scripts, 30-slide deck, sources. Status: v3 — approved & in build; Raffaello's Jul 14 feedback integrated (/pubblica-installazione + Gmail MCP).

Live: Wed Jul 16 Content: 75 min + Q&A 12 min Slides: 31 Demo blocks: 6 (~44 min) Cohort: Essedi · 8 seats · IT/EN Rev: v3 · 14 Jul

v2 changes (Giuseppe's feedback, Jul 14): rule-file creation + CLAUDE.md linking now shown explicitly (new slide 06, Demo 1 expanded) · concrete when-a-script example added · tier-3 example is now /chiudi-installazione calling the L2 skills · new skill-vs-hook comparison slide (17) · models and effort both demoed live · "rapid-fire" renamed to toolbox (cassetta degli attrezzi) · new section 4 with the ranked skip-to-L4 cut list · all six demos rewritten step-by-step with verbatim prompts · every demo slide now carries its numbered steps as a take-home runbook · demo project proposed: the L2 Essedi asset generator (decision 4).

1 · What L3 teaches

A Rules

Constraints Claude loads automatically: project rules, global rules, scoped rules (paths:). Why rules live outside CLAUDE.md (keep it lean, each rule at home). Mechanics shown on screen, not just described: create the file (.claude/rules/nome-regola.md, frontmatter with paths:, plain-language body) and the two ways it gets loaded — scoped rules load themselves when a matching file is touched; always-on rules are linked from CLAUDE.md with one @.claude/rules/nome-regola.md import line. The self-audit habit: a fresh session reviews your CLAUDE.md because the author cannot self-audit. The silent-failure warning: a misconfigured rule fails with zero warnings, so verify, don't trust. (Exact frontmatter key and import syntax re-verified on the current CLI version during demo-asset build.)

B The global layer (~/.claude)

Taught from zero live (cut from the prework preview). Global CLAUDE.md, settings.json, global skills. The placement decision: applies to every project → global; applies to this work → project. Anchor: they have used it unknowingly since Week 2, grill-me lives there.

C Skills that grow into workflows + scripts + early hook

The 3 tiers from the prework: plain instructions → instructions plus a script (fixed code, exact every run, zero AI tokens) → scripts plus supporting files and templates. When does a step earn a script? The litmus test: if doing it twice must produce identical results and any variation is a bug (date-stamped filenames, moving a file to archive, a VAT calculation), it's a script; if two good versions could legitimately differ (drafting the report text), it stays with Claude. Canonical example told live: the rule says "save as weekly-status-YYYY-MM-DD.md and archive the old one" — Claude gets it right 9 times out of 10, the 10th it writes report-14-luglio.md or forgets the archive; that step becomes a 3-line script that cannot get it wrong, never gets tired, costs zero tokens. Build a tier-2 skill live from a real repeated workflow. Tier-3 composition made concrete: /chiudi-installazione — one skill that calls /case-study, /post-linkedin and /testo-sito from the L2 demo, so "skills calling skills" lands on assets they already saw built. Then the early hook as the natural next rung, with the distinction made explicit: a skill is a playbook YOU invoke and can skip; a hook is a guardrail the SYSTEM fires on every event, whether or not anyone remembers. "The rule that keeps failing becomes a hook."

D MCPs + the mother project

Files are read, tools are used: MCP is the connector. One live connection (calendar, to confirm). The friction-twice decision gate so nobody over-installs. The agentic map: a central project whose docs other projects reference, the thing that makes the two-layer architecture personal.

E Operational literacy — the toolbox (la cassetta degli attrezzi)

Formerly labelled "rapid-fire", which confused even us: it just means four short back-to-back micro-demos, ~3 minutes each — breadth, not depth. Renamed everywhere to "toolbox". Contents: models and effort (which brain for which task + how long it thinks; switch live with /model, set the default in settings.json). Context window, /compact, usage monitoring. Git as part of the build loop. Live Server. Testing teaser: "prove it works", full method in L4.

· Close: the compounding loop

Error → rule → skill → hook. Every correction made once. The system improves every week.

2 · Session timing

Block	Time	Cumulative
Show & tell + map of today	10 min	0:10
Rules (Demo 1)	10 min	0:20
Global layer (Demo 2)	8 min	0:28
Skills + scripts (Demo 3)	15 min	0:43
MCP + API beat (Demo 4)	10 min	0:53
Mother project / agentic map	3 min	0:56
Toolbox (Demo 5, 4 micro-demos)	12 min	1:08
Testing teaser + loop + close	4 min	1:12
Q&A (+ hook bonus if ahead)	15 min	1:27

Buffer strategy (L3 is the highest cognitive-load week): see section 4 for the full ranked cut list — up to ~13 min recoverable without touching the four non-negotiable demos.

3 · The six demo blocks

Demo project (all six demos): the L2 Essedi marketing asset generator (sessions/lesson-2-build-a-feature/demo/). One project across L2→L3 makes the compounding story literal — the friction they watched in L2 becomes the rules and skills of L3. See open decision 4. Every step below states the exact prompt typed; these same steps appear on the demo's companion slide.

DEMO 1 · 10' Self-audit → create a rule file → link it → silent failure

Setup: the L2 asset-generator project with a pre-baked bloated CLAUDE.md (1 stale instruction, 1 repeated-mistake candidate — the output-file naming) + a pre-baked broken rule file using globs: instead of paths:.

0–1': open the project, fresh session. Frame: "this project has been worked in for two weeks — like yours."
1–3': type: "Leggi il CLAUDE.md di questo progetto. Cosa è obsoleto, cosa manca, cosa dovrebbe diventare una regola?" — Claude flags the stale instruction and the repeated naming mistake.
3–5': create the rule file on screen: "Crea un rule file .claude/rules/naming-asset.md scoped sui file di output" — open the generated file, walk the three parts: path, paths: frontmatter, plain-language body. Point: a rule is just a markdown file in the right place.
5–6': show the two ways it loads: scoped rule fires by itself when a matching file is touched (prove it: ask for an asset, watch the rule respected). For an always-on rule, add ONE line to CLAUDE.md: @.claude/rules/stile-essedi.md — "CLAUDE.md is the index, rules are the chapters."
6–8': the silent failure: swap in the pre-baked globs: file, same request → rule ignored, zero warnings. Fix the one line to paths: → same request now respects it. "La config sbagliata non urla."
8–10': "quale regola vale per TUTTI i tuoi progetti?" → "mai lavorare direttamente su main" → it can't live in this project → bridge to Demo 2.

ProofThe fresh session flags what the author missed (implementer cannot self-audit); the rule file is created, linked and seen firing on screen; one config line flips behavior with no error (misconfiguration is silent).

DEMO 2 · 5' The global layer tour

Setup: the two-root VS Code workspace from pre-L2 (~/.claude already in their sidebar).

0–2': open global CLAUDE.md ("who I am, how I work — true in every project") → settings.json, point at the model default line ("remember this line — it pays off in the toolbox block") → ~/.claude/skills/ where grill-me already lives.
2–4': run /grill-me in the asset generator, then in a second project.
4–5': placement question to the room: "regola di stile Essedi — global o project?" (project). "Mai su main?" (global).

ProofThe same skill fires in two projects: "you have used the global layer since Week 2 without knowing."

DEMO 3 · 10' /pubblica-installazione: the conductor skill (centerpiece — reworked on Raffaello's design, Jul 14)

The L2 asset generator becomes production-grade. The framing question: what happens BEFORE and AFTER the AI generates? Four steps: validate (script) → generate (AI) → check compliance (script: LinkedIn ≤700 chars, never the client name, valid HTML) → archive (script). Setup: 3 briefs seeded — brief-3 incomplete (missing field), brief-2 with the client name planted in a subtle field.

0–2': frame + the transform prompt (verbatim on slide 13): four steps, scripts exact, generation flexible
2–5': read what Claude built — SKILL.md + validate-brief.py + check-compliance.sh + archive-outputs.sh. "Righe scritte da noi: zero"
5–7': the free catch — incomplete brief stopped at step 1, zero AI tokens spent
7–9': the compliance catch — the client name slips into generation, the script catches it. "'Mai nominare il cliente' era una regola scritta; ora non può essere dimenticata" → the bridge to hooks
9–10': "quanti dei quattro passi servivano l'AI?" → one + the transfer question: "nel vostro workflow Pre-L3, quali passi sono in realtà deterministici?"

ProofIncomplete brief caught before one AI token; the L2 rule enforced as a spec; 1 AI step out of 4. The recipe/chef frame (oven at 180° vs season to taste) sets it up on slide 12. Tier-3 shown in 30": the generate step DELEGATES to /case-study + /post-linkedin + /testo-sito — the skill is a conductor, not a generator. Fallback: pre-built skill on a branch.

BONUS (if ahead) Skill vs hook: playbook vs guardrail — moved out of the main flow (Giuseppe, Jul 14 evening)

Framing (slide 17 table shown first): a skill is a playbook — you invoke it, it can be skipped, it does work. A hook is a guardrail — the system fires it on every event, nobody has to remember it, it prevents mistakes. Setup: the global "never commit to main" rule from Demo 1 + a prepared branch-guard hook.

0–2': ask Claude to commit to main. The written rule might stop it — show that it can slip (rules are advisory text).
2–4': install the hook, same request: blocked, visibly, every time. "Nobody remembered anything — the system did."

ProofRule text is advisory, the hook makes the action physically impossible. Slide line: "la regola che continua a fallire diventa un hook."

DEMO 5 · 10' MCP connected live (email) + API beat + decision gate

Switched from Google Calendar to Gmail (Raffaello's feedback, Jul 14): sharing the generated assets continues the /pubblica-installazione story, and sending is a stronger proof than reading — Claude ACTS outside the files. Calendar stays as tested plan-B. MCP-vs-API beat added (Raffaello, Jul 14 15:17): 30-sec superficial distinction on slide 19 — MCP = standard plug, API = the tool's own socket Claude can still use; named example: Buffer (has an API, no MCP). Take-home concept: "connessione a strumenti esterni" — so a missing MCP never reads as a dead end. Buffer stays the cohort-2 demo candidate (via its API).

0–1': collect 2–3 answers to the prework priming questions
1–3': connect Gmail on screen, timed — "questo è tutto il progetto di integrazione"
3–5': "Prendi il case study appena generato e mandalo a [collega] chiedendo una revisione entro giovedì" — co-instructor shows it arriving in their inbox
5–6.5': the API beat (Giuseppe, Jul 14): both plugs live — "che tempo farà domani a Varese?" No weather MCP exists: Claude writes the call to a keyless public API (Open-Meteo) itself. MCP = standard plug; API = Claude writes the adapter; one concept. First cut of this demo if behind
6.5–10': decision-gate round: each participant names their friction-twice tool, apply the gate together

ProofThe email exists in a colleague's inbox — Claude used a tool, not a file. Most participants get "not yet" from the gate, proving it is a filter, not a pitch.

DEMO 6 · 12' The toolbox — 4 micro-demos, ~3' each, breadth not depth

Models & effort (3') — type /model, pick Haiku, ask something trivial (note the speed), switch back. Show the effort setting in the same picker: model = which brain, effort = how long it thinks before answering (low = fast and cheap, high = slower and more careful). Then the payoff of Demo 2: the default lives in settings.json — change it once, every session starts there. (Exact picker UI re-verified at rehearsal on the current CLI version.)
Context + compact + usage (4') — watch the context indicator fill → /compact → ask about an early detail: gone from the chat, alive in todo.md (closes the loop with L1's memory-loss demo). 1' on the usage page: where the credits go, why model choice matters.
Git (2') — type: "Committa la fase 1 con un messaggio chiaro" → Claude runs git → show the commit on GitHub. Every closed phase = a restore point.
Live Server (2') — install the VS Code extension, edit the HTML mockup, browser updates live.

ProofModel switch: same question, visibly different speed. Compact: files are the real memory, the window is not. Git: version control happens inside the loop, no commands memorized.

4 · If we run late — the ranked cut list

What can be skipped and pushed to L4 (or async) without breaking the lesson's contract. Cut in this order; check the clock at 0:43 (end of Demo 3) and 0:55 (end of Demo 5).

Order	Cut	Saves	Where it lands	What's lost
1	Live Server	2 min	3-line tip in the follow-up email	Nothing conceptual — pure convenience tool
2	Usage monitoring minute	1 min	Screenshot + caption in the follow-up email	Nothing — it's a "where to click"
3	Git micro-demo	2 min	L4 — pairs naturally with shipping the capstone	Nothing permanent, L4 owns it anyway
4	Mother project / agentic map	3 min	1-min pointer now, full treatment opens L4 (capstone context)	The "personal architecture" moment — recoverable in L4

Never cut: Demo 1 (rules), Demo 2 (global layer), Demo 3 (tier-2 skill build), Demo 5 (MCP) — they ARE the take-home list on slide 29. Total recoverable: ~11–13 min, more than one full overrun.

5 · The deck, slide by slide (superseded — now 31)

Note (Jul 14, post-review): the deck evolved past this v2 list after Giuseppe's 21-point review — slide 19 split into MCP (19) + MCP-vs-API (20), everything after shifted +1, deck is now 31 slides. The list below is the v2 design reference; slides-l3.html is the source of truth.

Demo companion pattern (v2): every demo-tagged slide now carries the demo's numbered steps + the exact prompt in a pill — shown for ~20 seconds before switching to the terminal ("ecco cosa sto per fare"), left visible as reference, and doubling as the take-home runbook so participants can re-run every demo at home. No separate step-slides needed; the demo slide IS the runbook.

Apertura · 3 slides

Title

Skills, Rules & MCPs · "Smetti di ripeterti." · CCW L3 · 16 luglio

Show & tell

Question pill: "Cosa si è rotto? Cosa hai rifatto due volte?" 3 participants share.

Mappa di oggi

5 blocks: Regole → Livello globale → Skills che crescono → Collegare i tool → La cassetta degli attrezzi

Sezione A · Regole · 5 slides

04demo 1a

Self-audit

Chi scrive non può auto-verificarsi. Steps 1–2 of Demo 1 + the exact prompt pill. Fresh session reads YOUR CLAUDE.md; what it finds becomes the first rule.

Rule files

Vincoli che si caricano da soli: project / global / scoped (paths:). CLAUDE.md stays lean.

06demo 1bnew v2

Crea e collega una regola

The mechanics, annotated on screen: (1) il file — .claude/rules/nome.md; (2) lo scope — frontmatter paths:; (3) il collegamento — one @.claude/rules/nome.md line in CLAUDE.md for always-on rules, self-loading for scoped ones. "CLAUDE.md è l'indice, le regole sono i capitoli."

07demo 1c

Silent failure

La config sbagliata non urla: wrong key → ignored, 0 warnings; 1 line fixed → rule fires. Verify, don't trust.

La regola di tutti i progetti

Bridge: "mai lavorare direttamente su main" applies everywhere. So where does it live? There is a layer above the project.

Sezione B · Il livello globale · 2 slides

09demo 2

Tour di ~/.claude

Steps + prompt pill. You have used it for two weeks: global CLAUDE.md · settings.json · grill-me lives HERE, runs in every project.

Cosa va dove

Every project? → global. This work only? → project. Who you are / default permissions / universal vs project skills.

Sezione C · Skills che crescono · 8 slides

I 3 gradini (dal pre-work)

T1 istruzioni · T2 + script · T3 + script e file di supporto. Power only when the task earns it.

Script: cervello e mani

The litmus test: fatto due volte deve venire IDENTICO → script (nomi file con data, archiviazione, calcolo IVA). Due versioni buone possono differire → Claude. Example: 9 volte su 10 il nome è giusto, la decima è "report-14-luglio.md" — quel passo diventa script. You don't write code: you say which step must be exact.

13demo 3

Costruiamo la skill

Il report del venerdì, per sempre. All 5 steps + the verbatim transform-prompt pill. The fragile step goes to the script. /weekly-status live.

Anatomia di una tier-2

SKILL.md (instructions) + scripts/archive.sh (the exact step). L2's three habits can become gates inside the skill.

Tier 3: composizione

Concrete: /chiudi-installazione chiama /case-study + /post-linkedin + /testo-sito — one command, three assets, on the L2 project they know. Skills calling skills, now formalized.

Hook: un passo oltre

Script: code your skill calls. Hook: code that fires by itself, every time, with nobody remembering to call it.

17new v2

Skill vs Hook

Comparison table: Chi la attiva (tu / il sistema) · Quando (quando la chiami / a ogni evento) · Si può saltare? (sì / mai) · Serve per (fare un lavoro / impedire un errore). Analogy: skill = la procedura del pit-stop, hook = il limitatore di giri.

18demo 4

Regola vs hook

Steps + prompt pill. The written rule can slip. Commit to main → the hook blocks it. "La regola che continua a fallire diventa un hook."

Sezione D · Collegare i tool · 4 slides

MCP

Un file si legge. Un tool si usa. MCP = the plug that connects Claude to calendar, email, database.

20demo 5

Calendario collegato

Steps + prompt pill ("prepara il mio lunedì"). Il briefing del lunedì, dal vivo: connect flow shown live → tasks + real events.

Il gate: attrito ×2

Exercise pill: "quale tool ti ha fatto perdere tempo DUE volte?" Verdict together: yes / not yet. Most: not yet. Correct.

Il progetto madre

A central project the others consult: status, decisions, todos. How the global layer becomes YOUR way of working.

Sezione E · La cassetta degli attrezzi · 5 slides

23demo 6

Modelli e sforzo

Model = quale cervello (Haiku veloce · Sonnet quotidiano · Opus ragionamento profondo). Effort = quanto ci pensa prima di rispondere (basso = rapido, alto = accurato). /model live + default in settings.json (you saw the line).

24demo 6

Contesto e compact

Context fills up → /compact summarizes and frees space. Details fade, FILES remain. Plus: where to see your usage.

25demo 6

Git nel loop

"Committa la fase 1" → Claude runs git. Every closed phase = a restore point. No commands memorized.

26demo 6

Live Server

VS Code extension: the browser updates by itself while Claude edits the files.

Provalo, non guardarlo

"Sembra giusto" is not enough: ask Claude to prove it. Taste today, full method in L4.

Chiusura · 3 slides

Il cerchio si chiude

errore → regola → skill → hook. Every correction made once. The system improves every week.

Cosa vi portate a casa

✓ 1 real rule (created AND linked) ✓ 1 tier-2 skill ✓ ~/.claude configured ✓ the MCP gate ✓ models+effort, context, git, testing

L4: capstone + Q&A

Bring what you shipped. Trusting output · testing · the project map. Q&A 10–15 min.

6 · Sources per block

Content	Guide / source
Canonical L3 scope	curriculum/outline.md v1.6 · curriculum/inventory.md T2-01…T2-11 · curriculum-canonical.md Week 3
13 confirmed live concepts	sessions/lesson-3-skills-rules-mcps/planning-notes.md (Raffa-Giuse brainstorm Jul 8/9)
Skill tiers + scripts vocabulary	3-l3-preview.md (participant prework, binding wording) + docs/raw/2026-06-30-skill-taxonomy-screenshots.md
Rules→hooks loop, scripts framing, global-vs-project tiers	Agentic map: map/lessons.md Lessons 28, 33/34, 38, 55 · full-map.md tier model
Silent-failure rules demo	curriculum/inventory.md T2-07
Self-audit	inventory T2-08
MCP friction-twice gate	Decision D3a, docs/raffaello-call-decisions.md · inventory T2-04
Demo design standard (Setup/Action/Proof)	/curriculum-demo-audit skill (purpose-built for this workshop)
What NOT to teach (no swarms; one hand-made hook)	agentic-map evaluations: kieran-folder-as-agent.md · builder-checker-loop.md
Deck format	slides-l2.html design system + 3 patterns from the ai-literacy-bootcamp deck fork
What L1/L2 already taught	lesson-1-essentials/live-agenda.md · lesson-2-build-a-feature/outline.md + slides

7 · Decisions — ALL RESOLVED (Giuseppe, Jul 14)

1. Hooks placement — ✅ REVISED (Giuseppe, Jul 14 evening): BONUS slides at the end (deck 29–31), run only if ahead of schedule or as a Q&A answer — matching Raffaello's original position. The concept keeps 10 seconds inside the compounding close; the practice is L4.

2. Demo MCP — ✅ Gmail (revised Jul 14 on Raffaello's feedback; was Google Calendar, which stays as tested plan-B). Buffer/LinkedIn scheduling: cohort-2 candidate via its API (no MCP) — and the named example in the new MCP-vs-API beat on slide 19.

3. Pre-L3 send — ✅ confirmed sent. The live session can assume participants have the T1/T2/T3 skill-tier vocabulary.

5 (new, Jul 14). Demo 3 centerpiece — ✅ /pubblica-installazione per Raffaello's design (via Zeno): validate → generate → check → archive, recipe/chef frame, "one AI step out of four", transfer question. Replaces /weekly-status.

4. Demo project — ✅ the L2 Essedi marketing asset generator (sessions/lesson-2-build-a-feature/demo/) for all six demos. Seeding required (bloated CLAUDE.md, broken globs: rule, 2–3 installation briefs, pre-built /chiudi-installazione) — in the demo-assets build step.

Status: plan approved → build started on branch giuseppe/l3-live-session: live-agenda.md → slides-l3.html (30) → demo assets → outline.md → instructor-notes.md → /curriculum-demo-audit + Italian gate.

L3 Live Session PlanSkills, Rules & MCPs