Skip to content
Docs

FAQ

Do I need Claude Code?

Yes. Denote is the thinking tool. Claude Code is the building tool. The embedded terminal inside Denote spawns a real Claude Code process, and every skill (/vision, /ontology, /architecture, /screens, /spec) runs through it. Without Claude Code installed and signed in, the terminal has nothing to talk to.

Install from the Anthropic install guide before or after installing Denote.

Is my design data stored in the cloud?

No. Denote writes files to the project directory on your local machine. Nothing is uploaded, synced, or shared by Denote itself.

The embedded terminal runs Claude Code, which makes API calls to Anthropic when the skills reason about your design. Those calls include whatever content is in the files the skill reads. See the Claude Code documentation for its data handling. Denote does not add any separate telemetry of design content.

Denote captures anonymous usage events (when a skill runs, which layer was opened, how long a session lasted) and error reports for reliability. None of it contains design content.

Can I use Denote without Claude Code?

Partially. You can open a project, edit the Vision sidebar, drag screens in Architecture, place chips in Screens, and everything you type is written to design/ as normal.

What you can't do without Claude Code is run the skills (/ontology, /architecture, /screens, etc.). Those depend on the embedded terminal. You can author every design file by hand if you prefer, but that's a harder path than letting the skills do the first pass.

Can I use a different AI model with Denote?

Not at the moment. The embedded terminal specifically runs Claude Code. Denote's skills are prompts written for Claude. Swapping the model would require a different terminal surface, different prompts, and different reasoning. Not on the roadmap.

Can I edit design files by hand?

Yes. Every file under design/ is human-readable JSON or Markdown with a documented schema. Edit them in any editor. Denote picks up changes the next time the relevant layer is opened.

Schemas are enforced on skill writes. Hand edits that violate a schema may be flagged the next time a skill reads the file. When in doubt, run the corresponding skill and let it correct the shape.

What if I skip a layer?

You can. The pipeline is a ladder, not a gate. Vision alone is enough to run /ontology. Ontology alone is enough to run /architecture. You can even run /spec with partial input; it'll write a design specification from whatever exists and note in a "Missing Design Data" section what would have improved it.

The further up the pipeline you've filled, the more of the structural decision is yours rather than the implementer's. That's the tradeoff.

What happens when I change an upstream layer?

The activity feed logs a "may be stale" hint: "Ontology changed. Architecture may be stale. Run /architecture to update." No dialog, no blocker. You decide when to re-run.

Renames propagate silently to references in downstream files. Deletes leave references dangling; the activity feed records what became dangling so you can clean up.

Can two people work on the same project?

Not through Denote directly. Denote is a single-user desktop app. Two designers can work on the same project folder by taking turns, or by using git (branches, pull requests, merges) the way two engineers would. The design files are small and diff cleanly.

Real-time collaboration inside Denote is not on the current roadmap.

Does Denote work offline?

The Denote app works offline. You can open a project, edit any layer, and write to design/. The embedded terminal will show Claude Code's normal behavior offline, which includes losing the ability to reach the Anthropic API. Skills that call the model will fail until the connection returns.

How do I share a project?

Send the folder. A Denote project is a self-contained directory with all of its design files, intelligence/, .claude/commands/, and CLAUDE.md inside. The recipient needs Denote (to use the UI) or just Claude Code (to build from the files). Either way, the project travels as a zip, a git repo, or a network share.

If the recipient has Claude Code but not Denote, they can still run the skills in a regular terminal. The slash commands work the same way.

What about styling, colors, and tokens?

Denote doesn't capture any of it. No color decisions, no token values, no type ramps, no spacing scales. The /spec output stays in structural design vocabulary: entities, templates, zones, visual cues like "has image → card with thumbnail".

The implementer, working in the target project, adapts the spec to whatever design system already lives there — shadcn defaults, an existing Tailwind theme, a tokens JSON, a Figma export, anything Claude Code can read. Styling lives where styling already lives. Denote stays a structure tool.

Can I change how a skill behaves?

Yes, at two levels.

  • Project-specific — edit the knowledge files under intelligence/ in the project directory. Those are yours and travel with the project.
  • Denote-wide — edit Denote's own intelligence/ and .claude/commands/ directories before creating the project. New projects are seeded from the current state of Denote's source.

See Writing your own intelligence.

What happens when I rename an entity?

Renames propagate to every file that references the entity by ID (or by name, when references are name-based). Entity references in ontology.json (relationships, persona ownership, task entityIds), screen-related references in architecture.json, and composition references in screens.json all update silently.

You may still need to run the downstream skill when a rename changes the meaning of the entity significantly, not just its label.

What happens if I delete an entity?

The entity is deleted. References to it in downstream files are left dangling. The activity feed logs what became dangling so you can decide whether to remove the references by hand or re-run the downstream skill to clean up.

This is deliberate. Silent deletion across layers would destroy design decisions you might have meant to keep (a screen's template + variant might still be useful, just attached to a retired entity). Leaving references and flagging them gives you the chance to save the decision or discard it.

Can I undo a skill run?

Denote doesn't ship an undo stack for skill runs. The recourse is the filesystem. Because every change is a file on disk, git is the undo layer: git diff to see what changed, git checkout to revert, git stash to park.

This is why Denote initializes a git repository on every project. The commit history is the design history.

What is the pricing?

Denote is in closed beta and free during the beta. Post-beta pricing isn't set. You'll need an Anthropic account for Claude Code, which has its own pricing.

Where is the data on disk?

Everything is in the project folder you chose when creating the project. No hidden system directories, no application-library storage. A short list of app-level settings (recent projects, window position) lives in the standard macOS app-support location, but none of your design data is there.

Can I use Denote for things other than web products?

Denote's vocabulary and pattern library are weighted toward web and SaaS products. Mobile apps and desktop apps are adjacent; many patterns carry over. For domains Denote doesn't cover well (industrial, hardware, embedded), the pattern library will be less useful. The pipeline shape (objects, governance, screen inventory, composition) still applies.

You can also edit intelligence/ to specialize the knowledge for your domain.

Where to next