# Fix One Design-System Finding

Use this skill after `audit-design-system` has already identified a concrete issue.

This skill is intentionally narrow:
- one finding at a time
- one offending node or local cluster at a time
- minimal read scope
- minimal write scope

Load these capabilities first:
- Figma MCP read access for the normal inspection tools
- a `figma-use`-style helper before any `use_figma` write call, when your environment requires one

Use [apply-design-system](../apply-design-system/SKILL.md) instead when the task is a broader screen-wide reconnect, multiple sections need coordinated changes, or the user explicitly wants a full pass across the frame.

## Expected Input

Prefer one of these:
- a single JSON finding from `audit-design-system`
- the full review JSON plus the specific finding to address
- a paraphrased issue plus a Figma URL or `fileKey` and `nodeId`

If the finding came from `audit-design-system`, extract the target from:
- `code_location.absolute_file_path = /figma/<fileKey>/nodes/<nodeId>`

Treat the review result as the scope contract. Do not silently widen from one finding into a full cleanup pass.

## Scope Rule

Stay pinned to the selected finding until one of these is true:
- `fixed`: the targeted issue is corrected
- `blocked`: the fix requires missing library assets, inaccessible components, or broader product decisions
- `needs-follow-up`: the targeted node is improved, but a separate adjacent issue remains and should be reviewed independently

If the user pastes multiple findings, either address the one they selected or pick the highest-priority finding and say that is the one being fixed now.

## Required Workflow

### 1. Normalize the Finding

Extract and restate:
- `fileKey`
- offending `nodeId`
- finding title
- why the reviewer flagged it

If the review output does not identify a specific node, stop and ask for either the raw finding JSON or a direct Figma node.

### 2. Run A Local Compatibility Check When Replacement Choice Is Ambiguous

Before backing anything up or editing the canvas, decide whether a clean fix is actually possible.

Run a local compatibility check when:
- the finding implies a DS swap but does not identify the exact component
- more than one library component looks plausible
- override behavior or sizing is unclear
- the user explicitly wants extra research before writing

Do not continue into writes until the compatibility check returns one of:
- `safe-to-apply`
- `blocked`
- `needs-human-choice`

The compatibility check should answer:
- which exact component or variant is the leading candidate
- whether text, icon, state, and size overrides are supported
- whether the replacement can preserve the node's layout contract

If the result is `blocked`, stop and report the blocker.

If the result is `needs-human-choice`, stop and ask the minimal clarifying question instead of guessing.

### 3. Gather Only the Evidence Needed

Before writing, inspect the target with the smallest useful set of reads:
1. `get_screenshot` for the offending node or closest enclosing section
2. `get_metadata` for structural context
3. `get_variable_defs` when the finding mentions tokens, raw values, color, spacing, or typography
4. `get_code_connect_map` when the finding suggests an existing mapped component
5. `search_design_system` only if you still need to locate the replacement primitive

Do not re-review the whole board unless the finding clearly points to a repeated pattern and the repeated pattern is required to choose the fix.

### 4. Classify the Fix

Choose exactly one remediation mode:
- `swap-instance`: replace an ad-hoc or wrong instance with the correct library component or variant
- `compose-from-primitives`: rebuild the local custom wrapper from published library parts
- `bind-tokens`: replace raw values with variables or styles
- `align-variant`: move an existing instance to the correct variant or property state
- `blocked`: no valid library-backed fix is currently possible

If more than one mode seems plausible, prefer the smallest change that satisfies the original finding.

### 5. Back Up Only the Affected Area

Before destructive edits, duplicate only the offending node or the smallest enclosing local section.

Name the backup clearly, for example:
- `Backup - Fix finding 1`
- `Backup - Custom nav`

Make the backup in its own write call and return the created node ID.

### 6. Apply the Fix Incrementally

Do not rebuild the whole screen.

Work in small steps:
1. inspect current node IDs and component linkage
2. import or locate the needed library component or variable
3. replace, compose, or retokenize only the targeted area
4. return all created and mutated node IDs

Prefer `swapComponent()` when it preserves the node's position and valid overrides.

Prefer rebuilding beside the original when:
- the current node is a local wrapper with mixed custom structure
- the review finding points at a custom composition, not a single primitive
- you need v

…