# techygarg-lattice-composable-ai-skills-atoms-molecules-refiners-2026-05-05

## Veille

Repository GitHub `techygarg/lattice` che formalizza un framework di **skill componibili** per installare una *disciplina ingegneristica* negli assistenti di coding AI (Claude Code, Cursor). Architettura distintiva a tre livelli: **Atoms** (guardrail a principio singolo: clean code, DDD, sicurezza, qualità dei test, design-first), **Molecules** (workflow multi-step che compongono gli atoms: design, implement, refactor, fix, review), **Refiners** (interviste guidate che producono standard specifici del progetto che personalizzano il comportamento degli atoms). Pipeline operativa `lattice-init` → `design-blueprint` → `code-forge` → `review`, con `refactor-safely` e `bug-fix` come ramificazioni. Tre principi cardine: *"Skills over prompts"*, *"Composability over monoliths"*, ***"Living context over static config"*** — la cartella `.lattice/` diventa più intelligente a ogni ciclo di feature. MIT, puro shell, 18 stelle / 52 commit, una serie di articoli su martinfowler.com che spiegano cinque *collaboration patterns*. Forte convergenza con Vincent *Superpowers* (2026-04-02), Habert *PROJ-AI* (2026-05-05), Wescale *Usine Logicielle Augmentée* (2026-05-03), e — la convergenza dottrinale più alta senza filiazione dichiarata — **Compound Engineering** di Every (Shipper/Klaassen 2025-12-11): pipeline isomorfe (lattice-init→design-blueprint→code-forge→review ↔ ce:brainstorm→ce:plan→ce:work→ce:review), livello di contesto vivente (`.lattice/` ↔ `docs/plans/+solutions/+brainstorms/`), una comune postura design-first, review obbligatoria a fine pipeline. La dottrina 2026 del *coding agent harness* converge su un vocabolario stabile, senza influenza diretta.

## Titre Article

Lattice — Composable AI skills that teach assistants structured thinking (design-first, context-aware, architecture-guided)

## Date

2026-05-05

## URL

https://github.com/techygarg/lattice

## Keywords

lattice, techygarg, composable AI skills, engineering discipline, AI coding assistant framework, Claude Code plugin, Cursor compatible, three-tier architecture, atoms guardrails, molecules workflows, refiners interview-driven, lattice-init, design-blueprint, code-forge, review, refactor-safely, bug-fix, .lattice folder, living context layer, skills over prompts, composability over monoliths, living context over static config, design-first methodology, five-level progressive design, DDD secure coding test quality, project-specific standards, versioned skill files, team-owned skills, single-purpose skills, multi-step workflows, martinfowler.com five collaboration patterns, MIT license, shell installation, marketplace plugin

## Authors

techygarg (auteur GitHub, identité réelle non précisée dans le README ; auteur d'une série d'articles publiée sur martinfowler.com).

## Ton

**Profilo**: Un repository GitHub per un framework di skill opinionato destinato agli agenti di coding, con un README denso e strutturato che funge simultaneamente da pitch di prodotto, documentazione architetturale e manifesto filosofico. L'autore (techygarg) non si presenta attraverso credenziali istituzionali ma attraverso la qualità del framework e la pubblicazione di una serie di articoli su **martinfowler.com** — una rete che include Böckeler (*Harness engineering for coding agent users*, 2026-04-02) e Fowler stesso (*Thoughtworks Retreat*, 2026-02-13). Pubblico target: tech lead e engineering manager che vogliono installare standard inviolabili nei propri team usando Claude Code/Cursor, oltre alla comunità open-source dei plugin Claude Code.

**Stile**: Una voce prescrittivo-manifesto, un registro tech-editoriale ad alta densità concettuale. Tre scelte editoriali degne di nota:

1. **Una diagnosi breve e diretta**: *"AI coding assistants jump straight to code, silently make design decisions, forget constraints mid-conversation, and produce output nobody reviewed against real standards."* Quattro verbi, quattro disfunzioni canoniche. Nessun hype, nessuna promessa — una constatazione di fatto.

2. **Una triade concettuale**: *Atoms / Molecules / Refiners* è un prestito deliberato dalla chimica organica applicato all'ingegneria del software. È memorabile, è scalabile (principio singolo → workflow → personalizzazione), e stabilisce una grammatica di composizione. Un vocabolario strutturante.

3. **Tre principi-aforismi**: *"Skills over prompts"*, *"Composability over monoliths"*, *"Living context over static config"*. Un formato Strunk & White per il manifesto tech — ogni principio è un'opposizione binaria che prende posizione.

**Metafore elaborate**: *"living context layer"* per la cartella `.lattice/` che *"diventa più intelligente attraverso i cicli di feature"* (memoria di progetto che si accumula), *"engineering discipline installed into any AI coding assistant"* (l'ingegneria come *postura* da imporre all'assistente). Nessuna emozione forzata, nessuna urgenza artificiale, ma un'autorevolezza strutturata dalla coerenza del framework.

**Autorevolezza**: costruita da (a) il rigore architetturale (tre livelli espliciti, pipeline nominata), (b) la pubblicazione associata su martinfowler.com (una rete anglosassone, fluente in Thoughtworks), (c) l'operatività immediata (plugin Claude Code installabile + script locale), (d) la licenza MIT e il codice puro shell (trasparenza e adozione senza attrito). Un progetto piccolo (18 stelle / 52 commit) ma un posizionamento maturo — questa è dottrina impacchettata, non un side project affrettato.

## Pense-betes

- **Fonte**: repository GitHub `techygarg/lattice` (https://github.com/techygarg/lattice). Licenza MIT, **18 stelle / 0 fork / 52 commit** (istantanea maggio 2026), codice 100% shell.
- **Data di aggiunta alla cartella di veille**: 2026-05-05 (URL inviato via condivisione mobile). Il repository stesso non espone una data chiara nel README estratto — un progetto in corso, giovane, ma dottrinalmente compiuto.
- **Autore**: `techygarg` — identità reale non documentata nel README; firma una serie di articoli su **martinfowler.com** che spiegano cinque *collaboration patterns* sottostanti.
- **Tagline**: *"Install engineering discipline into any AI coding assistant"* / *"Composable AI skills that teach assistants structured thinking — design-first, context-aware, and architecture-guided."*
- **Diagnosi iniziale**: *"AI coding assistants jump straight to code, silently make design decisions, forget constraints mid-conversation, and produce output nobody reviewed against real standards."* — quattro disfunzioni canoniche dell'agente nel 2026.
- **Tre principi cardine**: 1. **Skills over prompts** — file di skill versionati, di proprietà del team, nel repository > prompt personali su macchine individuali. 2. **Composability over monoliths** — skill combinabili a scopo singolo > documenti di istruzioni esaustivi. 3. **Living context over static config** — la cartella `.lattice/` *"diventa più intelligente attraverso i cicli di feature"* (memoria che si accumula man mano che le feature vengono rilasciate).
- **Architettura a tre livelli (originalità concettuale chiave)**: | Livello | Funzione | Copre | |------|----------|--------| | **Atoms** | Guardrail a principio singolo | Clean code, architettura, DDD, secure coding, qualità dei test, approccio design-first | | **Molecules** | Workflow multi-step che compongono gli atoms | Design, implement, refactor, fix, review | | **Refiners** | Interviste guidate che producono standard specifici del progetto | Personalizzano il comportamento degli atoms per un team / un repository |
- **Pipeline canonica**: `lattice-init` → `design-blueprint` → `code-forge` → `review` (sequenza principale, design-first), con `refactor-safely` e `bug-fix` come ramificazioni per il lavoro strutturale e difensivo.
- **Cinque comandi/skill principali**:
- `/lattice-init` — scansione del progetto + configurazione iniziale
- `/design-blueprint` — **approccio di design progressivo a cinque livelli** (design prima del codice)
- `/code-forge` — implementazione che applica gli standard di qualità
- `/review` — audit delle modifiche + persistenza degli insight in `.lattice/`
- `/refactor-safely` — rilavorazione strutturale guidata
- `/bug-fix` — workflow guidato dal difetto
- **Livello di contesto vivente (`.lattice/`)**: una cartella che accumula **standard di progetto, decisioni, insight di review** man mano che le feature vengono rilasciate. È l'equivalente di `DOCTRINE/` + `DR/` di Habert PROJ-AI, o di un `CLAUDE.md`/`AGENTS.md` arricchito con pattern appresi.
- **Installazione**:
- **Plugin Claude Code**: `/plugins marketplace add techygarg/lattice` → `/plugins install lattice` → `/reload-plugins`. Compatibile con Cursor.
- **Locale**: `git clone https://github.com/techygarg/lattice.git` poi `./tools/install.sh /absolute/path/to/your/skills/folder`.
- **Documentazione associata**: Origin Story, How It Works, Practical Guide, Configuration Reference, Framework Intelligence, Collaborative Judgment + una serie di articoli su **martinfowler.com** sui **cinque collaboration pattern** sottostanti (rete Böckeler/Fowler/Thoughtworks).
- **Posizionamento nella cartella di veille (alta densità di convergenza)**:
- **Famiglia immediata (framework di skill per agenti di coding, 2026)**:
- **Vincent *Superpowers*** (2026-04-02): framework di Skills agentiche con SKILL.md, TDD rigoroso, brainstorming. Lattice = stessa categoria, ma spinge oltre sulla **composizione formale** (atoms→molecules→refiners) e sul **design-first** esplicito.
- **Anthropic *Skills*** (2025-10-16, Willison 2025-10-16): annuncio ufficiale delle Claude Skills. Lattice è un'implementazione opinionata di questa primitiva.
- **Karpathy *Skills for Claude Code*** (2026-01-27): 4 principi anti-bloat. Lattice converge sulla semplicità e sull'anti-monolitismo (*"composability over monoliths"*).
- **Curran *Skills-Based Plugin Architecture*** (2026-04-16): Intercom, marketplace privato con 153 contributori / 267 skill. Lattice = un equivalente open-source individuale di un marketplace di skill, ma con un'**architettura imposta** (Atoms/Molecules/Refiners).
- **Habert WEnvision PROJ-AI*** (2026-05-05): repo+agente+dottrina, sei zone. Lattice condivide la stessa tesi *living context > static config* ma si orienta verso la **produzione software** piuttosto che verso la **gestione di progetto**.
- **Wescale Usine Logicielle Augmentée** (2026-05-03): 6 linee di produzione, governance iniettata. Lattice = l'equivalente open-source che si installa come plugin Claude Code, mentre Wescale è una metodologia erogata tramite consulenza.
- **Compound Engineering — Every** (Shipper/Klaassen 2025-12-11, Chow 2026-03-31, Every GitHub plugin 2025-12-10, Shipper *AI-native company* 2025-11-23): la **convergenza dottrinale più forte** del corpus con Lattice — senza filiazione dichiarata in nessuna delle due direzioni.
- **Pipeline isomorfe**: Lattice `lattice-init → design-blueprint → code-forge → review` ↔ CE `ce:brainstorm → ce:plan → ce:work → ce:review` (+ loop `compound`).
- **Livello di contesto vivente**: Lattice `.lattice/` ↔ CE `docs/plans/`, `docs/solutions/`, `docs/brainstorms/` (gli stessi artefatti viventi che si accumulano man mano che le feature vengono rilasciate).
- **I tre principi di Lattice ↔ le tre scelte dottrinali di CE**: *Skills over prompts* ↔ slash-command versionati; *Composability over monoliths* ↔ subagenti specializzati (12 reviewer ce:review); *Living context over static config* ↔ docs/plans come documenti viventi.
- **Postura design-first condivisa**: i 5 livelli di `/design-blueprint` ↔ Klaassen *Stop Coding and Start Planning* (2025-11-06) *tre fedeltà*.
- **Review a fine pipeline**: Lattice `/review` ↔ CE `ce:review` (12 reviewer, confidence scoring, coda di fixer).
- **Distinzioni**: (1) Lattice impone una **tipologia formale** (Atoms/Molecules/Refiners) assente in CE, che è più *piatta*; (2) CE è portata da un'**organizzazione media** (Every) che ne fa un prodotto editoriale vendibile, Lattice è open-source individuale; (3) **Maturità asimmetrica**: CE alla v2.60.0 con un plugin marketplace e adozione settimanale documentata (Every Source Code), Lattice a 18 stelle / 52 commit; (4) **Reti editoriali distinte** — martinfowler.com/Thoughtworks (Lattice) vs Every (CE).
- **Lettura**: entrambi i framework sono **convergenze indipendenti** sulle primitive che nel 2026 stanno diventando standard per disciplinare gli agenti di coding. La somiglianza superficiale (slash-command, pipeline a 4 step, doc viventi, review obbligatoria) è il **vocabolario stabile** che sta emergendo — non un'influenza diretta.
- **Famiglia teorica (harness engineering)**:
- **Trivedy *Anatomy of an Agent Harness*** (2026-03-10): Agent = Model + Harness, 7 primitive. Lattice = un harness operativo concreto che implementa diverse primitive.
- **Osmani *Agent Harness Engineering*** (2026-04-19): equazione e 7 primitive consolidate, *AGENTS.md "pilot's checklist"*. Lattice si inserisce in questa dottrina.
- **Böckeler *Harness engineering for coding agent users*** (2026-04-02, martinfowler.com): guide feedforward, sensori feedback. **Stessa rete editoriale** di Lattice (martinfowler.com).
- **Seale *Semantic Agent: (Model+Harness) + (Ontology+Data)*** (2026-04-17): estende l'equazione dell'harness con l'ontologia. Lattice = la faccia operativa design-first + composizione.
- **Famiglia design-first / specifiche**:
- **Osmani *How to write a good spec for AI agents*** (2026-01-13): 5 principi per le specifiche, Plan Mode. Lattice rende il design-first un *livello 0* obbligatorio.
- **Klaassen *Stop Coding and Start Planning*** (2025-11-06): compounding engineering, tre fedeltà. Lattice converge.
- **Connessione martinfowler.com**: Lattice si inserisce nella rete che include **Böckeler** (aprile 2026), **Fowler** (*Thoughtworks Retreat*, 2026-02-13). È una rete anglosassone, fluente in Thoughtworks, che stabilisce il vocabolario di riferimento per la *disciplina degli agenti di coding* nel 2026.
- **Limiti da segnalare**:
- **Repository piccolo** (18 stelle / 52 commit) — non ancora validato tramite adozione massiva come Superpowers (130k+ stelle).
- **Codice 100% shell** — installazione semplice ma lock-in operativo all'ambiente Claude Code/Cursor.
- **Documentazione densa ma recente** — la maturità sul campo di Atoms/Molecules/Refiners deve ancora essere dimostrata nella pratica.
- **Autore con poca identificazione istituzionale** — autorevolezza costruita dal framework stesso + dalla connessione con martinfowler.com, ma nessuna credenziale pubblica evidente.
- **Utile per**: progettare l'architettura di una cartella `.skills/` interna per un team Claude Code; un confronto side-by-side con Vincent *Superpowers* e Habert *PROJ-AI* in una presentazione executive; un riferimento in un dossier francese di *harness engineering* che confronta approcci FR (PROJ-AI, Wescale) vs anglosassoni (Lattice, Superpowers).

## RésuméDe400mots

`techygarg/lattice` è un framework open-source MIT di skill componibili progettato per *"installare una disciplina ingegneristica in qualsiasi assistente di coding AI"* (Claude Code, Cursor). Il repository espone una diagnosi concisa: *"Gli assistenti AI passano direttamente al codice, prendono silenziosamente decisioni di design, dimenticano i vincoli a metà conversazione e producono codice che nessuno rivede rispetto a standard reali."*

Lattice affronta il problema con tre principi-aforismi: **Skills over prompts** (file di skill versionati, di proprietà del team > prompt personali), **Composability over monoliths** (skill componibili a scopo singolo > documenti esaustivi), **Living context over static config** (la cartella `.lattice/` *"diventa più intelligente attraverso i cicli di feature"*).

L'originalità concettuale risiede nell'**architettura a tre livelli**:
- **Atoms**: guardrail a principio singolo che coprono clean code, architettura, DDD, secure coding, qualità dei test, design-first.
- **Molecules**: workflow multi-step che compongono gli atoms — design, implement, refactor, fix, review.
- **Refiners**: interviste guidate che producono standard specifici del progetto, personalizzando il comportamento degli atoms per un dato team.

La pipeline canonica sequenzia `lattice-init` → `design-blueprint` → `code-forge` → `review`, con `refactor-safely` e `bug-fix` come ramificazioni. Il comando `/design-blueprint` impone un *approccio di design progressivo a cinque livelli* — il design-first come convenzione non negoziabile. La cartella `.lattice/` accumula *standard di progetto, decisioni, insight di review* come memoria vivente del progetto.

L'installazione avviene tramite un plugin Claude Code (`/plugins marketplace add techygarg/lattice`) compatibile con Cursor, oppure tramite clone + lo script shell `install.sh`. Una documentazione densa (Origin Story, How It Works, Practical Guide, Configuration Reference, Framework Intelligence, Collaborative Judgment) estesa da una **serie di articoli su martinfowler.com** su cinque *collaboration patterns* — la stessa rete editoriale di **Böckeler** (*Harness engineering for coding agent users*, 2026-04-02) e **Fowler** (*Thoughtworks Retreat*, 2026-02-13).

Lattice si inserisce nella **convergenza dottrinale 2026** dei framework di skill per agenti di coding, accanto a Vincent *Superpowers* (2026-04-02), Anthropic *Skills* (2025-10-16), Curran *Skills-Based Plugin Architecture* (Intercom 2026-04-16), Habert *PROJ-AI* (WEnvision 2026-05-05), Wescale *Usine Logicielle Augmentée* (2026-05-03) e — la convergenza più forte del corpus senza filiazione dichiarata — **Compound Engineering** (Every, Shipper/Klaassen 2025-12-11): pipeline isomorfe (`lattice-init → design-blueprint → code-forge → review` ↔ `ce:brainstorm → ce:plan → ce:work → ce:review`), livello di contesto vivente (`.lattice/` ↔ `docs/plans/+solutions/+brainstorms/`), i tre principi di Lattice mappabili su tre scelte dottrinali di CE. Rispetto a Vincent (130k+ stelle, maturo), Lattice (18 stelle) offre un'**architettura più formale** (atoms/molecules/refiners) e una postura **design-first esplicita** come livello zero.

Limiti: repository ancora giovane, nessuna validazione consolidata tramite adozione massiva, l'autore ha poca documentazione istituzionale, il codice è 100% shell. Ma il posizionamento è maturo: si tratta di dottrina impacchettata e installabile come plugin, non di un prototipo affrettato. Un riferimento utile per confrontare le architetture di skill tra gli approcci FR (PROJ-AI, Wescale) e quelli anglosassoni (Lattice, Superpowers).

## GrapheDeConnaissance

- techygarg —a_créé→ Lattice (TECHNOLOGIE, 0.97)
- Lattice —est_instance_de→ framework de skills composables (CONCEPT, 0.97)
- Lattice —s_applique_à→ Claude Code et Cursor (TECHNOLOGIE, 0.96)
- Lattice —est_basé_sur→ Architecture trois-tiers Lattice (CONCEPT, 0.97)
- Atoms (Lattice) —est_instance_de→ guardrails mono-principe (CONCEPT, 0.96)
- Molecules (Lattice) —utilise→ Atoms (Lattice) (CONCEPT, 0.96)
- Refiners (Lattice) —affine→ Atoms (Lattice) (CONCEPT, 0.95)
- Pipeline Lattice —est_basé_sur→ Pipeline Lattice (CONCEPT, 0.96)
- .lattice folder —est_instance_de→ living context layer projet (CONCEPT, 0.96)
- techygarg —publie→ série d'articles sur martinfowler.com (DOCUMENT, 0.93)
- Lattice —utilise→ design-first progressive approach (5 niveaux, imposé) (METHODOLOGIE, 0.94)
- Lattice —affirme_que→ "Skills over prompts" (CITATION, 0.97)
- Lattice —affirme_que→ "Composability over monoliths" (CITATION, 0.97)
- Lattice —affirme_que→ "Living context over static config" (CITATION, 0.97)
- Lattice —utilise→ licence MIT (CONCEPT, 0.97)
- Lattice —fait_partie_de→ Famille skills frameworks 2026 (CONCEPT, 0.94)
- Lattice —converge_avec→ Superpowers (Vincent) (TECHNOLOGIE, 0.92)
- Lattice —converge_avec→ PROJ-AI (Habert WEnvision) (METHODOLOGIE, 0.91)
- Lattice —converge_avec→ Convergence Lattice ↔ Compound Engineering (METHODOLOGIE, 0.93)
- Pipeline Lattice —converge_avec→ pipeline ce:brainstorm → ce:plan → ce:work → ce:review (isomorphisme) (METHODOLOGIE, 0.91)
- .lattice folder —converge_avec→ docs/plans + docs/solutions + docs/brainstorms (CE, isomorphisme) (TECHNOLOGIE, 0.9)
- Lattice —fait_partie_de→ réseau éditorial martinfowler.com (ORGANISATION, 0.89)

---
Canonical: https://www.thekb.eu/it/fiches/techygarg-lattice-composable-ai-skills-atoms-molecules-refiners-2026-05-05/