Cursor Workflows
This site asks Cursor to do most of the design-system housekeeping — bumping versions, syncing Figma, writing changelogs, rebuilding release notes. You type a plain-English prompt; Cursor picks the right tool. This page is the map: what's in the toolbox, what each tool does, and which prompts trigger what.
Say this — get that
The most common prompts and what they trigger. Type them in Cursor chat — you don't need to memorize skill names or workflows.
Bring the docs site up to a new Figma release.Reads both Figma files, applies safe updates, asks before anything risky, and rebuilds the release notes in Figma.
Pull one component's latest Figma into the docs.Deep-inspects the Figma component, updates the spec / CSS / examples, writes a per-component changelog entry, rebuilds Figma release notes.
Scaffold a brand-new component end to end.Creates the folder, every required file, the sidebar link, the docs-page placeholder, and a starter changelog entry.
Generate the canonical seven-card component canvas in Figma.Builds Header / Anatomy / Variants / Sub-components / Usage / Accessibility / Meta cards from the spec data, all token-bound.
figma-component-cardStart a code-first draft playground.Creates a hidden dev route where you can preview and tune a component idea before recreating it in Figma.
uds-component-labDraft a new UDS component directly in Figma.Builds a token-bound component set on a brand-new draft page. You accept it by renaming the page; the docs site catches up on the next "UDS updated."
generate-uds-figma-componentSee which components have the most spec gaps.Returns a completeness report — same scoring as the "Spec X/22" pill — with the three highest-impact fields to fill in next per component.
spec-auditWhat's in the toolbox
Four kinds of guidance, ordered from always-on background discipline to called-on-demand specialists to enforced-by-CI safety nets. Each kind lives in its own folder and plays a different role.
Rule
A standing instruction Cursor reads on every relevant task. Sets the project's discipline.
Like "always wear a seatbelt."
Skill
A how-to procedure Cursor loads on demand when your prompt matches. Cursor itself follows the steps.
Like "how to change a tire — read the manual when you need it."
Subagent
A specialist contractor. Spawns in its own context, does its job, returns one structured report, then disappears.
Like "call the mechanic."
CI Audit
A bash script that runs on every PR. Failing audits block merge. Catches the failure modes humans and agents skip.
Like the MOT inspection.
The whole toolchain
Browse by category. Workflows show the end-to-end flows Cursor stitches together. The other tabs list every rule, skill, subagent, and audit individually.
Four end-to-end flows the toolchain supports, from biggest scope (a new UDS release) to smallest (one component fix). Orchestrator skills tie multiple steps together; the specialist skills inside can also be invoked on their own.
UDS version release
Figma UDS Version: X.Y page bumps and the user confirms a release. The biggest flow — touches every Figma file, every changed component, both release-note frames, and the SITE build.
- 1
Preflight
Confirms Figma is readable, then walks both files to find the version bump, status changes, new components, and renamed components.
figma-capability-checkfigma-inventory - 2
Token audit
Direct read of every Figma Variable. Reports added / removed / renamed tokens, value changes per mode, and alias-graph validity.
figma-token-audit - 3
Component inspections
For each changed component: a deep node-tree, variant-matrix, token-binding, and accessibility read — compared against the docs-site spec.
figma-component-inspector - 4
Snapshot release
Archives the current
uds/folder intoversions/<old>/uds/, bumpsuds/version.json, refreshes manifests.release.sh - 5
Apply safe changes
High-confidence non-breaking changes apply automatically. Anything risky stops for explicit user confirmation.
import-figma-tokenssync-figma-component-specsync-figma-component-statuslink-figma-nodesnew-component - 6
Re-check contrast
Rebuilds the aggregated changelog and component manifest, then reviews token pairings in the Contrast Checker across all six themes.
aggregate-changelog.shaggregate-components.sh/contrast-checker - 7
Figma release notes
Rebuilds the
Release Notesframe on the current version page in BOTH Figma files. The two files always end up with identical text.sync-figma-release-notes - 8
Docs changelog
Bumps the SITE build counter, appends the SITE changelog entry, cache-busts what changed, pushes to
main. GitHub Actions deploys to GH Pages.SITE_CHANGELOG
Mid-release component sync
One or a few components get a fresh Figma read between releases. No version bump — just the changed components, their changelog entries, and a Figma release-notes refresh.
- 1
Deep inspect
Locates the canonical Figma component set, walks the node tree, captures variants and token bindings, classifies every finding by confidence and risk.
figma-component-inspector - 2
Apply spec sync
Updates the spec, CSS, examples, impl, and playground for every high-confidence non-breaking finding. Stops on anything risky.
sync-figma-component-spec - 3
Per-component changelog
Adds an entry to that component's
changelog.jsonfor the current UDS version, then runs the aggregator to refresh the global changelog.aggregate-changelog.sh - 4
Update sync-state snapshot
Records the captured Figma node IDs, variant matrix, and nested instances so the next sync can diff against this run.
.cursor/figma/state/ - 5
Figma release notes
Mandatory whenever the global changelog changes — rebuilds the
Release Notesframe on the current version page in both Figma files.sync-figma-release-notes - 6
Docs changelog
Appends a SITE changelog entry describing the sync. Cloudflare and Next.js handle cache invalidation on deploy.
SITE_CHANGELOG
Add a new component
Scaffold a brand-new component on the docs site — folder, files, sidebar link, page placeholder, starter changelog entry. The component starts at placeholder status; the spec fills in over time.
- 1
Scaffold the folder
Creates the new
uds/components/<id>/folder with every required file: CSS stub, spec.json, status.json, changelog.json with the initial "added" entry, impl.json, playground.js, examples/.new-component - 2
Wire into the docs site
Adds the sidebar link, the page placeholder, the component CSS import, and (if interactive) the JS registration.
- 3
Refresh manifests
Aggregates the new component into
components.jsonand folds its starter changelog entry intoCHANGELOG.json.aggregate-components.shaggregate-changelog.sh - 4
Docs changelog
Appends a SITE changelog entry announcing the new component. Cloudflare and Next.js handle cache invalidation on deploy.
SITE_CHANGELOG
Single component edit
Smallest scope — one component's CSS, examples, or playground gets adjusted. Often a Figma-comment follow-up or an a11y review fix. Per-component changelog is still mandatory.
- 1
Source-of-truth check
Any edit under
uds-docs/uds/has to come from Figma (or revert toward Figma parity). Cursor cites the Figma read first; it won't apply an audit-detected "fix" on its own.uds-source-of-truth - 2
Edit the file
Change only the targeted file in
uds/components/<id>/. Token-first CSS only — no raw hex / sizes / spacing. - 3
Per-component changelog
Adds an entry to that component's
changelog.jsondescribing the fix; the aggregator picks it up.aggregate-changelog.sh - 4
Docs changelog & release notes
Appends the SITE changelog entry. If the global changelog actually changed, Figma release notes rebuild too.
SITE_CHANGELOGsync-figma-release-notes
The Component Factory turns a plain-English brief into a real, token-correct component drafted directly in Figma. You describe what you want; it builds the whole variant set — every state, every tone, every nested icon and button — bound to UDS tokens, on its own draft page. You stay the designer and the approver. The factory does the repetitive construction and checks its own work before handing it back.
The life of a factory component
From a sentence to a documented component. You're in control at every gate — nothing becomes "real" without your say-so.
- 1
You describe it
A sentence or two: what the component is, when to use it, anything unusual. Say something like "factory me a Metric Card." That's the whole input.
- 2
It drafts in Figma, on its own page
The factory builds the component on a brand-new draft page in the UDS Components file. The page name carries two tags:
{Cursor}means "the factory may edit this freely" and{Ignore}means "keep this hidden from the rest of the tooling" — so a half-finished draft never shows up in the live library or the docs site by accident. - 3
It checks its own work
Before handing back, the factory runs a quality report and tells you what's solid and what still needs a designer's eye. The first draft is meant to be a strong starting point, not the finished article.
- 4
You review and accept
You look it over in Figma and tweak whatever you want. When you're happy, you accept it by renaming the page — drop the
{Cursor}{Ignore}tags and set the status color. That rename is your signature; the factory never does it for you. - 5
The docs site catches up
Later, when you say "UDS updated," the normal Figma–to–docs sync picks up the accepted component and creates its docs page, spec, and changelog entry. The factory itself stops at Figma.
- 6
It stays current (later)
As the factory improves, an approved component can fall behind the newer quality bar. The factory can then propose updates to bring it current — but every change waits for your approval, nothing is automatic on a live component, and you can tag one
{Frozen}to opt it out of factory updates entirely while keeping it in the docs.
What happens under the hood
4The factory works in four phases. The only one that needs you is the first — you approve the plan before anything is built.
The factory expands your brief into a full plan: which states and tones it'll build, what each part is, which existing UDS pieces it'll reuse, and which tokens it'll bind. It shows you the plan and waits for the word "approved" before touching Figma. No surprises.
It constructs the component set on the draft page — every variant, bound to UDS color / spacing / type / elevation tokens, reusing real UDS parts (icons, buttons) rather than redrawing them. It also writes a hidden "contract" note on the component describing the bits Figma can't draw (keyboard behavior, events, accessibility).
It audits its own build by machine — not from memory — and reports the counts: any hardcoded colors, any unbound spacing, any missing focus rings, any controls a designer should be able to reach. You get an honest "here's what's solid, here's what to review."
The factory's job ends. It leaves the draft on its {Cursor}{Ignore} page for you. Accepting it (the rename) and landing it in the docs site ("UDS updated") are your moves, on your schedule.
Why you can trust the draft
The factory holds itself to the same bar a careful designer would — and proves it by machine, not by claiming it.
Every color, spacing, radius, type style, and shadow is bound to a UDS token — so the component re-themes correctly and never ships a stray hex value.
Focus is a real offset ring with a gap, not a thickened border — the keyboard-accessibility detail that's easy to fake and easy to get wrong.
On a component with Info / Success / Warning / Error tones, every colored part — dot, chip, icon, trend — recolors to match its tone, not just the main surface.
Nested pieces (icons, an overflow menu) expose their own controls on the component, so you can swap a glyph or toggle a part without diving through layers.
It reuses the actual UDS icon and button components rather than redrawing them — so the draft stays in the design system's dialect from the start.
The quality report comes from a machine pass over the finished build, so "zero hardcoded colors" means zero — not "I think so."
What it won't do
The guardrails matter as much as the output. The factory:
- Stops at Figma. It drafts the component; it never edits the docs site or the design-system files itself. That happens later, on your "UDS updated."
- Never accepts its own work. The draft stays a draft until you rename the page. The factory won't drop the tags for you.
- Never invents a token. If a color or size it needs doesn't exist in UDS yet, it stops and tells you, rather than making one up.
Start the factory.Describe the component you want; Cursor drafts it in Figma on a new draft page and hands you the quality report. Accept it by renaming the page when you're happy.
generate-uds-figma-component23 rules total — 8 always-on (loaded into Cursor's context on every task) and 15 glob-scoped (loaded only when files matching the rule's glob are in context, or when a skill explicitly references the rule).
Always-on
8Loaded on every task. These set the project's standing discipline.
uds-source-of-truthvisibilityAlways onThe hardest rule: uds-docs/uds/ is Figma's source of truth. Cursor won't edit anything in there in response to audit findings or "obvious fixes" — only the named Figma-sync skills (or an explicit user-directed revert) may write there.
uds-master-preflightvisibilityAlways onThe five-phase workflow every change has to follow: sync first → source-of-truth check → bump → change → finalize. Phase 5 holds the canonical round-trip checklist every Figma-sync skill points back at.
uds-site-changelogvisibilityAlways onEvery change under uds-docs/ bumps the SITE version, adds a SITE_CHANGELOG entry, and cache-busts whatever files changed. The entry itself is designer voice, not implementation log — one to three sentences, lead with what changed, technical names only when the reader needs them.
uds-content-schemavisibilityAlways onComponent spec content lives in per-component spec.json and gets rendered by the Guidelines tab. Never re-introduce spec HTML into index.html.
uds-release-workflowvisibilityAlways onThe release questionnaire and automated release steps — snapshot, status sync, changelog, token regen, Figma release notes, SITE bump. The Changelog Sync Rule also fires whenever the global changelog changes mid-release.
uds-figma-write-safetyvisibilityAlways onFigma writes are denied by default. Only five scopes ever apply: release-notes frames, status page prefixes, cover-page version text, component drafts on a {Cursor}{Ignore} page (free), and gated upgrades to a live component (each change needs explicit approval). Every write produces a before / after / rollback summary. Editing any existing component first reads its embedded contract and the current factory bar — recorded design decisions are binding, and a component edit can't claim a factory version it doesn't actually meet.
uds-figma-change-classificationvisibilityAlways onEvery finding pulled from Figma has to land with a confidence (high / medium / low), a risk class (non-breaking / potentially-breaking / destructive), and a default action. Only high-confidence + non-breaking auto-applies; everything else asks.
communication-stylevisibilityAlways onHow Cursor should talk to you and write docs prose. Default tone: senior designer, not developer — concise, plain language, jargon only when it's the clearest word. SITE_CHANGELOG entries fall under designer voice now. Technical voice stays non-negotiable for code, schemas, per-component changelogs, audits, commits, PR descriptions, and the .cursor/ files themselves.
Glob-scoped
15Loaded only when files matching the rule's glob are in context, or when a skill explicitly references the rule.
uds-token-first-cssLoads on uds/**/*.cssBans hardcoded colors, spacing, fonts, and radii. Use var(--uds-*).
uds-token-architectureLoads on uds/tokens/**/*.cssThe canonical token architecture and CSS output contract. Direct Figma Variables reads are primary; ZIP exports are fallback only. Also defines the required figma-token-audit report shape.
uds-figma-preflightLoads on any taskRequired preflight for any Figma read or write. Owns the canonical Figma file-keys table and the stoplight → status mapping; other rules cross-reference these.
uds-figma-component-inspectionLoads on uds-docs/**Prevents screenshot-based guessing. Requires a node-tree + variant + token-binding + nested-instance + accessibility read before any component spec update. Bidirectional — also enumerates doc-side artifacts and diffs against the last snapshot so deletions and renames can't go silent.
uds-figma-sync-stateLoads on .cursor/figma/**Defines what counts as a valid sync snapshot under .cursor/figma/state/ and when an agent may update one. Snapshots only get written after a successful verified sync — never in dry-run mode.
uds-component-checklistLoads on component source filesThe standard UDS component contract: anatomy, variants, states, API, accessibility, examples, playground controls, Web Component implementation, and React wrapper coverage. The new-component and sync workflows use it as the baseline for "complete," with explicit notApplicable reasons when a state does not belong to a component.
uds-figma-component-cardLoads on card-skill filesThe canonical seven-card layout for component pages in the UDS Components Figma file. Used by the card-builder skill and its audit subagent.
uds-figma-component-card-updateLoads on card-skill filesUpdate-mode companion to the card layout rule. Defines drift detection, no-op when in sync, and the no-content-loss inventory-then-rebuild contract when the builder is re-run on an existing page.
uds-rule-disciplineLoads on .cursor/**Fires whenever you edit a rule, skill, or subagent file. First it sets the bar for what's worth writing — a lesson should be a reusable rule, not just "remember that one time," trimmed to the point but never stripped of the detail (triggers, exact names, paths, rationale) that makes it work. Then the bookkeeping: bump that file's lastUpdated: in its YAML frontmatter and refresh the matching row in .cursor/TOOLCHAIN.md in the same commit. The toolchain equivalent of the SITE changelog discipline.
uds-figma-plugin-api-gotchasLoads on any taskPlugin-API gotchas that bit the component factory once and would bite any other Figma write the same way: same-file vs library component identity, INSTANCE_SWAP defaults, hidden white auto-layout fills, resize-axis quirks, within-call propagation limits, all five auto-layout spacing properties needing to be bound (not just the two CSS-style horizontal/vertical pair — "every side bound" is the rule, not "every side equal"), and effects binding via setEffectStyleIdAsync rather than raw node.effects literals (which render fine but escape every bound-check audit).
uds-figma-factory-qualityLoads on factory skillsProcess gates for any factory-style Figma build: full state design contract up front; a machine-verified Phase C audit that must report unbound paints, per-side spacing bindings (all five auto-layout properties), effect-style bindings (every node where effects.length > 0), and per-variant INSTANCE_SWAP defaults vs. the model's plan; a variant grid that reflects axis semantics; sensible visibility defaults; and a Phase B.0 dependency manifest before any write.
uds-design-languageLoads on any taskHow every UDS component handles each state — interaction, validation, availability, selection. Covers focus-ring constructions, surface treatment scale, elevation, radius, density, and the Checked-vs-Selected-vs-Active naming. Factory builds source state visuals from this rule rather than re-deriving them.
uds-naming-conventionsLoads on any taskThe design-system-level naming framework. Locks the canonical vocabulary every UDS component reaches for across ten categories: states (Default / Hover / Pressed / Focus / Selected / Disabled / Loading / Error, plus Empty + Read-only when applicable, plus Checked + Current as reserved words), sizes (Small / Medium / Large), tones (Info / Success / Warning / Error / Neutral), emphasis (Primary / Secondary / Tertiary for ranked importance vs Bold / Default / Subtle for tuning loudness), parts of a component (Leading / Trailing, Header / Body / Footer), the state-vs-variant-vs-property litmus test, casing rules, component and subcomponent naming, and lifecycle status. Companion to uds-design-language — design-language covers how things look, this rule covers what we call them. Factory and new-component pick names from this framework rather than guessing from siblings.
uds-factory-docs-currencyLoads on factory skillsKeeps the plain-English Factory tab on this page honest. When a change to the factory skillset (generate-uds-figma-component, uds-figma-factory-quality, uds-figma-plugin-api-gotchas) changes something a designer would notice — a phase, a quality gate, the lifecycle, a trigger prompt — the Factory tab and a SITE_CHANGELOG entry update in the same change. Internal-only edits don't. An audit can confirm the page mentions the factory files; keeping the prose accurate is the editor's job.
uds-factory-versioningLoads on factory skillsStamps every factory-built component with the factory's version — a date, YYYY.MM.DD.N — so you can tell which components were built to an older quality bar. Defines when the version bumps (only when factory output changes, not on every edit), how it's stamped in Figma and carried into spec.json, and the rule that being behind is always reported, never silently applied to a live component. Source of truth: .cursor/figma/state/factory-version.json.
10 skills total — 4 orchestrators that stitch multiple steps together, and 6 specialist sync skills that orchestrators call (and that you can also invoke directly). Every sync skill ends by pointing at uds-master-preflight Phase 5 — the round-trip checklist lives in exactly one place.
Orchestrators
4Top-level skills you invoke directly. They call other skills and subagents in sequence.
uds-updatedOrchestratorEnd-to-end Figma → docs sync. Reads both Figma files, classifies findings (including surplus findings for doc-side artifacts with no Figma counterpart), applies high-confidence non-breaking changes, falls back to dry-run for everything else.
figma-component-cardOrchestratorBuilds the canonical seven-card layout on a UDS Components Figma page from spec.json data. Direction of data flow is code → Figma (opposite of every other Figma-sync skill).
uds-component-labOrchestratorStarts a dev-only code draft for a component idea. It creates a hidden lab route for previewing states and variants, keeps the draft out of official UDS docs, and waits for explicit direction before promoting anything to Figma.
generate-uds-figma-componentOrchestratorUDS Component Factory. Drafts a token-bound UDS component set directly inside Figma on a brand-new 🟠 <id> {Cursor}{Ignore} page (the lowercase component id, matching mainline component pages). The {Ignore} marker takes the page out of every automation; the designer accepts by renaming the page. Stops at Figma — docs landing happens later via uds-updated.
Specialist sync skills
6Called by orchestrators — or you can invoke them directly when you want just one piece of the flow.
new-componentSync skillScaffolds a brand-new uds/components/<id>/ folder end to end with every required file, the sidebar link, the page placeholder, and the SITE bump.
import-figma-tokensSync skillRegenerates the token CSS from a direct Figma Variables read. ZIP exports are fallback only. Updates the tokens snapshot and the last-sync marker.
sync-figma-component-specSync skillUpdates one component's per-component files (spec, CSS, examples, impl, playground, figma notes) from a component-inspector report. Bidirectional — consumes the inspector's surplus + snapshot delta sections to propose removals as classified findings; the figma-notes section also auto-prunes resolved entries and adds new ones for open questions.
sync-figma-component-statusSync skillEdits a component's status.json to match Figma's stoplight page prefix. Adds a per-component changelog entry. Backward moves from review or production ask before applying.
link-figma-nodesSync skillPopulates figmaNodeId and figmaPageNodeId in spec.json from canonical Figma component-set and page nodes. Overwriting a non-null link asks first.
sync-figma-release-notesSync skillRebuilds the Release Notes frame on the current version page in both UDS Tokens and UDS Components Figma files from uds/CHANGELOG.json. The two files always end up identical.
7 subagents, all read-only. Each spawns in its own isolated context window, does its job, returns one structured report, then disappears. That keeps noisy intermediate work out of the main conversation.
figma-capability-checklockRead-onlyProbes the Figma integration: which API tools work, what's actually readable. Returns a capability report covering pages, Variables, aliases, node trees, bound variables, and release-notes write support.
figma-token-auditlockRead-onlyReads UDS Tokens Variables directly, validates the architecture, diffs against the last snapshot, reports added / removed / renamed tokens and value changes per mode.
figma-inventorylockRead-onlyLists every Figma version, component page, status, component fingerprint. Spots new components, missing components, renamed components, and status mismatches against the docs site.
figma-component-inspectorlockRead-onlyDeep-inspects one component end to end. Returns the variant matrix, anatomy, token bindings, hardcoded values, accessibility implications, doc-site mismatches, doc-site surplus, snapshot delta, and a Figma-notes evaluation. All three structured sections are mandatory.
figma-spec-gaplockRead-onlyCompares Figma coverage against the docs site — missing docs, missing components, stale titles, status mismatches, new-component candidates.
figma-component-card-auditlockRead-onlyAudits one (or all) UDS Components Figma component pages against the canonical card layout. Checks structure, token bindings, status pill, link cards, and content match against the spec.
spec-auditlockRead-onlyScores spec completeness per component out of 22 — same scoring as the "Spec X/22" pill on each component page — and recommends the three highest-impact fields to fill in next.
12 bash audits in scripts/audit-*.sh, wired into .github/workflows/audits.yml. They run on every PR and every push to main. Failing audits block merge. Three of them grandfather pre-existing drift via scripts/audit-baseline.json. Contrast validation lives in the Contrast Checker tool (/contrast-checker), not CI.
Pre-existing audits
4Lived on the repo from early on. Catch the most basic completeness and convention violations.
audit-component-completenessblockBlocks mergeEvery uds/components/<id>/ folder has the required minimum files: CSS, schema-valid spec.json, status.json, changelog.json, impl.json, playground.js, examples/manifest.json, at least one example HTML.
audit-placeholdersblockBlocks mergeEvery {{token}} referenced in any example HTML is declared in placeholder-vocabulary.json. Keeps Demo Builder substitution deterministic.
audit-token-usageblockBlocks mergeEvery per-component CSS file uses --uds-* tokens. Flags hardcoded hex values.
audit-demo-coverageblockBlocks mergeEvery implementation-ready component has at least one example with demoWeight > 0 so the Demo Builder always has something to render.
Drift-detection audits
7Introduced to hard-block the failure modes that produced the nav-header changelog, page-chrome, and sync-state issues. Each fails CI when its specific class of drift appears.
audit-changelog-currencyhistoryGrandfatheredFor each component, fails if any commit after the baseline SHA touched source files (CSS / JS / spec / examples / impl / playground / status) without a matching changelog.json entry. Exempts commits whose message contains [no-changelog: <reason>].
audit-aggregate-currencyblockBlocks mergeRe-runs the aggregators into temp files and diffs against the committed uds/CHANGELOG.json and uds/components.json. Catches "edited per-component, forgot to aggregate."
audit-figma-sync-state-currencyblockBlocks mergeState-based check that each spec.json figmaNodeId and figmaPageNodeId matches the components.snapshot.json componentSetNodeId and pageNodeId.
audit-css-api-tablehistoryGrandfatheredFor each component, compares retained udc-* selectors in the payload CSS with the typed Code-tab API data in data/component-api/<id>.ts. Fails on either-direction drift. Empty cssClasses arrays are intentional for Web Components; retained legacy rows still have to match.
audit-doc-internal-consistencyhistoryGrandfatheredPer-component doc-side coherence safety net — the partner of the inspector's surplus pass. Five checks: orphan CSS selectors, undispatched spec events, missing impl token refs, missing component pair refs, and orchestrator script entries pointing at missing files. Catches what partial cleanups leave behind.
audit-agent-docs-currencyhistoryGrandfatheredCompares the files under .cursor/rules/, .cursor/skills/, .cursor/agents/ against the references on THIS docs page. Catches "added / renamed / removed a rule, skill, or agent without updating the docs."
audit-toolchain-currencyblockBlocks mergeThree bundled checks: every rule / skill / subagent file's frontmatter lastUpdated: is newer than its git mtime; every file has a row in .cursor/TOOLCHAIN.md; every row's date matches the file's frontmatter.
audit-figma-card-templateblockBlocks mergeVerifies the component-card template constants used by the card builder skill stay in sync with the canonical layout rule.
Baselines and exemptions
scripts/audit-baseline.json is the single config file for any audit that grandfathers pre-existing drift. It holds:
audit-changelog-currency— abaselineSHA. Commits before this SHA aren't checked. Update only on a deliberate sweep that backfills changelogs.audit-css-api-table— atoleratedComponentsarray. Components in this list are exempted from the Code-tab table check. Add or remove only with explicit user direction.audit-doc-internal-consistency— atoleratedFindingsarray of literalcomp/check/identifierstrings, plustoleratedComponentsfor whole-component skips. The goal is to drain the list as components get cleaned up.audit-agent-docs-currency— abaselineSHA and an optionaltoleratedFilesarray for internal-only rules / skills / agents that intentionally don't appear on this docs page.
All four kinds live in the repo and ship with anyone who clones it. Add one when the discipline you're following keeps getting forgotten — rules for standing instructions, skills for repeatable procedures, subagents for context-isolated work, audits for the safety net.
policyAdd a Rule
- Drop a
.mdcfile in.cursor/rules/with YAML frontmatter (description,alwaysApply: trueORglobs: [...]) and the rule body in markdown. - Use rules for standing instructions and project conventions — "always do X," "never use Y."
- Add a card to this page's Rules tab.
audit-agent-docs-currencyblocks the merge otherwise.
menu_bookAdd a Skill
- Create
.cursor/skills/<name>/SKILL.mdwith frontmatter (name,description) and a step-by-step procedure. Optionally addscripts/,references/, orassets/subfolders. - Use skills for repeatable, well-defined procedures Cursor can carry out itself — "scaffold X," "sync Y."
- Every sync skill should end with a pointer to
uds-master-preflightPhase 5. - Add a card to this page's Skills tab.
support_agentAdd a Subagent
- Create
.cursor/agents/<name>.mdwith frontmatter (name,description, optionallyreadonly: true,model). - Use subagents for tasks that benefit from context isolation — long research, parallel work, read-only audits.
- Add a card to this page's Subagents tab.
verifiedAdd an Audit
- Create
scripts/audit-<name>.shfollowing the patterns of existing audits — exit non-zero with a clear "FAIL — <reason>" line on failure; emit "OK — <summary>" on success. - Wire it into the
auditsjob in.github/workflows/audits.yml. - If the audit needs grandfathering, extend
scripts/audit-baseline.json. - Add a card to this page's CI Audits tab.
You don't have to memorize any of this
Saying "sync the bento dropdown from Figma," "audit our specs," or "scaffold a new tooltip component" is enough. Cursor picks the right skill or subagent based on the description, the rules guarantee the version bump / per-component changelog / aggregate / snapshot / Figma release notes / cache-bust all land, and the CI audits hard-fail if anything is silently skipped. Less ceremony, fewer mistakes, more time on actual design.