Canon A design practice that publishes.

Overview

Designers have started handing instructions to AI agents: plugin files that tell Claude, Cursor, or Codex how to think about motion, accessibility, or typography. Finding good ones means trawling GitHub. Canon started as the editorial answer, hand-picked, license-verified, and written up with a point of view. Since then it has become a practice that ships its own tools and logs its decisions in public.

I built it because I kept re-explaining the same judgment to the same tools. An agent will happily animate everything, ship a 32px tap target, or invent a fifth grey, and it will do it fast. The fix is not more prompting, it is encoding the decision once and handing it over. That is what these plugins are, and once they exist they are worth sharing rather than hoarding.

What a plugin actually enforces

• A gate before the animation

  The motion plugin asks whether the thing should animate at all before it asks how. Most of the time the answer is no, and that question is the part people skip.

• Hit areas and keyboard paths, checked before ship

  The accessibility plugin holds the 44px minimum, real focus states, and a working tab order. It flags them while the work is in progress, not after somebody complains.

• The brand, encoded once

  The brand plugin carries the actual palette, type scale, and logo rules, so every later pass inherits them instead of improvising a near-miss.

As of October 2026

The problem

Act I
Curate

The founding rule, from Canon's decision log: curate, never scrape. Judgment is the product; a scraped list is the competitor category, not the aspiration. Every entry is read in full, license-checked, and given an original write-up with an honest gotcha section.

Four things no other directory does

• Structure maps

  An interactive diagram of every skill's actual file tree and internal outline, generated from the real GitHub repo, so you can see what you are installing before you install it.

• Kits

  Skills composed for a job: a full redesign, a marketing site, a product UI, a mobile review. Each one phased in working order, with a generated one-command install script and a portable digest for tools that cannot run skills natively.

• An editorial voice

  Ratings that mean something, and entries I turned down for not being good enough.

• One-command install

  The catalog ships as a Claude Code plugin: add the marketplace once and a router skill comes with it. The router stays dormant until called, reads the task, and pulls in the kit that applies. The marketplace now carries four plugins: the router and three tools Canon authored, covered in Act II.

Licenses are facts, not vibes

Two of the log's earliest rulings are about permission. The license field is derived from the GitHub API, never hand-typed, because a hand-typed claim shipped wrong exactly once. And a skill with no license is hidden everywhere, not just unlisted: no page, no listing, no generated install command. A hidden card with a live clone script would be compliance theater. Reversal is one status field the moment a license lands.

Monochrome, by ruling

Dogfooding

Built like it preaches

The site is data, not pages. A skill entry, abbreviated:

slug: design-motion-principles
name: Design Motion Principles
tagline: >-
  Three named motion philosophies, weighted by project context,
  with a frequency gate that decides whether it should animate at all.
sourceUrl: https://github.com/kylezantos/design-motion-principles
sourceAuthor: Kyle Zantos
tools: [claude-code, cursor, generic]
categories: [motion]
rating: 5
lastVerified: 2026-08-11
fileTree:                 # generated from the real repo
  - path: SKILL.md
    type: file
  - path: references/emil-kowalski.md
    type: file
contentOutline:           # parsed from the skill's own headings
  - title: The Frequency Gate
    subsections: [Duration Guidelines, The Golden Rule]

And a kit, which is just composition with reasons attached:

slug: full-redesign
name: Full Redesign
tagline: Brand foundation through pre-ship audits, the long arc, in working order.
phases:
  - title: Brand foundation
    entries:
      - skill: brand-guidelines
        why: Encode the real palette, type, and logo rules once so every
             later pass inherits them instead of improvising.
      - skill: frontend-design
        why: Forces a named point of view before pixels.
  - title: Pre-ship audits
    entries:
      - skill: better-accessibility
        why: Keyboard paths and hit areas checked before launch, not after
             a complaint.
digestPath: /kits/full-redesign-digest.md

Act II
Author

Reading twenty skills closely teaches you what a good one looks like. In August the positioning moved, in the log's words, from aggregator to practice that publishes. Canon's own skills are labeled as Canon's, never slipped in as peers of the curated work.

canon

The router. Reads the task, pulls in the kit that applies, stays dormant until called.

graft

Maps an agent session as branches: trunk, forks, compactions. A live prototype runs at jamesmadson.me/graft.

strata

A record of what users actually said, in layers. Verbatim kept apart from interpretation.

deter

Less, but better. A review that removes, and never an unrequested rewrite.

Graft, and its laws

Graft draws a session as it actually happened: the main thread as a trunk, subagents as forks, context compactions as diamonds. Its hard rules travel with it. A transcript is never read into context; parsing happens in a subprocess and only a summary returns. A map contains conversation excerpts, so a generated map is as private as the session it maps. And from the renderer spec now on its bench: truncate for display, never at the source.

Strata, and the evidence bar

Strata files feedback the way a researcher would, not the way a Slack scroll does. Said, meant, and decided stay separate, because verbatim, interpretation, and action are different epistemic states. Its hardest rule is the evidence bar: one is a quote, two is a possible pattern said aloud, three is a pattern. The same person twice is persistence, not pattern. Stakeholders never pool with users.

Add P-07 Add P-07 again Add P-12 Add P-31 Add S-02, a stakeholder Reset

Nothing filed yet.

Deter, and the removals

Deter reviews by taking away. Every finding is priced against the surface's job, one thing is kept and said out loud, at most one thing may be missing, and the unrequested rewrite, the baseline failure of AI reviews, is banned outright. Even its name follows a ruling: tribute names rendered exactly, so Rams is quoted as less, but better, and the rename from its earlier spelling got a redirect for a URL that was live for hours.

The act closes where it points next: the practice now logs every call it makes, with the rejected options kept visible. The log is itself becoming a skill that encodes how its author decides. Working name: Cairn, stones stacked to mark the route taken.

Act III
The workbench

Here is the second problem. Generation is solved; the mess it produces is not. Teams using AI to prototype now generate faster than they can track: branches nobody can find, Figma files nobody links, feedback in threads nobody can cite. Every tool in the audit ships opinions about making; nothing manages what got made.

Canon v2 is the answer the first two acts earned, and it fits in one sentence from the product brief: prototypes in one place, feedback that becomes evidence.

The aperture

The brief holds a wide horizon and a narrow build, in the log's words: the horizon can be wide; the build aperture cannot. The alpha is two jobs, a prototype manager and a feedback facilitator, plus a single skill run that tests whether reviews change real decisions. Everything else stays sequenced or held until the assumption ladder clears it.

References, not copies

Canon indexes and annotates; the work stays in GitHub and Figma. No code storage. That one ruling is the security story and the lean story at once, and it echoes how the gallery treats curated skills: point at the source, never redistribute it.

The riskiest assumptions, in build order

1. Teams will select which branches are prototypes when they connect a repo.
2. Feedback filed at the prototype beats feedback in Slack.
3. Skill runs on real prototypes produce findings a lead acts on.
4. A team will connect a private repo to a solo-maintained alpha.

Each alpha week answers one before the next layer gets built. These are open bets, and the page says so on purpose.

Changed in the open

The first version required teams to rename branches with a prototype prefix to be indexed. Superseded: connecting a repo now lists every branch and the person chooses what appears, because requiring a rename to be indexed is adoption friction dressed as tidiness. The log keeps the old decision visible beside the new one. The change of mind is data, not embarrassment.

The ledger

• Committed The annotation layer: one script tag, comments anchored to real page elements, each filing as Strata evidence.
• Sequenced Survey: space maps beside Graft's time maps, screens captured from the running prototype so the canvas cannot drift.
• Held Component promotion: a prototype-proven component scaffolds a PR into the team's own system. Held until the ladder clears it.
• Held Linear, both ways: issues in as evidence under full pseudonymization, reviews out as comments. A mention is a person triggering, so the no-surprise-runs rule holds.

The core model, from the brief:

Account (personal at alpha; teams are a later layer, not a rename)
 └─ Project
     ├─ Sources        a Git repo (read-only), a Figma file (by URL)
     ├─ Prototypes     selected branches, attached Figma frames
     ├─ Feedback       Strata entries: pseudonymized, Said/Meant/Decided
     ├─ Maps           Graft renders: branch history, session history
     └─ Reviews        skill runs against a prototype: deter, access

Plan

Strata evidence, the decision log

Build

Prototypes

Test

Review runs

Deploy

PR graduation

Maintain

Staleness flags, feeding Plan

The whole act answers to one principle, adopted into the log from Anthropic's AI-native SDLC playbook: every stage commits an artifact the next stage can read. Canon's own development already runs that cycle. This page was written from those artifacts, which is the only proof of the principle that counts.

How it decides

The log opens by extracting the pattern from its own entries. Five of the nine, verbatim in spirit:

• Field evidence before features

  Ideas arrive as links, get filed as entries, and graduate to scope only when the evidence bar clears.

• Honesty outranks polish

  Scripted-preview labels on every mock, counts said out loud. When a mechanism could mislead, it is removed rather than softened.

• Names carry the ethos

  One-word field terms, puns that work twice, attributions rendered exactly.

• Constrain before critique; remove before add

  The default question is what should go, and additions must survive being the single missing item.

• Change your mind in the open

  Supersede, never rewrite. The superseded call stays visible beside its replacement.

The full log, all thirty-five decisions with their rejections, is public in the Canon repo.

Open questions

The parts I have not settled, kept here on purpose:

• Where curation stops

  Twenty entries is still small enough to read everything. It will not stay that way, and curated stops meaning anything past some number I have not found yet.

• Whether people comment where the work lives

  The workbench bets that feedback filed at the prototype beats feedback in Slack. It is assumption two on the ladder, and it is genuinely untested.

• Whether trust arrives before track record

  Connecting a private repo to a solo-maintained alpha asks for real trust. Read-only scopes and a clean security story are the mitigation, not the proof.

• What happens when the format moves

  An open packaging standard is forming, backed by several of the big agent vendors. Betting on it early is either free portability or a rewrite.

Changelog

• Sep 2026 Graft renderer spec: output becomes a function of the input, and a decisions rail joins the map. Graft's skill gains its privacy rule.
• Aug 2026 The v2 PRD and the decision log: the workbench thesis, thirty-five decisions with their rejections kept visible.
• Aug 2026 Strata and Deter join Graft: three tools published under Canon's own name, four plugins in the marketplace.
• Aug 2026 Graft: the first Canon-authored skill, a session cartography tool with a live prototype at jamesmadson.me/graft.
• Aug 2026 Canon router: the catalog as an installable Claude Code plugin, one marketplace add, kits routed by task.
• Aug 2026 Kits: four curated bundles with generated install scripts.
• Aug 2026 Stripped the palette to monochrome; hover and focus now shift value, not hue.
• Aug 2026 Ran the site's own mobile-review skills against it; fixed twelve defects.
• Jul 2026 First eleven skills, structure maps, faceted gallery.

Still building. Acts I and II are shipped and live; Act III is a thesis with a ladder to climb, and the open questions above are genuinely open.

Browse Canon at jamesmadson.github.io/canon