Lattice: Composable Skills Framework for AI Coding Agents

Key takeaways

1. Source. GitHub repo techygarg/lattice (https://github.com/techygarg/lattice). MIT license, 18 stars / 0 forks / 52 commits (snapshot May 2026), code 100% shell.
2. 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.
3. Author. techygarg — real identity not documented in the README; signs a series of articles on martinfowler.com explaining five underlying collaboration patterns.
4. Tagline. "Install engineering discipline into any AI coding assistant" / "Composable AI skills that teach assistants structured thinking — design-first, context-aware, and architecture-guided."
5. 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.
6. 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).
7. 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 |
8. 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.
9. Five main commands / skills.
10. /lattice-init — project scanning + initial configuration
11. /design-blueprint — five-level progressive design approach (design before code)
12. /code-forge — implementation applying the quality standards
13. /review — auditing changes + persisting insights into .lattice/
14. /refactor-safely — guided structural rework
15. /bug-fix — defect-driven workflow
16. 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.
17. Installation.
18. Claude Code plugin. /plugins marketplace add techygarg/lattice → /plugins install lattice → /reload-plugins. Cursor compatible.
19. Local. git clone https://github.com/techygarg/lattice.git then ./tools/install.sh /absolute/path/to/your/skills/folder.
20. 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).
21. Positioning within the watch folder (high convergence density).
22. Immediate family (skills frameworks for coding agents, 2026).
23. 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.
24. Anthropic *Skills. * (2025-10-16, Willison 2025-10-16): official announcement of Claude Skills. Lattice is an opinionated implementation of this primitive.
25. Karpathy *Skills for Claude Code. (2026-01-27): 4 anti-bloat principles. Lattice converges on simplicity and anti-monolithism ("composability over monoliths"*).
26. 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).
27. 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.
28. 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.
29. 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.
30. Isomorphic pipelines. Lattice lattice-init → design-blueprint → code-forge → review ↔ CE ce:brainstorm → ce:plan → ce:work → ce:review (+ compound loop).
31. Living context layer. Lattice .lattice/ ↔ CE docs/plans/, docs/solutions/, docs/brainstorms/ (the same living artifacts that compound as features ship).
32. 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.
33. Shared design-first stance. /design-blueprint's 5 levels ↔ Klaassen Stop Coding and Start Planning (2025-11-06) three fidelities.
34. Review at pipeline exit. Lattice /review ↔ CE ce:review (12 reviewers, confidence scoring, fixer queue).
35. 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).
36. 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.
37. Theoretical family (harness engineering).
38. Trivedy *Anatomy of an Agent Harness. * (2026-03-10): Agent = Model + Harness, 7 primitives. Lattice = a concrete operational harness implementing several primitives.
39. Osmani *Agent Harness Engineering. (2026-04-19): equation and 7 consolidated primitives, AGENTS.md "pilot's checklist"*. Lattice fits within this doctrine.
40. Böckeler *Harness engineering for coding agent users. * (2026-04-02, martinfowler.com): feedforward guides, feedback sensors. Same editorial network as Lattice (martinfowler.com).
41. Seale *Semantic Agent: (Model+Harness) + (Ontology+Data). * (2026-04-17): extends the harness equation with ontology. Lattice = the operational design-first + composition facet.
42. Design-first / specs family.
43. 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*.
44. Klaassen *Stop Coding and Start Planning. * (2025-11-06): compounding engineering, three fidelities. Lattice converges.
45. 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.
46. Limitations to flag.
47. Small repo. (18 stars / 52 commits) — not yet validated through massive adoption like Superpowers (130k+ stars).
48. Code 100% shell. — simple installation but operational lock-in to the Claude Code/Cursor environment.
49. Dense but recent documentation. — the real-world maturity of Atoms/Molecules/Refiners has yet to be proven in the field.
50. Author with little institutional identification. — authority built by the framework itself + the martinfowler.com connection, but no obvious public credentials.
51. 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).