using-bridge
/using-bridge
Use when any Bridge command is invoked (make, fix, done, setup, drop, status) or any Figma / design-system / compiler / Bridge workflow topic is raised. Sets command priorities and iron laws (compiler-only, semantic tokens only, verification-before-ship).
Assessment and security
- Files in this package
- 1
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 03.06.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Use when any Bridge command is invoked (make, fix, done, setup, drop, status) or any Figma / design-system / compiler / Bridge workflow topic is raised. Sets command priorities and iron laws (compiler-only, semantic tokens only, verification-before-ship).
Original author description
Use when any Bridge command is invoked (make, fix, done, setup, drop, status) or any Figma / design-system / compiler / Bridge workflow topic is raised. Sets command priorities and iron laws (compiler-only, semantic tokens only, verification-before-ship).
How it works
- Command Map
- Drop Procedure (inline)
- Skill Priority
- Iron Laws (non-negotiable)
- Red Flags — Rationalization → Reality
- References
- Conversation Language Rule
SKILL.md preview
---
name: using-bridge
description: Use when any Bridge command is invoked (make, fix, done, setup, drop, status) or any Figma / design-system / compiler / Bridge workflow topic is raised. Sets command priorities and iron laws (compiler-only, semantic tokens only, verification-before-ship).
---
# Using Bridge
Bridge is a **compiler-driven** design workflow for generating Figma designs
and maintaining a design system via Claude Code. The compiler (at
`lib/compiler/compile.ts`) enforces all 26 Figma Plugin API rules, so Claude
NEVER writes raw Plugin API code and NEVER hardcodes primitive values.
This skill is **force-loaded at every SessionStart** via `hooks/session-start`.
Its job is to establish the discipline before any action skill runs. It is
deliberately small (~400 tokens) to keep the fixed per-session cost low.
---
## Command Map
| User intent (keywords) | Route to |
|----------------------------------------------------------------|-----------------------------------|
| "make", "design", "create", "build", "generate", "new component", "new screen" | `generating-figma-design` |
| "fix", "correct", "learn", "diff", "what changed", "I adjusted" | `learning-from-corrections` |
| "done", "ship", "ship it", "finish", "complete" | `shipping-and-archiving` |
| "setup", "setup bridge", "extract", "extract DS", "onboard", "initialize", "bootstrap" | `extracting-design-system` |
| "drop", "abandon", "cancel" | inline `Drop Procedure` (this skill) |
| "status", "what's next", "workflow" | inline status logic (this skill) |
---
## Drop Procedure (inline)
`drop` is handled inline here — it is small enough not to warrant its
own skill. Invoke when the user says "drop", "abandon", or "cancel".
1. **Confirm.** Ask: "Sure you want to drop {name}?"
2. **Capture learnings.** If a snapshot exists, offer to run `fix` first to
capture corrections before archiving.
3. **Document drop reason.** Append a `drop:` block to the CSpec with
`date`, `reason`, and `learnings`.
4. **Archive.** Move `specs/active/{name}.cspec.yaml` →
`specs/dropped/{name}.cspec.yaml`. Move the snapshot JSON too if it
exists.
5. **Update history.** Append `{ISO date} | {name} | DROPPED | {reason}`
to `specs/history.log`.
6. **Cleanup.** Remove `/tmp/bridge-scene-{name}.json` if present.
Output template:
## Dropped: {name}
Reason: {reason}
CSpec archived: specs/dropped/{name}.cspec.yaml
Learnings: {captured | skipped}
Ready for the next design. Run: `make <description>`.
---
## Skill Priority
1. **Process first, then action.** For exploratory or ambiguous requests,
brainstorm the intent first before implementing. For a clear directive
that maps to a command in the table above, route directly.
2. **Verification before completion.** No "done" without evidence
(see Iron Laws below).
3. **Minimal context.** Load only the references needed for the current
action. See each action skill's `## Verification` section.
---
## Iron Laws (non-negotiable)
<IRON-LAW>
NEVER write raw Figma Plugin API code. All scene graph JSON must pass through `lib/compiler/compile.ts`. Violations require explicit human approval before any execution to Figma.
</IRON-LAW>
<IRON-LAW>
NEVER use hardcoded primitive values. Only semantic DS tokens (`$color/...`, `$spacing/...`, `$text/...`, `$comp/...`). The compiler emits `RESOLVE_TOKEN_NOT_FOUND` for any unresolved reference.
</IRON-LAW>
<IRON-LAW>
NEVER claim "done" without: (a) compiler exit 0, (b) screenshot taken in this turn, (c) user confirmation of visual correctness. "Looks right" / "should pass" / "I'm confident" are forbidden — show the evidence.
</IRON-LAW>
<IRON-LAW>
NEVER read `figma-api-rules.md`. The compiler enforces all 26 rules. This file does not exist in v6.
</IRON-LAW>
<IRON-LAW>
NEVER reuse a Figma `nodeId` from a previous session. Node IDs are session-scoped — re-search.
</IRON-LAW>
---
## Red Flags — Rationalization → Reality
| Rationalization | Reality |
|---|---|
| "I'll just hardcode this hex once" | Always use a semantic token. No exceptions. |
| "The compiler is overkill for this tiny thing" | The compiler is the only path. |
| "Skip the screenshot, it's obviously right" | 'Looks right' ≠ 'is right'. |
| "I remember this nodeId from my last session" | Node IDs are session-scoped. Re-search. |
| "I'll use figma-api-rules.md for context" | That file is forbidden. Compiler owns all rules. |
| "The user approved, I can skip the compile exit code check" | Compile exit 0 is Gate A. Independent of user approval. |
| "Let me write a small inline Plugin API script for this fix" | No inline scripts. Scene graph → compiler → execute. |
---
## References
- Compiler reference: `references/compiler-reference.md` (repo-root)
- Transport adapter: `references/transport-adapter.md` (repo-root)
- Verification gates: `references/verification-gates.md` (repo-root)
- Red Flags catalog: `references/red-flags-catalog.md` (repo-root)
---
## Conversation Language Rule
- **Conversation** with the user: their language (detect from context).
- **All generated artifacts** (KB files, CSpecs, guides, learnings, recipes,
scene graphs, docs, specs, plans): **English only**. This rule is
non-negotiable per Bridge's artifact policy.
Versions
The database has no other skills named using-bridge.
Database snapshot: 13.11.2026 · package version 431b095496b0 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100figma-bridge
Expert guide for the figma-bridge MCP (vladmdgolam/figma-mcp-bridge): reading live Figma files through the plugin without API rate limits, and keeping responses small enough to fit in context. Activate when: (1) any mcp__figma-bridge__* tool is about to be used, (2) the user… - 100extracting-design-system
Use when the user says "setup", "setup bridge", "extract", "extract DS", "onboard", "build knowledge base", "initialize bridge", or is starting Bridge in a project for the first time. Handles the complete bootstrap: pre-flight checks, scaffolding (docs.config.yaml, cron… - 100om-figma-design-with-ds
Design in a design tool (Figma or similar) on the repository's design system — write a brief for a new screen using only the contract's tokens, components and archetypes, or audit an existing design against the contract with a ranked remediation plan. Tool access goes through a… - 100pf-figma-token-check
Audit designs against the PatternFly 6 token architecture and bridge Figma styles to PF semantic tokens. Use when validating token usage, mapping Figma variables to PF tokens, or checking designs for token compliance. - 100pf-figma-token-check
Audit designs against the PatternFly 6 token architecture and bridge Figma styles to PF semantic tokens. Use when validating token usage, mapping Figma variables to PF tokens, or checking designs for token compliance. - 90figma-bridge
Use to turn Designpowers' markdown specs into something a designer can actually SEE and manipulate, and to pull existing Figma work back in. Bridges in both directions — push design-lead's visual decisions or built code into real Figma frames (code-to-design), and pull a Figma…