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

## Veille

GitHub repo `techygarg/lattice` that formalizes a framework of **composable skills** for installing an *engineering discipline* into AI coding assistants (Claude Code, Cursor). Distinctive three-tier architecture: **Atoms** (single-principle guardrails: clean code, DDD, security, test quality, design-first), **Molecules** (multi-step workflows composing the atoms: design, implement, refactor, fix, review), **Refiners** (guided interviews producing project-specific standards that customize the atoms' behavior). Operational pipeline `lattice-init` → `design-blueprint` → `code-forge` → `review`, with `refactor-safely` and `bug-fix` as offshoots. Three pivotal principles: *"Skills over prompts"*, *"Composability over monoliths"*, ***"Living context over static config"*** — the `.lattice/` folder grows smarter with every feature cycle. MIT, pure shell, 18 stars / 52 commits, a series of articles on martinfowler.com explaining five *collaboration patterns*. Strong convergence with Vincent *Superpowers* (2026-04-02), Habert *PROJ-AI* (2026-05-05), Wescale *Usine Logicielle Augmentée* (2026-05-03), and — the highest doctrinal convergence with no declared lineage — **Compound Engineering** by Every (Shipper/Klaassen 2025-12-11): isomorphic pipelines (lattice-init→design-blueprint→code-forge→review ↔ ce:brainstorm→ce:plan→ce:work→ce:review), living context layer (`.lattice/` ↔ `docs/plans/+solutions/+brainstorms/`), a shared design-first stance, mandatory review at the end. 2026 *coding agent harness* doctrine converges on a stable vocabulary, without direct influence.

## 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

**Profile**: A GitHub repository for an opinion-driven skills framework for coding agents, with a dense, structured README that serves simultaneously as a product pitch, architecture documentation, and philosophical manifesto. The author (techygarg) does not present themselves through institutional credentials but through the quality of the framework and through publishing a series of articles on **martinfowler.com** — a network that includes Böckeler (*Harness engineering for coding agent users*, 2026-04-02) and Fowler himself (*Thoughtworks Retreat*, 2026-02-13). Target audience: tech leads and engineering managers who want to install inviolable standards in their teams using Claude Code/Cursor, plus the open-source community of Claude Code plugins.

**Style**: A prescriptive-manifesto voice, a tech-editorial register with high conceptual density. Three notable editorial choices:

1. **A short, blunt diagnosis**: *"AI coding assistants jump straight to code, silently make design decisions, forget constraints mid-conversation, and produce output nobody reviewed against real standards."* Four verbs, four canonical dysfunctions. No hype, no promise — a statement of fact.

2. **A conceptual triad**: *Atoms / Molecules / Refiners* is a deliberate borrowing from organic chemistry applied to software engineering. It is memorable, it scales (single principle → workflow → customization), and it establishes a grammar of composition. Structuring vocabulary.

3. **Three principle-aphorisms**: *"Skills over prompts"*, *"Composability over monoliths"*, *"Living context over static config"*. A Strunk & White format for the tech manifesto — each principle is a binary opposition that takes a stance.

**Worked metaphors**: *"living context layer"* for the `.lattice/` folder that *"grows smarter across feature cycles"* (project memory that compounds), *"engineering discipline installed into any AI coding assistant"* (engineering as a *posture* to impose on the assistant). No forced emotion, no manufactured urgency, but an authority structured by the framework's coherence.

**Authority**: built by (a) architectural rigor (explicit three-tier, named pipeline), (b) the associated publication on martinfowler.com (an Anglo-Saxon, Thoughtworks-fluent network), (c) immediate operability (installable Claude Code plugin + local script), (d) the MIT license and pure shell code (transparency and friction-free adoption). A small project (18 stars / 52 commits) but a mature positioning — this is packaged doctrine, not a hasty side project.

## Pense-betes

- **Source**: GitHub repo `techygarg/lattice` (https://github.com/techygarg/lattice). MIT license, **18 stars / 0 forks / 52 commits** (snapshot May 2026), code 100% shell.
- **Date added to the watch folder**: 2026-05-05 (URL submitted via mobile-share). The repo itself does not expose a clear date in the extracted README — an ongoing, young project, but doctrinally accomplished.
- **Author**: `techygarg` — real identity not documented in the README; signs a series of articles on **martinfowler.com** explaining five underlying *collaboration patterns*.
- **Tagline**: *"Install engineering discipline into any AI coding assistant"* / *"Composable AI skills that teach assistants structured thinking — design-first, context-aware, and architecture-guided."*
- **Opening diagnosis**: *"AI coding assistants jump straight to code, silently make design decisions, forget constraints mid-conversation, and produce output nobody reviewed against real standards."* — four canonical dysfunctions of the agent in 2026.
- **Three pivotal principles**: 1. **Skills over prompts** — versioned, team-owned skill files in the repo > personal prompts on individual machines. 2. **Composability over monoliths** — combinable single-purpose skills > exhaustive instruction documents. 3. **Living context over static config** — the `.lattice/` folder *"grows smarter across feature cycles"* (memory that compounds as features ship).
- **Three-tier architecture (key conceptual originality)**: | Tier | Function | Covers | |------|----------|--------| | **Atoms** | Single-principle guardrails | Clean code, architecture, DDD, secure coding, test quality, design-first approach | | **Molecules** | Multi-step workflows composing the atoms | Design, implement, refactor, fix, review | | **Refiners** | Guided interviews producing project-specific standards | Customize the atoms' behavior for a team / a repo |
- **Canonical pipeline**: `lattice-init` → `design-blueprint` → `code-forge` → `review` (main sequence, design-first), with `refactor-safely` and `bug-fix` as offshoots for structural and defensive work.
- **Five main commands / skills**:
- `/lattice-init` — project scanning + initial configuration
- `/design-blueprint` — **five-level progressive design approach** (design before code)
- `/code-forge` — implementation applying the quality standards
- `/review` — auditing changes + persisting insights into `.lattice/`
- `/refactor-safely` — guided structural rework
- `/bug-fix` — defect-driven workflow
- **Living context layer (`.lattice/`)**: a folder that accumulates **project standards, decisions, review insights** as features ship. It is the equivalent of Habert PROJ-AI's `DOCTRINE/` + `DR/`, or a `CLAUDE.md`/`AGENTS.md` enriched with learned patterns.
- **Installation**:
- **Claude Code plugin**: `/plugins marketplace add techygarg/lattice` → `/plugins install lattice` → `/reload-plugins`. Cursor compatible.
- **Local**: `git clone https://github.com/techygarg/lattice.git` then `./tools/install.sh /absolute/path/to/your/skills/folder`.
- **Associated documentation**: Origin Story, How It Works, Practical Guide, Configuration Reference, Framework Intelligence, Collaborative Judgment + a series of articles on **martinfowler.com** on the **five underlying collaboration patterns** (Böckeler/Fowler/Thoughtworks network).
- **Positioning within the watch folder (high convergence density)**:
- **Immediate family (skills frameworks for coding agents, 2026)**:
- **Vincent *Superpowers*** (2026-04-02): agentic Skills framework with SKILL.md, strict TDD, brainstorming. Lattice = same category, but pushes further on **formal composition** (atoms→molecules→refiners) and explicit **design-first**.
- **Anthropic *Skills*** (2025-10-16, Willison 2025-10-16): official announcement of Claude Skills. Lattice is an opinionated implementation of this primitive.
- **Karpathy *Skills for Claude Code*** (2026-01-27): 4 anti-bloat principles. Lattice converges on simplicity and anti-monolithism (*"composability over monoliths"*).
- **Curran *Skills-Based Plugin Architecture*** (2026-04-16): Intercom, private marketplace with 153 contributors / 267 skills. Lattice = an individual open-source equivalent of a skills marketplace, but with an **imposed architecture** (Atoms/Molecules/Refiners).
- **Habert WEnvision PROJ-AI*** (2026-05-05): repo+agent+doctrine, six zones. Lattice shares the same *living context > static config* thesis but orients toward **software production** rather than **project management**.
- **Wescale Usine Logicielle Augmentée** (2026-05-03): 6 production lines, injected governance. Lattice = the open-source equivalent one installs as a Claude Code plugin, whereas Wescale is a methodology delivered through consulting.
- **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): the **strongest doctrinal convergence** in the corpus with Lattice — with no declared lineage in either direction.
- **Isomorphic pipelines**: Lattice `lattice-init → design-blueprint → code-forge → review` ↔ CE `ce:brainstorm → ce:plan → ce:work → ce:review` (+ `compound` loop).
- **Living context layer**: Lattice `.lattice/` ↔ CE `docs/plans/`, `docs/solutions/`, `docs/brainstorms/` (the same living artifacts that compound as features ship).
- **Lattice's three principles ↔ CE's three doctrinal choices**: *Skills over prompts* ↔ versioned slash-commands; *Composability over monoliths* ↔ specialized subagents (12 ce:review reviewers); *Living context over static config* ↔ docs/plans as living documents.
- **Shared design-first stance**: `/design-blueprint`'s 5 levels ↔ Klaassen *Stop Coding and Start Planning* (2025-11-06) *three fidelities*.
- **Review at pipeline exit**: Lattice `/review` ↔ CE `ce:review` (12 reviewers, confidence scoring, fixer queue).
- **Distinctions**: (1) Lattice imposes a **formal typology** (Atoms/Molecules/Refiners) absent from CE, which is more *flat*; (2) CE is carried by a **media organization** (Every) that turns it into a sellable editorial product, Lattice is individual open-source; (3) **Asymmetric maturity**: CE at v2.60.0 with a marketplace plugin and weekly documented adoption (Every Source Code), Lattice at 18 stars / 52 commits; (4) **Distinct editorial networks** — martinfowler.com/Thoughtworks (Lattice) vs Every (CE).
- **Reading**: both frameworks are **independent convergences** on the primitives that are becoming standard in 2026 for disciplining coding agents. The surface similarity (slash-commands, 4-step pipeline, living docs, mandatory review) is the **stable vocabulary** that is emerging — not a direct influence.
- **Theoretical family (harness engineering)**:
- **Trivedy *Anatomy of an Agent Harness*** (2026-03-10): Agent = Model + Harness, 7 primitives. Lattice = a concrete operational harness implementing several primitives.
- **Osmani *Agent Harness Engineering*** (2026-04-19): equation and 7 consolidated primitives, *AGENTS.md "pilot's checklist"*. Lattice fits within this doctrine.
- **Böckeler *Harness engineering for coding agent users*** (2026-04-02, martinfowler.com): feedforward guides, feedback sensors. **Same editorial network** as Lattice (martinfowler.com).
- **Seale *Semantic Agent: (Model+Harness) + (Ontology+Data)*** (2026-04-17): extends the harness equation with ontology. Lattice = the operational design-first + composition facet.
- **Design-first / specs family**:
- **Osmani *How to write a good spec for AI agents*** (2026-01-13): 5 spec principles, Plan Mode. Lattice makes design-first a mandatory *level 0*.
- **Klaassen *Stop Coding and Start Planning*** (2025-11-06): compounding engineering, three fidelities. Lattice converges.
- **martinfowler.com connection**: Lattice fits within the network that includes **Böckeler** (April 2026), **Fowler** (*Thoughtworks Retreat*, 2026-02-13). It is an Anglo-Saxon, Thoughtworks-fluent network that sets the reference vocabulary for *coding agent discipline* in 2026.
- **Limitations to flag**:
- **Small repo** (18 stars / 52 commits) — not yet validated through massive adoption like Superpowers (130k+ stars).
- **Code 100% shell** — simple installation but operational lock-in to the Claude Code/Cursor environment.
- **Dense but recent documentation** — the real-world maturity of Atoms/Molecules/Refiners has yet to be proven in the field.
- **Author with little institutional identification** — authority built by the framework itself + the martinfowler.com connection, but no obvious public credentials.
- **Useful for**: designing an internal `.skills/` folder architecture for a Claude Code team; a side-by-side comparison with Vincent *Superpowers* and Habert *PROJ-AI* in an executive presentation; a reference in a French *harness engineering* dossier comparing FR approaches (PROJ-AI, Wescale) vs Anglo-Saxon ones (Lattice, Superpowers).

## RésuméDe400mots

`techygarg/lattice` is an open-source MIT framework of composable skills designed to *"install an engineering discipline into any AI coding assistant"* (Claude Code, Cursor). The repo lays out a concise diagnosis: *"AI assistants jump straight to code, silently make design decisions, forget constraints mid-conversation, and produce code that nobody reviews against real standards."*

Lattice addresses this with three principle-aphorisms: **Skills over prompts** (versioned, team-owned files > personal prompts), **Composability over monoliths** (composable single-purpose skills > exhaustive documents), **Living context over static config** (the `.lattice/` folder *"grows smarter across feature cycles"*).

The conceptual originality lies in the **three-tier architecture**:
- **Atoms**: single-principle guardrails covering clean code, architecture, DDD, secure coding, test quality, design-first.
- **Molecules**: multi-step workflows composing the atoms — design, implement, refactor, fix, review.
- **Refiners**: guided interviews producing project-specific standards that customize the atoms' behavior for a given team.

The canonical pipeline sequences `lattice-init` → `design-blueprint` → `code-forge` → `review`, with `refactor-safely` and `bug-fix` as offshoots. The `/design-blueprint` command imposes a *five-level progressive design approach* — design-first as a non-negotiable convention. The `.lattice/` folder accumulates *project standards, decisions, review insights* as the project's living memory.

Installation is either via a Claude Code plugin (`/plugins marketplace add techygarg/lattice`) compatible with Cursor, or via clone + the `install.sh` shell script. Dense documentation (Origin Story, How It Works, Practical Guide, Configuration Reference, Framework Intelligence, Collaborative Judgment) extended by a **series of articles on martinfowler.com** on five *collaboration patterns* — the same editorial network as **Böckeler** (*Harness engineering for coding agent users*, 2026-04-02) and **Fowler** (*Thoughtworks Retreat*, 2026-02-13).

Lattice fits within the **2026 doctrinal convergence** of skills frameworks for coding agents, alongside 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) and — the strongest convergence in the corpus with no declared lineage — **Compound Engineering** (Every, Shipper/Klaassen 2025-12-11): isomorphic pipelines (`lattice-init → design-blueprint → code-forge → review` ↔ `ce:brainstorm → ce:plan → ce:work → ce:review`), living context layer (`.lattice/` ↔ `docs/plans/+solutions/+brainstorms/`), Lattice's three principles mappable onto three CE doctrinal choices. Compared to Vincent (130k+ stars, mature), Lattice (18 stars) offers a **more formal architecture** (atoms/molecules/refiners) and an **explicit design-first** stance as level zero.

Limitations: still a young repo, no established validation through massive adoption, the author has little institutional documentation, code is 100% shell. But the positioning is mature: this is doctrine packaged and installable as a plugin, not a hasty prototype. A useful reference for comparing skills architectures between FR approaches (PROJ-AI, Wescale) and Anglo-Saxon ones (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/en/fiches/techygarg-lattice-composable-ai-skills-atoms-molecules-refiners-2026-05-05/