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 the slash commands invoke. 5 agent definitions that orchestrate longer tasks. Together they're the reasoning layer behind extraction, pattern recommendation, critique, 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. Every skill and agent declares which files it reads.
  • Skills (intelligence/skills/) — 7 reasoning skills: object-model, flow-mapping, ia-audit, product-spec, critique, visual-critique, design-system-audit. Each is a Markdown file with role, inputs, outputs, and required knowledge files.
  • Slash commands (.claude/commands/) — the invocation surface a designer types in the terminal: /vision, /ontology, /architecture, /screens, /spec, plus /critique for ad-hoc design review.
  • Agents (intelligence/agents/) — 5 agent definitions: Design Builder, Design Critic, Craft Lead, Product Strategist, UX Architect. Used when a single skill isn't enough.

All three layers are 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:

  • Vision sidebar's proposed items come from the /vision skill reading the vision knowledge files.
  • Architecture's template recommendations come from the /architecture skill reading the pattern catalog and governance principles.
  • Critique results come from the Design Critic agent reading the critique rubrics.

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 copy is yours.

  • System-level changes (edits to Denote-wide defaults) only affect projects created in the future. Existing projects keep the copy they were seeded with.
  • Project-level changes (edits to intelligence/ inside a specific project) only affect that project. They travel with the folder; they don't leak back into Denote's defaults.

The recipe example

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

  • /ontology loaded intelligence/knowledge/ooux-methodology.md + entity-modeling.md. Output (Recipe, Ingredient, ScalingRatio) is what those knowledge files produce.
  • /architecture loaded the pattern catalog + governance principles. 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