Skip to content
Docs

The intelligence system

The intelligence system is the design knowledge that ships with Denote and travels with every project. 34 knowledge files across 7 categories. 7 reasoning skills. 5 agent definitions. Together with the generated catalogs, they're the reasoning layer behind extraction, pattern recommendation, and the design specification.

Why it exists

A structure-first tool is only as good as the knowledge it brings to bear. Pattern recommendations are opinions. Governance rules encode judgment. Critique requires an aesthetic vocabulary. Without a coherent, editable knowledge base, every AI call reaches for a different source and the output drifts.

The intelligence system pins the knowledge in place. It's the source every skill and agent reads. When you run /ontology, the skill reads the same OOUX methodology file Claude Code will read later when it builds. The thinking and the building work from the same text.

What's in the system

Everything lives under intelligence/ inside your project directory and is copied there from Denote when the project is created.

  • Knowledge files (intelligence/knowledge/) — 34 Markdown files across 7 categories: design-systems, interaction-design, object-oriented-ux, philosophy, product-strategy, user-understanding, visual-design. Each is a focused treatment of a single topic. The layer commands declare which files they read.
  • Slash commands (.claude/commands/) — the invocation surface a designer types in the terminal: /vision, /ontology, /architecture, /screens, /spec. Each names the knowledge files and catalogs it reasons from.
  • Catalogs (intelligence/catalog/) — generated JSON exports of the system-level vocabularies: the 20 templates, 48 variants, content types, shell patterns, overlay patterns. The commands read these for canonical IDs.
  • Reasoning skills (intelligence/skills/) — 7 deeper methodology modules: object-model, flow-mapping, ia-audit, product-spec, critique, visual-critique, design-system-audit. Reference material you can wire into your own commands.
  • Agents (intelligence/agents/) — 5 agent definitions: Design Builder, Design Critic, Craft Lead, Product Strategist, UX Architect. Longer-form roles for orchestrated work.

Everything except the generated catalogs is plain Markdown. Open any file in a code editor, read it, understand exactly what Claude Code will do, edit it.

Two roles for the system

Inside Denote

When you work in a layer, the intelligence system powers the AI:

  • Ontology's entities, cues, and mental models come from the /ontology skill reading the entity-analysis, visual-cue, and mental-model knowledge files.
  • Architecture's level assignments and template picks come from the /architecture skill reading the information-architecture knowledge and the template catalogs.
  • Screens' shells, zone fills, and overlay rules come from the /screens skill reading the navigation-shell, surface-pattern, and spatial-system knowledge.

The AI in the app isn't freehanded. It's always grounded in the same knowledge files.

Inside Claude Code

When Claude Code builds, it reads the same knowledge files as project context. The project's CLAUDE.md points at intelligence/ and instructs Claude Code to follow the methodology and design system rules captured there.

The principles that guided the design now govern the implementation. The extraction methodology used to produce ontology.json is the same methodology Claude Code uses when it reasons about entities at build time. The visual hierarchy knowledge that drove Architecture's template picks is the same knowledge Claude Code uses when it chooses which element should be L1 focus on a screen.

The design thinking and the building literally read from the same files.

The system is editable

The default system is opinionated. You can agree or disagree. Either way, you can change it.

Every knowledge file, skill, and agent under intelligence/ is a Markdown file in your project directory:

  • Edit a knowledge file to change how a concept is described. Adjust the pattern catalog. Add a new pattern. Rewrite the critique rubric.
  • Edit a skill to change its inputs, outputs, or knowledge files. Add a new skill by dropping a Markdown file in intelligence/skills/.
  • Edit an agent to change how it orchestrates work. Add a new agent.

Edits persist. They affect both Denote (when you run the skill from the embedded terminal next time) and Claude Code (when it builds). No sync, no rebuild, no re-import. The files are the source of truth.

System-level vs project-level

The intelligence system ships with Denote as a starting point. When you create a project, Denote copies the current system into the project's intelligence/ folder. From that moment, the Markdown is yours.

  • Knowledge, skills, and agents are copied only if missing, so your edits survive every project open. They travel with the folder; they don't leak back into Denote's defaults.
  • Catalogs (intelligence/catalog/*.json) and the slash commands (.claude/commands/) are refreshed from Denote on every project open. They encode app behavior, not designer intent; customize the knowledge files instead.
  • System-level changes (Denote's own defaults) reach existing projects through that refresh for commands and catalogs, and reach only future projects for knowledge files.

The recipe example

The recipe portion calculator sample uses the default intelligence system as shipped. No edits.

  • /ontology loaded object-oriented-ux/entity-analysis.md, design-systems/visual-cue-library.md, user-understanding/mental-models.md, and design-systems/governance.md. Output (Recipe, Ingredient, Scaling Ratio) is what those knowledge files produce.
  • /architecture loaded interaction-design/information-architecture.md plus the template and variant catalogs. Fired the image-attribute visual cue on Recipe and assigned card_grid : with_filters for the browse screen. Directly traceable to the rules in those files.
  • Claude Code at build time reads the same knowledge files. Typography decisions on the detail screen follow typography-systems.md. Spatial decisions follow spatial-systems.md. The app and the knowledge files don't disagree — they're the same text.

[Screenshot TODO: file tree of intelligence/ showing the knowledge/, skills/, and agents/ subfolders with file names visible, rendered inside a code editor.]

How to think about editing the system

  • Start by reading, not editing. The defaults are opinionated. Understand the opinion first.
  • Edit when you disagree. If the critique rubric pushes back on a decision you know is right for your product, adjust the rubric.
  • Edit when you specialize. Add project-specific knowledge files for your domain (finance / dev tool / consumer utility all overlap differently).
  • Don't edit to remove opinions. An intelligence system without opinions is just a prompt. The whole point is that it takes a stance.

Where to next