open-design

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese
<!-- generated:open-design-agent-kit -->
Open Design is a bundled catalog of design skills and design templates (reusable task recipes and rendering styles — both usable interchangeably as a
skillId
) plus design systems (brand-inspired visual token sets), exposed through the
open-design
MCP server's tools.
Every skill/template id is namespaced as
od:<mode>:<name>
(e.g.
od:deck:guizang-ppt
), where
mode
is one of:
prototype
,
deck
,
design-system
,
image
,
video
,
template
,
utility
,
audio
. Always pass the full namespaced id as
skillId
. Note: mode
design-system
means "a skill that helps author a design-system deliverable" — it has nothing to do with
designSystemId
, which selects from the separate library of ~150 prebuilt brand design systems (see step 2).
A small, curated subset of skills/templates also has its own explicit
/open-design:<id>
skill — if the user's request closely matches one of those, prefer invoking it directly; it pins the exact skillId and often a ready-made example brief, removing any guesswork. Otherwise, follow the flow below yourself.
All Open Design content (skill/template text, design system tokens, example briefs) is delivered to you as plain text through the MCP tool calls below — never as a file path. You never need to, and should not, browse or search for Open Design's own files anywhere on disk;
list_open_design_skills
and
prepare_open_design_brief
already return everything you need as plain text.
<!-- voice:start -->
How to talk to the user. Many people using Open Design don't write code, so:
  • Use the user's own words. If they say "artifact", "design tokens" or give a file path, use those terms back; otherwise use the plain words below.
  • Keep the machinery out of replies: no tool names, no ids like
    od:prototype:poster-hero
    , no internal files (
    .artifact.json
    ,
    .comments.json
    ,
    config.json
    ), and not the words "register", "manifest", "sidecar", "entry" or "surface", unless the user used them first.
  • Explain a print term the first time it comes up, in one short clause, and not again.
  • Say where a file is the way the user would find it ("in your Open Design folder, under seed-swap-flyer"). Give a raw path only where the user can click it (Claude Code, Claude Desktop's Code tab, VS Code) or asks for it.
  • End each reply that finishes a step with one line on what they can do next, with at most two options ("Want it in Instagram sizes too, or is it ready to print?").
Instead ofSay
artifact, entry, registeredyour design, saved
design system, active design systemyour style (the first time: "a saved style: colours, fonts and spacing")
surface, skill, template, recipekind of design, starting layout, or nothing
workspace, output directoryyour folder, your Open Design folder
bleedprint edge ("a few millimetres extra that the printer trims off")
trim sizefinal size
preflight findings, errors"I checked it and fixed…", "one thing to look at:"
exportsave as PDF, save as an image
inline preview, MCP Appthe preview above
<!-- voice:end -->
Follow this flow:
  1. Check the tools are wired up. This skill does nothing on its own — every step below calls a tool the
    open-design
    MCP server provides. If
    list_open_design_skills
    (or any other tool named below) isn't available to you right now, the server hasn't been registered in this project yet. Set it up, then retry from step 1:
    • Claude Code: point the user to the setup steps in Claude Code.
    • Codex CLI: point the user to the setup steps in Codex.
    • Any other MCP-capable agent (Cursor, etc.): point the user to Getting started, which shows how to add the Open Design MCP server to any agent.
    • Claude Desktop Chat or claude.ai (no Open Design tools in the chat): don't make anything yet. Welcome the user in plain words, in this shape:
      Open Design can't save or check designs in this chat yet. Two ways to fix that:
      1. Connect a folder: make a folder called "Open Design" (in Documents, for example), then click + in this chat, choose Add folder and pick it.
      2. Install the Open Design extension for Claude Desktop: download it from https://github.com/feimacode/open-design-agent-kit/releases/latest, double-click the file, then start a new chat.
      What's the design for?
      Don't name file types, packages, commands or tools in it. Offer the goals from step 1 below as examples of what they can say ("promote an event", "show an idea", "get hired"). Only if they want to go ahead without either, make one self-contained HTML page and publish it with your own Artifact tool, and say it can't use saved styles, checks or saving as PDF and images.
    Run the command yourself if you have shell access; otherwise tell the user the exact command to run and wait for their confirmation before continuing. Skip this step entirely once the tools are available.
    In Claude Desktop (a chat or Cowork session with a folder the user connected), the server runs on the user's machine and starts in their home folder, and your file tools see the folder under a different path. Before any other Open Design tool, call
    set_open_design_workspace
    with the folder's path on the user's machine (the one
    get_device_info
    lists under
    connectedFolders
    ). Every path other tools return is relative to that folder: join it onto your own path for the folder when you read or write files, and when you attach or show a file with your own tools, give the full path: a relative one resolves against your shell's current folder, which moves when you
    cd
    . If a tool says it would be working in the home folder, this is what it's asking for. The first time you set the folder in a chat, tell the user in one sentence where their designs will be saved (the folder's name and the
    Open Design
    folder inside it) and that they can open it any time; don't repeat it for later designs.
    In Claude Desktop Chat with no folder (
    use_open_design_managed_workspace
    is in your tools), your own file tools, if you have any, can't reach the server's files. Call
    use_open_design_managed_workspace
    first with a short name for the design, and tell the user once, in one sentence, the folder's absolute path from its result (under
    ~/Documents/Open Design/
    by default), so they can open it. Then save every design file with
    write_open_design_file
    (the whole file each time, under the output directory) instead of your own file tools, and register, check and export as usual. Show the design with
    show_open_design_artifact
    once; later rounds update that inline copy by itself. Don't keep a per-round Claude artifact preview here. The managed folder is the source of truth: to edit, send the full new file through
    write_open_design_file
    . If the chat has a connected folder, use
    set_open_design_workspace
    instead.
  2. Call
    list_open_design_skills
    (optionally with a
    query
    and/or an exact
    mode
    ) to find a skill or design template that matches what the user wants. Pick the best match by name/description/triggers, and prefer a result's
    examplePrompt
    (adapted to the user's specifics) over inventing your own brief when one is present and closely fits.
  3. There is an active design system, persisted per project (a local
    .open-design/config.json
    file). If the user mentions a brand, company, industry, or visual style that differs from what's active, call
    list_open_design_design_systems
    (optionally with a
    query
    and/or an exact
    category
    — call with no arguments first to see categories, and check each result's
    active
    flag) to find the right one, and pass its id explicitly to
    prepare_open_design_brief
    — doing so also makes it the new active one going forward, so you don't need to re-specify it on later requests in this project. For phone screens (the Mobile app surface, or a brief like "a budgeting app that feels like Monzo"), look in the
    Mobile Apps
    category first, with the app's name as
    query
    : those systems are adapted from the real iOS apps (tab bars, sheets, iOS point sizes). Use
    <app>-ios
    (e.g.
    spotify-ios
    ) for phone screens even when a web system of the same brand exists (
    spotify
    ); the web one stays the right choice for web pages. If the user hasn't mentioned any direction and one is active, just omit
    designSystemId
    from
    prepare_open_design_brief
    and it will use the active one. If none is active and the user hasn't named a direction, recommend one before preparing a new design (not for an edit, a remix or an export): call
    recommend_open_design_design_systems
    with what you know from the request, the conversation and the workspace (
    industries
    ,
    moods
    ,
    theme
    ,
    surface
    ,
    likeBrands
    ,
    brief
    ), leaving out what you don't know. If its result has
    questions
    , ask them once, as short multiple-choice options: through
    show_open_design_questions
    where it is in your tools, else in one message (or your host's question tool if it has one), and accept "you pick"; then call it again with the answers. Ask them in the same message as any surface questions, three in total at most. Show the shortlist: where
    show_open_design_design_systems
    is in your tools, pass it the recommended
    ids
    ; elsewhere, a short numbered list with each name and its
    reason
    . Don't wait for a pick unless you asked questions: go ahead with the first recommendation, pass its id to
    prepare_open_design_brief
    , and say which style you used and that they can pick another. If
    recommend_open_design_design_systems
    isn't in your tools, use
    list_open_design_design_systems
    instead, or go without one. Only call
    set_active_design_system
    directly when the user wants to pin a look before generating anything ("let's use the Starbucks look from now on").
  4. Call
    prepare_open_design_brief
    with the chosen
    skillId
    , optional
    designSystemId
    (per step 2), and the user's
    brief
    (their request, in their own words). This returns
    instructions
    to follow, a
    suggestedEntryPath
    , and the
    designSystemId
    /
    designSystemName
    actually used (whether explicit or defaulted from active) — mention which one it was if it wasn't obvious from the conversation. It does NOT write any files.
  5. Follow the returned
    instructions
    and author the artifact's entry file (plus any supporting files) yourself, using your own file-editing tools. Do not look for a separate tool to write the design content.
  6. Call
    register_open_design_artifact
    with the entry path, a
    kind
    , a
    title
    , and any
    supportingFiles
    , so the artifact is recognized and gets its manifest sidecar written.
  7. Call
    check_open_design_artifact
    with the entry path before telling the user it's done (after creating an artifact, and again after a substantial edit). It renders the artifact and returns screenshots plus preflight findings: fix every error, then look at the screenshots for what the checks can't measure — balance, hierarchy, crowded or empty areas, text over busy imagery — and fix what's clearly wrong. Taste warnings (
    slop-glow
    ,
    card-row
    ,
    uniform-surface
    ,
    type-scale
    ,
    intent
    ) are worth a look: fix them unless the brief or the design system asks for that look, and never add
    data-od-allow
    only to silence one. Re-check after fixing, but stop after two fix rounds and tell the user about anything left. Then get a second look before you call it done: once the checks are clean or the fix rounds are spent, run the
    open-design-critique
    skill, which has a fresh critic judge the latest check run against the brief and the design system on purpose and hierarchy, typography, colour and contrast, layout and rhythm, copy, states, and fit, so build with those in mind. One critique round: on
    polish
    , apply its fixes once, register and re-check, then report done without another critique; on
    rework
    , tell the user what's wrong and ask before rebuilding; on
    ship
    , it's done. The brief or design system wins over a finding against a look it asks for, and the user can ask for another opinion at any time or say they don't want one. 3D designs are the exception: when the check returns a 3D review sheet, a clean check isn't the end. Get the critique the check result asks for (the
    3d-object
    skill's scorecard, from a subagent where your host has one), then fix, re-check and re-critique for up to three critique rounds, which replace the two-fix-round limit and the second look above. Don't describe the screenshots to the user unless they ask: each run's screenshots are saved for them, and the browser preview's Checks panel shows them before and after (the result also lists the saved paths). If it returns
    no-browser
    , skip checking and tell the user once that visual checks need Chrome, Edge or Chromium installed.
  8. Optionally call
    get_open_design_artifact
    to confirm what was written before telling the user it's done.
  9. After the first artifact you register in a session, call
    open_open_design_preview
    with its entry path, unless the user said they don't want it, so they can see it. It opens a live browser preview that reloads whenever the file changes, so don't call it again after edits; call it again only to switch to another artifact. Mention that they can click Comment in the preview to leave comments on elements.
    In Claude Desktop's Code tab (its preview tool, named like
    preview_start
    , is in your tools), use the Browser pane instead of a separate window: the first time you show a design in the session, call
    set_up_open_design_browser_pane
    (once per project; tell the user once, in one sentence, that you added a preview entry to
    .claude/launch.json
    ), then start the
    open-design-preview
    configuration it names with that preview tool. The pane opens on the newest registered design and reloads when its files change. For a later design, reload the pane if your preview tools can, or tell the user it's in the pane's list. If the pane can't start, fall back to
    open_open_design_preview
    .
    In Claude Desktop Chat (a chat conversation, not the Code tab or a terminal), call
    show_open_design_artifact
    with the entry path instead: it shows the design inline in the conversation, where the user can comment and click Ask Claude to apply. Call it once per design, after its first
    register_open_design_artifact
    : that copy follows later edits and applied comments by itself, so don't show the same design again unless the user asks. The register result says which applies. If its result says the host doesn't show MCP Apps, fall back to
    open_open_design_preview
    as above. Its export buttons post a request in the chat: run
    export_open_design_artifact
    with the format named and tell the user the path. For an exploration, pass
    explorationId
    to show the directions side by side; when the user picks one with Take this one, ask which next step they want before calling
    choose_open_design_direction
    . A style-tile exploration also offers Use as design system, which asks directly for
    choose_open_design_direction
    with
    next: "save-design-system"
    .
    Picking by eye in Claude Desktop Chat. Two more tools are listed only where the host shows MCP Apps inline, so use them only when they are in your tool list:
    show_open_design_examples
    shows the remixable examples as a gallery of live previews (filter by
    query
    ,
    mode
    or
    surface
    ), and
    show_open_design_design_systems
    shows design systems as tiles (pass
    ids
    for a shortlist). Use them when the user wants to choose a starting example or a brand look and hasn't named one. Picks arrive as chat messages naming the tool to call: "Remix this" means
    remix_open_design_example
    with that skillId (ask what to make first if the user hasn't said); "Use this design system" means
    set_active_design_system
    with that id. Elsewhere, keep to
    list_open_design_skills
    and
    list_open_design_design_systems
    .
    Linking the public gallery. Some results carry a link to the Open Design gallery, a website with every example and design system:
    gallery.url
    from
    show_open_design_examples
    and
    show_open_design_design_systems
    , and
    designSystem.galleryUrl
    from
    register_open_design_artifact
    . They appear only while the gallery is live; never write a gallery link yourself. When the user is browsing (wants to look before deciding: "show me some examples", "what styles are there?", "ideas for a café menu"), show the in-chat gallery where it is in your tools, then add one line linking
    gallery.url
    ("See them all in the Open Design gallery."), unless you already linked the gallery in this conversation. When a design is ready and its register result has
    designSystem.galleryUrl
    , name the design system with that link in the sentence that says it's ready ("It uses the Kami design system."), the first time you use that design system in the conversation; not again for later rounds or designs in the same style. Never link the gallery before building on a concrete request ("a poster for our seed swap on Saturday"), after an export or publish, or in a recurring job run.
    Asking with taps in Claude Desktop Chat.
    show_open_design_questions
    is listed only where the host shows MCP Apps inline. Where it is in your tool list, ask every short multiple-choice question through it instead of a chat message: the surface and design-system questions before a build, which direction after an exploration, "fix these?" after a review. Up to four questions, each with a short
    id
    ,
    text
    , a
    kind
    (
    single
    ,
    multi
    or
    text
    ) and up to eight
    options
    ; an option can carry
    imageRef
    (
    designSystem:<id>
    ,
    example:<skillId>
    ,
    artifact:<entryPath>
    or
    checkRun:<entryPath>
    ), never a URL. Don't repeat the questions in chat. The answer arrives as a message starting "Answers:" with a line
    <!-- od-answers {...} -->
    : read that JSON (question id to option id, an array for
    multi
    , typed text, or
    you-pick
    , meaning choose for them and say what you chose). Accept typed answers too. The artifact view also has three quick replies under the design ("Looks good", "Change something", "Try another direction"); each posts a message saying what to do next. Elsewhere, ask in one chat message.
When a request says what the design is for but not what to make ("help me promote our seed swap", "something to get a UX job"), or is too vague to tell, call
list_open_design_skills
with
surface: "list"
: its
goals
are plain-language aims (Promote an event, Show an idea, Get hired…). Take the goal that fits, or show the goals (label and description) and ask one question, "What's it for?". Then call it with
goal
set to that id and continue with the surface marked
default
, asking which one only when the request doesn't settle it and the goal leads to several. Don't show the user the list of surfaces unless they ask what kinds of thing you can make.
When a request names a kind of thing to make (a prototype or landing page, app screens (a settings page, table, form, search or detail screen of a product, or a sign-in, onboarding, paywall or settings flow: surface
app-screens
, never
prototype
), mobile app, slides, document, wireframe, animation, résumé, research synthesis, data report, poster or flier, social post, diagram, 3D object), call
list_open_design_skills
with
surface
set to that kind first (
surface: "list"
shows the ids). Pick from its entries and follow the surface's prompt when it names one. Questions: a surface lists a few
questions
, each with
options
, a
default
and what the answer
changes
. Ask only the ones the request, the conversation and the workspace don't already answer: at most three in total, merged with any design-system recommender questions (surface ones first), in one message, as multiple choice, accepting "you pick" (then use the question's
default
). A request that already says enough gets no questions. Pass the answers to
prepare_open_design_brief
as
answers
(question id to answer) and what you decided without asking as
assumptions
(up to six short lines), then pass both, with the request in one line as
text
, to
register_open_design_artifact
as
brief
. When the design is ready, list the assumptions in one sentence and invite a change ("I assumed a dark theme and one sign-up button; say if you want otherwise"). A request for one specific template or style still goes straight to it. Never pick an entry marked
stub: true
: it only advertises an upstream skill and has no instructions here.
For engineering documents (an RFC, ADR, postmortem, PR explainer or changelog page), use the matching skill (
od:prototype:rfc
,
adr
,
postmortem
,
pr-explainer
,
changelog-page
). Gather the facts yourself first, from git (
git log
,
git diff
) and the files involved, and register what you read as
sources
. Never invent incident facts, dates or numbers: ask for them. To turn a folder of Markdown docs into pages, follow the docs flow (load the
open-design-docs
skill): one page per file, one template for the set, and on a re-run only the pages whose Markdown changed.
For a recurring design ("every week", "on a schedule", "each month from the new numbers") or a prompt that says "Run the Open Design job <path>", load the
open-design-recurring
skill: the job lives in
.open-design/jobs/<id>.job.md
, each run starts with
start_open_design_job_run
(stop when it returns
skip
) and ends with
finish_open_design_job_run
, and job runs never publish publicly or post to social networks.
If the request is based on a document (it names or attaches a report, spec, spreadsheet, PDF or existing deck, or points at repository files such as
CHANGELOG.md
,
docs/adr/
, an RFC or a metrics CSV), generate from it rather than from memory: pass those workspace paths as
sources
to
prepare_open_design_brief
. Typical examples: "a release deck from CHANGELOG.md", "an architecture review from docs/adr/", "a board update from metrics/q3.xlsx", "turn docs/q3-report.docx into a pitch". The tool extracts each document (DOCX, PPTX, XLSX, PDF with
pdftotext
, Markdown, text, CSV) to Markdown and returns instructions that make you write an outline first and stop for the user's approval before building. Follow them: read the extracted text by line range, write
outline.md
, show it, and wait (unless the user said to just build it). Then register with the same
sources
; its result lists numbers on the page that it couldn't find in the sources, so check and fix each one. Use
read_open_design_source
on its own to look inside a document before deciding how to use it. For a whole folder of files (such as
docs/adr/
), pass the relevant files individually (up to 10).
When the user wants to choose colors and fonts, a palette or a type pairing, or a look for a new brand ("show me some color and type options", "what could our brand look like?"), run the exploration with the style-tile skill (
skillId: "od:design-system:style-tile"
): it makes compact tiles (palette with contrast, type specimen, components) instead of pages, 4 by default. To vary the active design system rather than replace it ("the same but warmer"), use
axis: "custom"
with one direction per variation. When the user picks a tile, call
choose_open_design_direction
with
next: "save-design-system"
: the tile's tokens are copied verbatim into the new system, which then becomes active.
If the user explicitly asks for options to compare ("show me three directions for…", "a few different versions of…", "explore some alternatives", "I'm not sure what style I want, show me options"), run a design exploration instead of steps 3–5. Don't explore for an ordinary request ("design a pricing page"): it costs several generations.
  1. Call
    prepare_open_design_exploration
    with the
    skillId
    and the user's
    brief
    (and
    count
    2–4 if they gave a number; default 3). The tool picks deliberately different directions itself: visual styles when no design system is active, layout/narrative structures when one is (so the brand is kept), or pass
    axis: "custom"
    with
    customDirections
    when the user named what should vary ("three hero concepts"). Pass
    directionIds
    only when the brief's tone clearly calls for specific ones (e.g.
    editorial-monocle
    for a magazine,
    brutalist-experimental
    for an art or agency site). If the result says the active design system was set aside, tell the user.
  2. For each returned direction, follow
    sharedInstructions
    followed by that direction's own
    instructions
    , write its file at its
    suggestedEntryPath
    , and call
    register_open_design_artifact
    with the
    explorationId
    and that direction's
    directionId
    . Directions are quick sketches (one screen, or a cover plus two slides), not full builds. If you can delegate work to sub-agents, generate the directions in parallel, passing each one
    sharedInstructions
    plus its own
    instructions
    .
  3. Call
    compare_open_design_exploration
    with
    contactSheet: true
    . If you can view images, open the contact sheet and check the directions really look different (layout and hero pattern, not just colour); regenerate any that resembles another.
  4. Show the user the comparison page path (
    compareFile
    ; it opens in any browser straight from the file system and shows every direction side by side) and the contact sheet path, each on its own line, briefly describe how each direction differs, and ask which one to take forward (through
    show_open_design_questions
    where it is in your tools, with each direction as an option and
    imageRef: "artifact:<its entry path>"
    ).
  5. When the user picks one, call
    choose_open_design_direction
    with
    next
    :
    build-out
    (build the chosen sketch out at full fidelity),
    merge
    (the same, taking named aspects from other directions via
    mergeFrom
    , e.g. "B with A's hero"), or
    save-design-system
    (turn the direction into a reusable custom design system). Follow the returned
    instructions
    and register the result as they say.
Generated artifacts land under the project's Open Design output directory (default
.open-design/
) so they stay visible and trackable in version control like any other project file. After registering or updating an artifact, tell the user where it was written, with its workspace-relative entry path (e.g.
.open-design/coffee-poster/coffee-poster.html
) on its own line: in Claude Desktop's Code tab, clicking that path opens it in the Browser pane. Don't open the HTML file in a browser yourself:
open_open_design_preview
(or
show_open_design_artifact
in Claude Desktop Chat) is how it is shown.
Comments from the preview. When the user says they left comments (or pastes the preview's "Apply my comments" instruction, or the inline preview posts it), call
get_open_design_artifact
for that entry. Its
openComments
lists each comment's note and the element it points at (
selector
,
text
,
htmlHint
,
rect
); screenshots of up to 4 commented elements are attached as images, and every comment's
screenshot
path is listed. Change only those elements, with your own file-editing tools, then call
register_open_design_artifact
again with the comments' ids as
resolvedCommentIds
so their pins leave the preview, and run the check as in step 6. In Claude Desktop Chat, the inline copy updates by itself; tell the user it's updated rather than showing it again.
If the user wants to start from or riff on an existing example rather than build something new, prefer
remix_open_design_example
(skillId must be an entry with
remixable: true
) over
prepare_open_design_brief
— it copies a working starting artifact into the project and tells you to modify it rather than regenerate from scratch. See references/remixable-examples.md for the full list of what's available to remix, grouped by mode — check it before calling
list_open_design_skills
with
remixableOnly: true
if a quick skim already answers the question.
If the user wants a brand/style that isn't one of the ~150 bundled design systems ("use our own brand colors", "match our website", "set up a custom design system for..."), call
create_open_design_design_system
with a
name
, a
brief
describing the brand, and an optional
sourceUrl
if they gave you a website to match. It returns
instructions
for writing a new
DESIGN.md
yourself (same file shape as every bundled design system) plus, when a
sourceUrl
was given, a best-effort extracted starting palette/font list to incorporate — treat that as a rough starting point, not ground truth. It does NOT write any files. After writing the file, call
set_active_design_system
with the returned
id
— there's no separate "register" step for design systems; a written
DESIGN.md
is immediately selectable, the same way generated artifacts are immediately visible once written.
Once the user is happy with a generated or refined artifact and wants it turned into real, working code in this app ("turn this into a real component", "add this to the app", "wire this into my codebase"), call
port_open_design_artifact_to_app
with the artifact's
entryPath
. It returns
instructions
for reproducing the artifact's design as idiomatic code in this project's actual application — read the returned instructions carefully: they'll tell you to find and follow a real existing component in this codebase as your pattern reference (its styling approach, conventions, file organization) rather than copying the artifact's HTML/CSS verbatim, and to leave routing/navigation wiring as a separate step for the user. It does NOT write any files itself.
Working with Impeccable. After porting, if a skill named
impeccable
is in your own skill list, end your reply with one suggestion: run
/impeccable polish
(or
/impeccable audit
) on the component you just wrote. Say nothing about Impeccable when you don't have that skill. In a code project, once you've set a design system there and the project has no
DESIGN.md
, you may offer once to save it as the project's
DESIGN.md
so other tools can read it; when the user agrees, call
set_active_design_system
again with
writeProjectDesignMd: true
(it never overwrites an existing file).
When the user wants reusable components rather than one page in the app ("make Material 3 components for my React app from this", "a component library from this design", "an MUI / shadcn set for these screens"), call
prepare_open_design_component_library
instead, with the artifact's
entryPaths
(or the
collectionId
for every screen) and
library
mui
,
shadcn
or
auto
. Follow its stages in order: write the
components.md
inventory and stop for the user's yes before any code, use the generated theme as is, wrap the library's own components, add the gallery, run the app's type check, then call the tool again with
record
. It writes no app code itself. "Material 3" means
mui
.
When the artifact is meant to be posted or uploaded as an image (an X/Twitter post, Instagram or LinkedIn image, Xiaohongshu cards, a YouTube thumbnail, a poster), call
export_open_design_artifact
with its
entryPath
after registering it. It renders the artifact in a headless browser and writes PNG/JPEG file(s) under the artifact's own
exports/
folder, sized from the source skill automatically unless you pass
width
/
height
. For multi-card designs, give each card a
data-od-card
attribute and pass
selector: "[data-od-card]"
to get one numbered image per card. Pass
maxBytes
with the platform's upload limit (X 5000000, YouTube thumbnail 2000000, Instagram 8000000). Tell the user the exported file paths. For any social-post request ("make an X post…", "an Instagram carousel…", "a YouTube thumbnail…"), load the
open-design-social-post
skill first. It maps each platform and format to the right canvas size, skillId and export arguments (and asks the user which platform when that's unclear), then walks through generate → register → export. Animated designs (motion frames, title cards, animated charts, sprite or WebGL animations) export as video or GIF: call
export_open_design_artifact
with
format: "mp4"
,
"webm"
or
"gif"
. Time runs on a virtual clock, so the frames are exact and the same on every run; the length comes from the page (
data-duration
frames or the longest animation) unless you pass
duration
. Before exporting, call
check_open_design_artifact
with
at
(e.g.
[0, 1.5, 3]
) to see the start, middle and end. Export needs an installed ffmpeg: if it reports
no-ffmpeg
or
ffmpeg-missing-encoder
, tell the user what to install rather than trying another way. Compositions built with the HyperFrames framework are the exception: the brief's own instructions render them with the HyperFrames CLI. After registering a slide deck, offer to export it as PowerPoint or PDF, and when the user wants that, call
export_open_design_artifact
with
format: "pptx"
or
"pdf"
(one full-bleed image per slide: exact, but not editable). When the user wants slides they can edit (in PowerPoint, Keynote, Google Slides or Canva), add
editable: true
to the
pptx
export: text boxes, shapes and pictures they can change, close to the deck but not identical, with gradients, SVG diagrams and effects kept as a background picture. Tell them what the result lists as staying a picture and which fonts they need installed. Never write your own conversion script for this.
format: "pdf"
on an ordinary page prints it as a vector PDF.
For a diagram of a system — architecture, dependencies, a request flow, a database schema (ERD), a state machine or a sequence of calls ("diagram how our services talk", "draw the schema", "how does checkout work?") — use the
diagram
skill (
od:prototype:diagram
, or remix its example
od:prototype:diagram:example
). Read the relevant code first and draw only what you read. Write nodes with
data-rank
/
data-lane
and hidden links, never coordinates, then call
add_open_design_diagram_runtime
(it inserts the layout runtime; never write that script yourself), register with kind
diagram
and the files you read as
sources
, and check it. When a later check or
get_open_design_artifact
reports that its sources changed, offer to redraw it.
For a 3D object — a product shot, a 3D logo, a turntable, or the user's own
.glb
/
.gltf
model ("make a 3D render of our bottle", "turn the logo into 3D", "a product shot of models/headphones.glb") — use the
3d-object
skill (
od:prototype:3d-object
). It's one three.js scene with studio lighting, materials from the design system's tokens, a ground shadow and a turntable. Load three.js exactly as the skill says (its import map for the pinned
three@0.160.0
module build): older
three.min.js
and
examples/js
script tags no longer exist and leave the page blank. Copy a user's model under
assets/
next to the design and load it with
GLTFLoader
, framing the camera from its bounding box. The page must expose
window.odScene
(
ready
, resolved after a direct render once everything has loaded, and
rotate
); exports and checks turn on software WebGL and wait for it. Fix
webgl
findings before exporting. For a cut-out to place on slides or pages, export
format: "png"
with
transparent: true
from a scene with no background; for a turntable,
format: "mp4"
or
"gif"
with
duration
equal to one rotation.
For an HTML email (newsletter, launch or product-update email), use the
email-campaign
skill: it builds a table-based, inbox-safe email marked
data-od-email
. Check it, then export with
export_open_design_artifact
and
format: "email"
(add
baseUrl
once the user has hosted the
assets/
folder, so image URLs become absolute), and tell the user to send themselves a test before sending to a list. When the user wants a design pasted into another editor (a WeChat Official Account article, a Notion page, a newsletter tool), export with
format: "paste"
and
target
wechat
,
notion
,
newsletter
or
generic
; styles are inlined from what the browser rendered. To use either file, the user opens it in a browser, selects all and copies.
For a campaign (one message across several channels or sizes, ad banners in several sizes, or the same creative in several languages), load the
open-design-campaign
skill first: agree a copy deck saved as a CSV, build one fluid master bound to it with
data-od-field
(headline and subhead marked
data-od-fit
for long translations), check every chosen shape per row, and export with
presets
,
data
and
campaignSheet: true
.
For a poster, flyer, certificate or other print piece, or when the user wants an existing design in other sizes or as a print-ready PDF, load the
open-design-poster
skill first. In short: ask print or screen and which size if unclear; pass that canvas
format
(e.g.
a3
,
a2
,
ig-portrait
,
story
) with
fluid: true
to
prepare_open_design_brief
and the same
format
to
register_open_design_artifact
(a fluid poster reflows to any shape, so the size can change later); make any QR code with
create_open_design_qr_code
(never draw a fake one); run
check_open_design_artifact
and fix every preflight error; then export with
preset
set to the format id (print formats give a PDF with bleed, trim and bleed boxes).
presets
exports several shapes at once and
shapeSheet: true
shows them all in one image;
adapt_open_design_artifact
tunes a shape that looks wrong (in place, for fluid posters), and
data
on the export makes one file per row of the user's spreadsheet. Print PDFs are RGB: say so.
When the user wants to share a design with people who don't have this project open: for a link ("publish this", "deploy it", "give me a link to send the team", "host it somewhere"), call
publish_open_design_artifact
with its
entryPath
(pass
provider
only if they already said where; otherwise it returns the choices to show them). It builds a deploy-ready folder and returns step-by-step instructions to run with your terminal under the user's own CLI login, or as a temporary no-account link. Follow them exactly: they stop for the user's explicit yes before anything goes online, and after a successful deploy you call the tool again with
published
to record the link. For a single file to attach or send ("export it as one HTML file"), call
export_open_design_artifact
with
format: "standalone"
instead; nothing goes online. The
open-design-publish
skill walks through the whole flow.
For Figma: to turn a frame into code, call
pull_open_design_figma_frame
with the frame link ("Copy link to selection"); to put a finished design into Figma as editable layers, call
push_open_design_artifact_to_figma
with its
entryPath
. Both work through the user's Figma connection, and fall back to the Figma import plugin.
When a step would hand work to another service (import into Canva, read or push a Figma frame, save to Google Drive, write a Notion page, share in Slack, or post to a social network), call
list_open_design_integrations
first with the
capability
(plus
platform
for a social post). Then:
  1. Check your own tools for one matching the returned patterns, including deferred or on-demand tools you can search for. If one is there, use it, calling its tools by their server-defined names (e.g. Canva's
    import-design-from-url
    ).
  2. If none is, offer to set up the first provider, once per conversation and only when the step needs it: say what it does and what sign-in it needs. Only after the user says yes, follow the returned setup steps (user-level configuration only). Never install silently, and never ask for an API key or write one into a file: the user sets it themselves.
  3. Help the user sign in and reload if needed, then confirm by listing your tools.
  4. If the user declines or setup fails, carry on with the workflow's manual path.
Anything that publishes, sends or posts on the user's account still needs their go-ahead first.
<!-- generated:open-design-agent-kit -->
Open Design 是一套内置的 design skills 和 design templates 目录(可复用的任务配方和渲染样式,两者均可互换使用并作为
skillId
),同时还包括 design systems(受品牌启发的视觉 token 集),并通过
open-design
MCP server 提供的工具对外开放。
每个 skill/template id 的命名空间格式均为
od:<mode>:<name>
(例如
od:deck:guizang-ppt
),其中
mode
的取值为:
prototype
、
deck
、
design-system
、
image
、
video
、
template
、
utility
、
audio
。始终将完整的命名空间 id 作为
skillId
传入。注意:mode
design-system
表示“一种帮助创作 design-system 交付物的 skill”,它与
designSystemId
无关;后者用于从另一个包含约 150 套预构建品牌 design systems 的库中选择(参见步骤 2)。
一小部分经过精心筛选的 skills/templates 还拥有各自明确的
/open-design:<id>
skill。如果用户的请求与其中某项高度匹配,应优先直接调用;它会锁定准确的 skillId,通常还会提供现成的示例 brief,从而避免不必要的猜测。否则,请自行遵循下面的流程。
所有 Open Design 内容(skill/template 文本、design system tokens、示例 brief)都通过下面的 MCP 工具调用以纯文本形式提供给你,而不会以文件路径形式提供。你永远不需要,也不应该在磁盘上的任何位置浏览或搜索 Open Design 自身的文件;
list_open_design_skills
和
prepare_open_design_brief
已经会将以纯文本形式返回所需的一切内容。
<!-- voice:start -->
如何与用户沟通。 许多使用 Open Design 的人不写代码,因此:
  • 使用用户自己的措辞。如果用户说了“artifact”“design tokens”或给出了一个文件路径,请沿用这些术语;否则使用下面的通俗说法。
  • 回复中不要暴露内部机制:不要提及工具名称、不要出现
    od:prototype:poster-hero
    之类的 id、不要提及内部文件(
    .artifact.json
    、
    .comments.json
    、
    config.json
    ),也不要使用“register”“manifest”“sidecar”“entry”或“surface”等词,除非用户先使用了这些词。
  • 印刷术语第一次出现时,用一个简短从句进行解释,之后不再重复。
  • 说明用户会在哪里找到文件(例如“在你的 Open Design 文件夹下的 seed-swap-flyer 中”)。只有在用户可以点击文件路径(Claude Code、Claude Desktop 的 Code 标签页、VS Code)或用户主动要求时,才提供原始路径。
  • 每个完成某一步骤的回复,都应以一行说明用户接下来可以做什么,并且最多提供两个选项(例如“还需要 Instagram 尺寸的版本,还是已经可以印刷了?”)。
不要使用改为使用
artifact、entry、registered你的设计,已保存
design system、active design system你的风格(第一次提到时说:“一套已保存的样式:颜色、字体和间距”)
surface、skill、template、recipe设计类型、起始布局,或不提及
workspace、output directory你的文件夹、你的 Open Design 文件夹
bleed印刷边缘(“多出几毫米、供印刷时裁切的部分”)
trim size最终尺寸
preflight findings、errors“我已经检查并修复了……”、“有一点需要留意:”
export保存为 PDF、保存为图片
inline preview、MCP App上方预览
<!-- voice:end -->
请遵循以下流程:
  1. 检查工具是否已连接。 此 skill 本身无法执行任何操作——下面的每个步骤都需要调用
    open-design
    MCP server 提供的工具。如果你当前无法使用
    list_open_design_skills
    (或下文提到的任何其他工具),说明该 server 尚未在当前项目中注册。请先完成设置,然后从步骤 1 重新尝试:
    • **Claude Code:**引导用户查看 Claude Code 中的设置步骤。
    • **Codex CLI:**引导用户查看 Codex 中的设置步骤。
    • **其他支持 MCP 的 agent(Cursor 等):**引导用户查看 Getting started,其中说明了如何将 Open Design MCP server 添加到任意 agent。
    • Claude Desktop Chat 或 claude.ai(聊天中没有 Open Design 工具):此时不要创建任何内容。使用通俗语言按以下形式欢迎用户:
      Open Design 目前无法在此聊天中保存或检查设计。可以通过两种方式解决:
      1. **连接文件夹:**创建一个名为“Open Design”的文件夹(例如放在 Documents 中),然后点击此聊天中的 +,选择 Add folder,然后选中该文件夹。
      2. **为 Claude Desktop 安装 Open Design 扩展:**从 https://github.com/feimacode/open-design-agent-kit/releases/latest 下载文件,双击该文件,然后开始一段新聊天。
      你想设计什么?
      在这段话中不要提及文件类型、软件包、命令或工具名称。将步骤 1 中的目标作为用户可以表达的示例(“推广一场活动”、“展示一个想法”、“获得工作机会”)。只有当用户明确表示不采用上述任何方式但仍想继续时,才使用你自己的 Artifact 工具创建并发布一个自包含的 HTML 页面,同时说明它无法使用已保存的样式、无法进行检查,也无法保存为 PDF 或图片。
    如果你拥有 shell 访问权限,请自行运行命令;否则,告诉用户需要运行的确切命令,并等待用户确认后再继续。工具可用后,直接跳过此步骤。
    在 Claude Desktop 中(聊天会话或用户已连接文件夹的 Cowork 会话),server 会在用户的计算机上运行,并从用户的主文件夹启动,而你的文件工具会在另一个路径下看到该文件夹。在调用任何其他 Open Design 工具之前,先调用
    set_open_design_workspace
    ,并传入该文件夹在用户计算机上的路径(即
    get_device_info
    在
    connectedFolders
    下列出的路径)。其他工具返回的所有路径都相对于该文件夹:读写文件时,应将该路径拼接到你看到的文件夹路径上;附加或显示文件时,应提供完整路径,因为相对路径会根据 shell 当前目录进行解析,而该目录会随
    cd
    发生变化。如果某个工具提示自己将在主文件夹中工作,它需要的就是这个文件夹。首次在聊天中设置文件夹时,用一句话告诉用户设计将保存在哪里(文件夹名称及其内部的
    Open Design
    文件夹),并说明用户随时可以打开;后续设计无需重复。
    在未连接文件夹的 Claude Desktop Chat 中(你的工具中存在
    use_open_design_managed_workspace
    ),你自己的文件工具无法访问 server 的文件(即使存在此类工具)。先调用
    use_open_design_managed_workspace
    ,为设计提供一个简短名称,并用一句话告知用户其结果中给出的文件夹绝对路径(默认位于
    ~/Documents/Open Design/
    下),以便用户打开。随后,使用
    write_open_design_file
    保存每个设计文件(每次写入完整文件,并放在输出目录下),不要使用自己的文件工具;然后照常注册、检查和导出。调用
    show_open_design_artifact
    一次以显示设计;后续轮次会自动更新该内联副本。不要在这里为每一轮单独保留 Claude artifact 预览。托管文件夹是唯一可信来源:要修改设计,请通过
    write_open_design_file
    发送完整的新文件。如果聊天中已连接文件夹,则改用
    set_open_design_workspace
    。
  2. 调用
    list_open_design_skills
    (可选择传入
    query
    和/或准确的
    mode
    ),查找与用户需求匹配的 skill 或 design template。根据名称、描述和触发条件选择最佳匹配项。如果某个结果包含
    examplePrompt
    且与用户需求高度契合,应优先在适配用户具体需求后使用该示例,而不是自行编写 brief。
  3. 项目中持久化存在一个active design system,保存在本地
    .open-design/config.json
    文件中。如果用户提到了品牌、公司、行业或与当前 active design system 不同的视觉风格,请调用
    list_open_design_design_systems
    (可选择传入
    query
    和/或准确的
    category
    ——首先不传参数以查看分类,并检查每个结果的
    active
    标记)来寻找合适的 design system,并将其 id 明确传给
    prepare_open_design_brief
    ;这样它也会成为此后该项目中默认使用的新 active design system,因此后续请求无需再次指定。对于手机屏幕(Mobile app surface,或类似“感觉像 Monzo 的记账 app”之类的 brief),请先查看
    Mobile Apps
    分类,并以 app 名称作为
    query
    :这些 design systems 根据真实的 iOS app 进行了调整(标签栏、底部面板、iOS 字号)。手机屏幕应使用
    <app>-ios
    (例如
    spotify-ios
    ),即使同名品牌也存在 web design system(如
    spotify
    );web 页面仍应使用 web 版本。如果用户没有提出任何方向且已有 active design system,只需在
    prepare_open_design_brief
    中省略
    designSystemId
    ,它会使用当前 active design system。如果没有 active design system,且用户也没有指定方向,请在准备新设计之前先推荐一个(编辑、remix 或导出除外):调用
    recommend_open_design_design_systems
    ,根据请求、对话和 workspace 中已知的信息传入
    industries
    、
    moods
    、
    theme
    、
    surface
    、
    likeBrands
    、
    brief
    ,未知项不要填写。如果结果包含
    questions
    ,应一次性以简短的多选项形式询问:工具中存在
    show_open_design_questions
    时使用该工具,否则在一条消息中询问(或使用宿主提供的 question 工具),并允许用户选择“你来定”;收到答案后再次调用该工具。如果还要询问 surface 问题,应在同一条消息中提出,总问题数最多为三个。展示推荐列表:工具中存在
    show_open_design_design_systems
    时传入推荐的
    ids
    ;否则用简短编号列表展示每个名称及其理由。无需再等待一次明确选择:直接采用第一个推荐,将其 id 传给
    prepare_open_design_brief
    ,并告诉用户使用了哪种风格,同时说明用户可以改选。如果工具中没有
    recommend_open_design_design_systems
    ,则改用
    list_open_design_design_systems
    ,或者不指定 design system。只有当用户希望在生成任何内容前固定某种外观时(例如“以后都使用 Starbucks 的风格”),才直接调用
    set_active_design_system
    。
  4. 调用
    prepare_open_design_brief
    ,传入选定的
    skillId
    、可选的
    designSystemId
    (按步骤 2 确定)以及用户的
    brief
    (用用户自己的原话表述)。它会返回需要遵循的
    instructions
    、
    suggestedEntryPath
    ,以及实际使用的
    designSystemId
    /
    designSystemName
    (无论是显式指定还是使用默认值);如果从对话中无法明显看出使用了哪个 design system,应说明这一点。该工具不会写入任何文件。
  5. 遵循返回的
    instructions
    ,使用你自己的文件编辑工具亲自创作 artifact 的入口文件(以及所有支持文件)。不要寻找其他单独的工具来写入设计内容。
  6. 调用
    register_open_design_artifact
    ,传入入口路径、
    kind
    、
    title
    和所有
    supportingFiles
    ,以便系统识别该 artifact 并为其写入 manifest sidecar。
  7. 在告诉用户完成之前,调用
    check_open_design_artifact
    并传入入口路径(创建 artifact 后执行一次,进行实质性编辑后再次执行)。它会渲染 artifact,并返回截图和 preflight findings:修复每一个 error,然后查看截图,找出检查工具无法衡量的问题——平衡、层级、拥挤或空洞的区域、文字压在繁忙图像之上等——并修复明显有误之处。审美警告(
    slop-glow
    、
    card-row
    、
    uniform-surface
    、
    type-scale
    、
    intent
    )也值得检查:除非 brief 或 design system 明确要求这种效果,否则应予以修复;绝不能仅为了消除警告而添加
    data-od-allow
    。修复后重新检查,但最多进行两轮修复;如果仍有遗留问题,应告知用户。**随后,在宣布完成前再获取一次独立意见:**检查结果干净或修复轮次用尽后,运行
    open-design-critique
    skill,让一名全新的 critic 根据 brief 和 design system 对最新一次检查进行评判,涵盖目的与层级、排版、颜色与对比度、布局与节奏、文案、状态和适配度;构建时就应考虑这些方面。只进行一轮 critique:如果结果为
    polish
    ,应用其修复建议一次,重新注册并检查,然后报告完成,不再进行另一轮 critique;如果结果为
    rework
    ,告诉用户存在的问题,并在重建前征求同意;如果结果为
    ship
    ,则已经完成。brief 或 design system 的要求优先于与指定风格相冲突的评审意见,用户可以随时要求另一轮意见,也可以表示不需要。**3D 设计是例外:**当检查返回 3D review sheet 时,检查结果干净并不代表结束。按检查结果要求获取 critique(
    3d-object
    skill 的评分表;如果宿主支持,则使用 subagent),然后修复、重新检查并重新 critique,最多进行三轮 critique;这些轮次取代前述两轮修复上限和额外意见环节。除非用户主动询问,否则不要向用户描述截图:每次运行的截图都会保存供用户查看,浏览器预览的 Checks 面板会在修改前后展示它们(结果中也会列出保存路径)。如果返回
    no-browser
    ,跳过检查,并告知用户一次:视觉检查需要安装 Chrome、Edge 或 Chromium。
  8. 可以选择调用
    get_open_design_artifact
    ,确认已写入的内容,然后再告诉用户完成。
  9. 在会话中首次注册 artifact 后,除非用户明确表示不需要预览,否则调用
    open_open_design_preview
    并传入其入口路径。它会打开实时浏览器预览,并在文件发生变化时自动重新加载,因此编辑后不要再次调用;只有切换到另一个 artifact 时才再次调用。告诉用户可以点击预览中的 Comment 为元素留下评论。
    在 Claude Desktop 的 Code 标签页中(其预览工具名称类似
    preview_start
    ),使用 Browser 面板而不是单独的窗口:会话中第一次显示设计时,调用
    set_up_open_design_browser_pane
    (每个项目一次;用一句话告诉用户,已在
    .claude/launch.json
    中添加一个预览入口),然后使用该预览工具启动它指定的
    open-design-preview
    配置。面板会打开最新注册的设计,并在文件变化时重新加载。对于后续设计,请重新加载面板(如果预览工具支持),或者告诉用户该设计已出现在面板列表中。如果面板无法启动,则回退到
    open_open_design_preview
    。
    在 Claude Desktop Chat 中(聊天对话,而非 Code 标签页或终端),改为调用
    show_open_design_artifact
    并传入入口路径:它会在对话中内联显示设计,用户可以发表评论并点击 Ask Claude to apply。每个设计在首次调用
    register_open_design_artifact
    后调用一次:该副本会自动跟踪后续编辑和已应用的评论,因此除非用户要求,不要再次显示同一设计。注册结果会说明当前宿主支持哪种方式。如果结果提示宿主无法显示 MCP Apps,则回退到上述
    open_open_design_preview
    。它的导出按钮会在聊天中发来请求:运行
    export_open_design_artifact
    并使用按钮指定的格式,然后告知用户文件路径。对于 exploration,传入
    explorationId
    以并排展示各个方向;当用户通过 Take this one 选择后,先询问下一步想做什么,再调用
    choose_open_design_direction
    。style-tile exploration 还会提供 Use as design system,此时直接调用
    choose_open_design_direction
    ,并设置
    next: "save-design-system"
    。
    在 Claude Desktop Chat 中通过视觉方式选择。 以下两个工具仅在宿主支持内联显示 MCP Apps 时才会列出,因此只有工具列表中确实存在时才使用:
    show_open_design_examples
    会以实时预览图库的形式展示可 remix 的示例,可按
    query
    、
    mode
    或
    surface
    筛选;
    show_open_design_design_systems
    会以图块形式展示 design systems,并接受
    ids
    以显示候选列表。当用户希望选择起始示例或品牌风格,但尚未指定具体选项时,使用这些工具。用户的选择会以聊天消息的形式返回,并注明要调用的工具:“Remix this”表示对带有
    skillId
    的条目调用
    remix_open_design_example
    (如果用户还没说想做什么,先询问);“Use this design system”表示调用
    set_active_design_system
    并传入该 id。在其他环境中,继续使用
    list_open_design_skills
    和
    list_open_design_design_systems
    。
    链接到公开图库。 有些结果会带有 Open Design 图库链接。该图库是一个展示所有示例和 design systems 的网站:图库 url 来自
    show_open_design_examples
    和
    show_open_design_design_systems
    的
    gallery.url
    ,design system url 来自
    register_open_design_artifact
    的
    designSystem.galleryUrl
    。这些链接仅在图库在线时出现;绝不要自行编写图库链接。当用户正在浏览时(想先看看再决定,例如“给我看一些示例”、“有哪些风格?”或“咖啡馆菜单可以有哪些创意?”),如果工具支持,就在聊天中显示图库,然后添加一行
    gallery.url
    链接(“可在 Open Design 图库 中查看全部内容。”),除非本次对话中已经提供过该链接。当设计准备就绪且注册结果包含
    designSystem.galleryUrl
    时,应在宣布准备就绪的那句话中带上链接并注明 design system(例如“它使用了 Kami design system。”);同一对话中首次使用该 design system 时这样做即可,后续轮次或使用相同风格的其他设计无需重复。在用户提出具体请求之前(例如“设计一张周六种子交换活动海报”),在导出或发布之后,或者在定期任务运行中,绝不要链接图库。
    在 Claude Desktop Chat 中通过点击操作提问。 只有当
    show_open_design_questions
    出现在工具列表中时,才使用它;此时所有简短多选问题都应通过该工具提出,而不是在聊天消息中提出。构建前询问 surface 和 design-system 问题,exploration 后询问方向问题,review 后询问“是否修复这些问题?”。最多四个问题,每个问题包含简短的
    id
    、
    text
    、
    kind
    (
    single
    、
    multi
    或
    text
    )以及最多八个
    options
    ;选项可以携带
    imageRef
    (
    designSystem:<id>
    、
    example:<skillId>
    、
    artifact:<entryPath>
    或
    checkRun:<entryPath>
    ),但绝不能使用 URL。不要在聊天中重复这些问题。答案会以一条以
    Answers:
    开头的消息返回,并包含一行
    <!-- od-answers {...} -->
    :读取其中的 JSON(问题 id 对应选项 id,
    multi
    对应数组,文本类型对应输入文本,
    you-pick
    表示由你代为选择并说明选择结果)。也接受用户输入的文字答案。artifact 视图下方还有三个快捷回复(“Looks good”、“Change something”、“Try another direction”);每个回复都会发布一条说明下一步操作的消息。在其他环境中,应在一条聊天消息中提出所有问题。
当请求说明了设计用途但没有说明要制作什么时(“帮我们推广种子交换活动”、“做点能帮我获得 UX 工作机会的东西”),或者请求过于模糊、无法判断时,使用
surface: "list"
调用
list_open_design_skills
:其
goals
是用通俗语言描述的目标(推广活动、展示想法、获得工作机会等)。选择符合要求的目标,或者展示这些目标(名称和描述)并询问一个问题:“这是用来做什么的?”。随后将该目标的 id 作为
goal
再次调用,并以
default
标记 surface;仅当请求本身无法确定具体形式且该目标对应多个选项时,才进一步询问用户。不要向用户展示 surface 列表,除非他们询问可以制作哪些类型的内容。
当请求明确指出了要制作的种类时(原型或落地页、app 屏幕(产品中的设置页、表格、表单、搜索页或详情页,或登录、引导、付费墙、设置流程:应使用 surface
app-screens
,而不是
prototype
)、移动 app、幻灯片、文档、线框图、动画、简历、研究综述、数据报告、海报或传单、社交帖子、图表、3D 对象),首先使用相应的
surface
调用
list_open_design_skills
(使用
surface: "list"
可以查看 ids)。从结果中选择合适条目;如果该 surface 指定了某个 prompt,应遵循该 prompt。**问题:**每个 surface 会列出少量
questions
,每个问题都包含
options
、
default
以及回答会改变的
changes
字段。只询问请求、对话和 workspace 尚未回答的问题:与 design-system 推荐器的问题合并后,总数最多三个,并在一条消息中以多选形式提出,允许用户选择“你来定”(此时使用该问题的
default
)。如果请求本身已经足够明确,则不要提问。将答案作为
answers
(问题 id 到答案的映射)传给
prepare_open_design_brief
,将无需询问便自行决定的内容作为
assumptions
(最多六条简短说明)传入;然后在调用
register_open_design_artifact
时,将二者连同用户请求的单行文本一起作为
brief
传入。设计准备就绪后,用一句话列出所做的假设,并邀请用户提出修改(“我采用了深色主题和一个注册按钮;如果你想要其他效果,请告诉我。”)。如果用户明确要求某一个特定 template 或 style,仍应直接使用它。绝不要选择标记为
stub: true
的条目;它只是在宣传上游 skill,本身不包含任何 instructions。
对于工程文档(RFC、ADR、postmortem、PR 变更说明或 changelog 页面),使用匹配的 skill(
od:prototype:rfc
、
adr
、
postmortem
、
pr-explainer
、
changelog-page
)。先自行收集事实,来源包括 git(
git log
、
git diff
)和相关文件,并将读取到的内容注册为
sources
。绝不要虚构事故事实、日期或数字:应向用户询问。要将一个 Markdown 文档文件夹转换为页面,请遵循 docs flow(加载
open-design-docs
skill):每个文件对应一个页面,整组页面使用同一个 template,重新运行时仅处理 Markdown 已发生变化的页面。
对于定期设计(“每周”、“按计划”、“每月根据新数据”)或提示中写着“Run the Open Design job <path>”的请求,请加载
open-design-recurring
skill:job 位于
.open-design/jobs/<id>.job.md
,每次运行都先调用
start_open_design_job_run
(如果返回
skip
则停止),最后调用
finish_open_design_job_run
;job 运行绝不会公开发布,也不会发布到社交网络。
如果请求基于某个文档(提到或附上报告、spec、spreadsheet、PDF、现有 deck,或者指向 repository 文件,如
CHANGELOG.md
、
docs/adr/
、RFC 或 metrics CSV),应基于该文档生成,而不是凭记忆生成:将这些 workspace 路径作为
sources
传给
prepare_open_design_brief
。典型示例包括“根据 CHANGELOG.md 制作发布 deck”、“根据 docs/adr/ 制作架构评审”、“根据 metrics/q3.xlsx 制作董事会更新”、“把 docs/q3-report.docx 变成 pitch”。该工具会将各类文档(DOCX、PPTX、XLSX、通过
pdftotext
处理的 PDF、Markdown、文本、CSV)提取为 Markdown,并返回 instructions,要求你先编写 outline 并停下来等待用户批准,然后再进行构建。遵循这些 instructions:按行范围读取提取出的文本,编写
outline.md
,向用户展示并等待确认(除非用户明确表示直接构建)。随后使用相同的
sources
注册;结果会列出页面上无法在 sources 中找到的数字,因此应逐一检查和修复。可以单独使用
read_open_design_source
查看文档内容,再决定如何使用。对于整个文件文件夹(如
docs/adr/
),请逐个传入相关文件(最多 10 个)。
当用户希望选择颜色和字体、配色方案、字体搭配,或为新品牌确定风格(“给我看看颜色和字体方案”、“我们的品牌可以是什么样子?”),请使用 style-tile skill(
skillId: "od:design-system:style-tile"
)运行 exploration:它会生成紧凑的图块(包含对比度的调色板、字体样张和组件),而不是完整页面,默认生成 4 个。如果要在 active design system 的基础上变化,而不是替换它(例如“同样的风格,但更温暖”),使用
axis: "custom"
,并为每种变化指定一个方向。用户选定某个图块后,调用
choose_open_design_direction
并设置
next: "save-design-system"
:该图块的 tokens 会被原样复制到新的 design system 中,随后它会成为 active design system。
如果用户明确要求比较多个选项(“为……展示三个方向”、“做几个不同版本”、“我不确定想要什么风格,给我一些选项”),请运行 design exploration,而不是执行步骤 3–5。不要为普通请求进行 exploration(例如“设计一个定价页面”),因为这需要多次生成。
  1. 调用
    prepare_open_design_exploration
    ,传入
    skillId
    和用户的
    brief
    (如果用户指定了数量,再传入
    count
    2–4,默认 3)。该工具会自行选择有明显差异的方向:没有 active design system 时选择视觉风格,有 active design system 时选择布局或叙事结构(从而保留品牌);如果用户明确指出需要变化的内容,则传入
    axis: "custom"
    和
    customDirections
    (例如“三个 hero 概念”)。只有当 brief 的语气明确要求特定方向时,才传入
    directionIds
    (例如杂志使用
    editorial-monocle
    ,艺术或代理类网站使用
    brutalist-experimental
    )。如果结果说明 active design system 已被暂时搁置,应告知用户。
  2. 对于每个返回的方向,先遵循
    sharedInstructions
    ,再遵循该方向自己的
    instructions
    ,将其文件写入
    suggestedEntryPath
    ,并调用
    register_open_design_artifact
    ,传入
    explorationId
    和该方向的
    directionId
    。这些方向只是快速 sketch(一个屏幕,或一张封面加两张幻灯片),不是完整构建。如果可以委派工作给 sub-agents,可并行生成各个方向,并分别向其传递
    sharedInstructions
    和该方向自己的
    instructions
    。
  3. 调用
    compare_open_design_exploration
    ,并设置
    contactSheet: true
    。如果可以查看图片,请打开 contact sheet,检查这些方向是否确实存在明显差异(布局和 hero 模式,而不只是颜色);如果某个方向与另一个过于相似,请重新生成。
  4. 将 comparison page 路径(
    compareFile
    ;可直接从文件系统在浏览器中打开,并并排显示所有方向)和 contact sheet 路径分别放在单独一行,简要说明每个方向有何差异,并通过
    show_open_design_questions
    (工具中存在时)询问用户想采用哪个方向,每个方向作为一个选项,并设置
    imageRef: "artifact:<其 entry path>"
    。
  5. 用户选定后,调用
    choose_open_design_direction
    并设置
    next
    :
    build-out
    (将选中的 sketch 完成为高保真成品)、
    merge
    (同样完成构建,但通过
    mergeFrom
    吸收其他方向中指定的特性,例如“B 加上 A 的 hero”)或
    save-design-system
    (将该方向转换为可复用的自定义 design system)。遵循返回的 instructions,并按照其中的要求注册结果。
生成的 artifacts 会放在项目的 Open Design 输出目录下(默认
.open-design/
),以便像其他项目文件一样在版本控制中保持可见且可追踪。注册或更新 artifact 后,应在单独一行告诉用户写入位置及其相对于 workspace 的入口路径(例如
.open-design/coffee-poster/coffee-poster.html
):在 Claude Desktop 的 Code 标签页中,点击该路径会在 Browser 面板中打开。不要自行在浏览器中打开 HTML 文件:应使用
open_open_design_preview
(或 Claude Desktop Chat 中的
show_open_design_artifact
)进行展示。
来自预览的评论。 当用户表示留下了评论(或粘贴预览中的“Apply my comments”指令,或内联预览发布了该指令)时,为对应入口调用
get_open_design_artifact
。其
openComments
会列出每条评论的备注及其指向的元素(
selector
、
text
、
htmlHint
、
rect
);最多会附加 4 个被评论元素的截图,并列出每条评论的
screenshot
路径。仅使用自己的文件编辑工具修改这些元素,然后再次调用
register_open_design_artifact
,并传入这些评论的 ids 作为
resolvedCommentIds
,使预览中的评论标记消失;然后按照步骤 6 执行检查。在 Claude Desktop Chat 中,内联副本会自动更新;只需告诉用户设计已更新,不要再次显示。
如果用户希望从现有示例开始或基于示例改造,应优先使用
remix_open_design_example
(skillId 必须是
remixable: true
的条目),而不是
prepare_open_design_brief
;它会将一个可用的起始 artifact 复制到项目中,并提示你修改它,而不是从头重新生成。可 remix 示例的完整列表见 references/remixable-examples.md,按 mode 分组;在调用带
remixableOnly: true
的
list_open_design_skills
之前,如果快速浏览该列表已经能回答问题,应先查看它。
如果用户需要使用不在约 150 套内置 design systems 中的品牌或风格(例如“使用我们自己的品牌颜色”、“匹配我们的网站”、“为……设置自定义 design system”),请调用
create_open_design_design_system
,传入
name
、描述品牌的
brief
,以及用户提供了网站时的可选
sourceUrl
。它会返回编写新
DESIGN.md
所需的 instructions(文件结构与每套内置 design system 相同);如果提供了
sourceUrl
,还会尽力提取一份初始调色板/字体列表供你参考——应将其视为粗略起点,而不是事实依据。该工具不会写入任何文件。写好文件后,使用返回的 id 调用
set_active_design_system
;design system 不需要单独的注册步骤,写好的
DESIGN.md
会立即变为可选状态,就像生成并写入的 artifact 会立即可见一样。
当用户对生成或修改后的 artifact 满意,并希望将其转换为当前 app 中真正可运行的代码(例如“把它变成真正的组件”、“把它加入这个 app”、“接入我的 codebase”),请使用 artifact 的
entryPath
调用
port_open_design_artifact_to_app
。它会返回 instructions,用于在当前项目的真实应用中复现该 artifact 的设计:仔细阅读这些 instructions;它们会要求你查找并遵循 codebase 中真实存在的组件作为模式参考,包括其样式方案、约定和文件组织方式,而不是逐字复制 artifact 的 HTML/CSS,并将路由/导航接入作为独立步骤留给用户。该工具本身不会写入任何文件。
与 Impeccable 配合。 移植完成后,如果自己的 skill 列表中存在名为
impeccable
的 skill,请在回复结尾建议对刚编写的组件运行
/impeccable polish
(或
/impeccable audit
)。如果没有该 skill,则不要提及 Impeccable。在代码项目中,如果已经为项目设置了 design system,但项目中没有
DESIGN.md
,可以一次性询问是否将其保存为项目的
DESIGN.md
,以便其他工具读取;用户同意后,再次调用
set_active_design_system
并设置
writeProjectDesignMd: true
(它绝不会覆盖已有文件)。
当用户需要的是可复用组件,而不是 app 中的单个页面(例如“为我的 React app 制作 Material 3 组件”、“根据这个设计制作一套组件库(用于这些屏幕)”),请改为调用
prepare_open_design_component_library
,传入 artifact 的
entryPaths
(如果每个屏幕都有
collectionId
,则传入它)以及
library
(
mui
、
shadcn
或
auto
)。严格按顺序执行各阶段:先编写
components.md
清单,并在编写任何代码之前停下来等待用户明确同意;使用生成的 theme;包装该库自身的组件;添加 gallery;运行 app 的类型检查;然后再次调用该工具并设置
record
。该工具本身不会写入 app 代码。“Material 3”对应
mui
。
当 artifact 需要作为图片发布或上传时(X/Twitter 帖子、Instagram 或 LinkedIn 图片、小红书卡片、YouTube 缩略图、海报),注册后调用
export_open_design_artifact
并传入其
entryPath
。它会在无头浏览器中渲染 artifact,并将 PNG/JPEG 文件写入 artifact 自己的
exports/
文件夹;除非传入
width
/
height
,否则尺寸由 source skill 自动决定。对于多卡片设计,为每张卡片添加
data-od-card
属性,并传入
selector: "[data-od-card]"
,从而为每张卡片生成一张带编号的图片。传入
maxBytes
以匹配平台的上传限制(X 5000000、YouTube 缩略图 2000000、Instagram 8000000)。告知用户导出文件的路径。对于任何社交帖子请求(“制作一条 X 帖子……”、“制作一个 Instagram 轮播图……”、“制作一个 YouTube 缩略图……”),必须先加载
open-design-social-post
skill。它会将每个平台和格式映射到正确的画布尺寸、skillId 和导出参数(平台不明确时会询问用户),然后引导完成生成 → 注册 → 导出。动画设计(动态帧、标题卡、动态图表、精灵图或 WebGL 动画)应导出为视频或 GIF:调用
export_open_design_artifact
,设置
format: "mp4"
、
"webm"
或
"gif"
。时间按虚拟时钟运行,因此帧精确且每次运行结果一致;时长来自页面(
data-duration
帧数或最长动画),除非另行传入
duration
。导出前,调用
check_open_design_artifact
并设置
at
(例如
[0, 1.5, 3]
),以查看开头、中间和结尾。导出需要安装 ffmpeg:如果报告
no-ffmpeg
或
ffmpeg-missing-encoder
,应告诉用户需要安装什么,不要自行尝试其他替代方式。使用 HyperFrames framework 构建的组合是例外:其 brief 自身的 instructions 会要求使用 HyperFrames CLI 进行渲染。注册 slide deck 后,应主动询问是否需要导出为 PowerPoint 或 PDF;用户需要时,调用
export_open_design_artifact
并设置
format: "pptx"
或
"pdf"
(PPTX 中每张幻灯片都是一张铺满页面的图片:效果精确,但不可编辑)。如果用户需要可在 PowerPoint、Keynote、Google Slides 或 Canva 中编辑的幻灯片,请在
pptx
导出时添加
editable: true
:文本框、形状和图片可以修改,效果与原 deck 接近但不完全一致,渐变、SVG 图表和特殊效果会作为背景图片保留。告诉用户哪些内容会保留为图片,以及需要安装哪些字体。绝不要自行编写转换脚本。普通页面设置
format: "pdf"
时,会打印为矢量 PDF。
对于展示系统关系的图表——架构、依赖关系、请求流程、数据库 schema(ERD)、状态机或调用时序(“绘制我们的服务如何通信”、“画出 schema”、“结账流程如何运作?”)——请使用
diagram
skill(
od:prototype:diagram
,或 remix 其示例
od:prototype:diagram:example
)。先阅读相关代码,并且只绘制实际读到的内容。使用
data-rank
/
data-lane
和隐藏链接编写节点,绝不要使用坐标;然后调用
add_open_design_diagram_runtime
(它会插入布局 runtime,绝不要自行编写该脚本),使用 kind
diagram
和已读取的文件作为
sources
进行注册,并执行检查。如果后续检查或
get_open_design_artifact
报告 sources 已发生变化,应主动提出重新绘制。
对于 3D 对象——产品图、3D logo、旋转展示,或用户自己的
.glb
/
.gltf
模型(“为我们的瓶子制作 3D 渲染”、“把 logo 变成 3D”、“为 models/headphones.glb 制作产品图”)——请使用
3d-object
skill(
od:prototype:3d-object
)。它会创建一个 three.js 场景,包含影棚灯光、来自 design system tokens 的材质、地面阴影和旋转展示装置。严格按照 skill 的说明加载 three.js(使用其针对固定版本
three@0.160.0
模块构建的 import map):旧版
three.min.js
和
examples/js
script 标签已不存在,使用它们会导致页面空白。将用户模型复制到设计旁边的
assets/
下,并使用
GLTFLoader
加载,根据模型边界框调整相机取景。页面必须公开
window.odScene
(包含
ready
,并在所有内容加载后完成一次直接渲染后解析为 true,以及
rotate
);导出和检查会启用软件 WebGL 并等待其就绪。导出前修复
webgl
findings。如果需要制作可放置到幻灯片或页面中的镂空对象,从无背景的场景导出
format: "png"
并设置
transparent: true
;如果需要旋转展示,则导出
format: "mp4"
或
"gif"
,并将
duration
设为一圈旋转的时长。
对于 HTML 邮件(newsletter、发布通知或产品更新邮件),使用
email-campaign
skill:它会构建基于 table、适合邮件客户端安全渲染的邮件,并标记
data-od-email
。完成检查后,调用
export_open_design_artifact
并设置
format: "email"
;用户将
assets/
文件夹托管后,添加一次
baseUrl
,使图片 URL 变为绝对路径;并提醒用户先给自己发送一封测试邮件,再发送给邮件列表。如果用户希望将设计粘贴到其他编辑器(微信公众号文章、Notion 页面、newsletter 工具),导出时设置
format: "paste"
,并设置
target
为
wechat
、
notion
、
newsletter
或
generic
;样式会从浏览器渲染结果中内联化。使用生成的文件时,用户需在浏览器中打开、全选并复制。
对于 campaign(一条信息覆盖多个渠道或尺寸、多个尺寸的广告横幅,或相同创意使用多种语言),必须先加载
open-design-campaign
skill:先就 CSV 保存的 copy deck 达成一致,构建一个使用
data-od-field
绑定到该 deck 的流式主设计(将 headline 和 subhead 标记为
data-od-fit
,以适应较长的翻译),按行检查每个选定尺寸,然后导出时传入
presets
、
data
和
campaignSheet: true
。
对于海报、传单、证书或其他印刷品,或者当用户希望将现有设计转换为其他尺寸或打印就绪 PDF 时,必须先加载
open-design-poster
skill。简要流程:如果尚不明确,先询问是印刷还是屏幕展示以及尺寸;将画布
format
(例如
a3
、
a2
、
ig-portrait
、
story
)与
fluid: true
一起传给
prepare_open_design_brief
,并将相同
format
传给
register_open_design_artifact
(流式海报可适配任何形状,因此后续可以更改尺寸);任何 QR code 都应使用
create_open_design_qr_code
制作,绝不能画一个假的;运行
check_open_design_artifact
并修复所有 preflight error;然后导出时设置
preset
为对应的 format id(印刷格式会生成包含 bleed、trim 和 bleed boxes 的 PDF)。
presets
可一次导出多种尺寸,
shapeSheet: true
会将它们显示在同一张图片中;
adapt_open_design_artifact
可以调整看起来不合适的形状(对于流式海报会就地调整);导出参数中的
data
会为用户 spreadsheet 中的每一行生成一个文件。印刷 PDF 使用 RGB,应明确告知用户。
当用户希望与没有打开当前项目的人分享设计时:如果需要链接(“发布这个”、“部署它”、“给我一个可以发给团队的链接”、“托管到某个地方”),调用
publish_open_design_artifact
并传入其
entryPath
(只有当用户已经明确指定托管位置时才传
provider
;否则工具会返回可供用户选择的选项)。它会构建一个可直接部署的文件夹,并返回在用户自己的 CLI 登录环境中通过终端执行的详细说明,或者提供一个临时的免账号链接。必须严格遵循这些说明:任何内容上线前都要等待用户明确同意;成功部署后,再次调用该工具并设置
published
以记录链接。如果用户只需要附加或发送单个文件(“把它导出为一个 HTML 文件”),则调用
export_open_design_artifact
并设置
format: "standalone"
,不会将任何内容发布到线上。
open-design-publish
skill 会引导完成整个流程。
对于 Figma:如果要将 frame 转换为代码,调用
pull_open_design_figma_frame
并传入 frame 链接(“Copy link to selection”);如果要将完成的设计作为可编辑图层放入 Figma,调用
push_open_design_artifact_to_figma
并传入其
entryPath
。两者都通过用户的 Figma 连接工作;如果不可用,则回退到 Figma 导入插件。
当某一步需要将工作移交给其他服务时(导入 Canva、读取或推送 Figma frame、保存到 Google Drive、编写 Notion 页面、分享到 Slack,或发布到社交网络),先使用相应的
capability
调用
list_open_design_integrations
(社交帖子还需传入
platform
)。然后:
  1. 检查自己的工具中是否有与返回模式匹配的工具,包括可以搜索的 deferred 或 on-demand 工具。如果存在,则使用它,并调用其 server 定义的名称(例如 Canva 的
    import-design-from-url
    )。
  2. 如果不存在,则提议配置第一个 provider;每次对话最多提议一次,并且仅在当前步骤确实需要时提议:说明该 provider 的作用及其登录要求。只有用户明确同意后,才遵循返回的设置步骤(仅进行用户级配置)。绝不要静默安装,也绝不要索要 API key 或将 API key 写入文件;用户应自行设置。
  3. 帮助用户登录,并在需要时重新加载,然后通过列出工具进行确认。
  4. 如果用户拒绝配置或配置失败,则继续采用该工作流的手动路径。
任何会以用户账户发布、发送或投稿的内容,仍必须事先获得用户同意。

Help

帮助