Website Design System logo

Website Design System

Community
DiqingWWW
website-design-system

Analyze a website URL and build a browsable design-system website with evidence-backed foundations, tokens, component states, usage rules, motion, and working composition examples. Use for URL-to-design-system, website visual-language extraction, or generating a system reference from an existing site. Not for a simple screenshot clone, isolated UI fix, or Figma-only library creation.

Overview

PublisherDiqingWWW
RepositoryWeb-Design-System-Skill
Skill namewebsite-design-system
Stars
10
Forks
0
Bundled files
9
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 9 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by DiqingWWW on GitHub. Read the source before you install it.

Installation

Install the Website Design System AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/DiqingWWW/Web-Design-System-Skill/tree/main
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/DiqingWWW/Web-Design-System-Skill.git \
  .claude/skills/website-design-system
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Website Design System in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Website Design System on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Website Design System is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Website Design System

Turn a URL into a usable, traceable design-system website. A written audit, palette, screenshot gallery, or static component collage alone does not finish the task. Deliver running examples built from the same tokens and components that the documentation describes.

This skill is self-contained. Never assume access to the skill author's repositories, localhost routes, prior conversations, preferred framework, or private design files. Treat the current request, the supplied URLs or files, the inspected source, and the active workspace rules as the complete source of truth.

Establish the target

  • Read references/cold-start.md when the request provides only a URL, the destination is unclear, or the skill is being evaluated in a new environment.
  • Separate the source website to analyze from any reference documentation website whose presentation the user likes. A reference supplies documentation depth and interaction patterns; its brand, dimensions, and colors do not become the source's design language.
  • With one source URL, inspect that page from top to bottom and the distinct same-origin page families reachable through its navigation. Start with one representative of each family; expand when another page exposes new components, variants, or layout rules. Record unvisited URLs and inaccessible states. Do not call a sampled crawl “every element on the entire site.”
  • If the only URL is explicitly a documentation reference and no source is supplied, ask for the source before claiming to extract its system.
  • Default to the user's language for documentation and the source's language for faithful specimens. Keep observed source copy separate from labeled fictional demo content.
  • Use an existing project's framework only when the user names that project or route as the destination, or the source URL is that project's local preview. Mere presence in an application repository is not permission to modify it. Otherwise create an isolated output directory and runnable local documentation site; plain HTML/CSS/JS is sufficient when no app stack is established. Follow any required site-building workflow in the active environment. Do not introduce a backend for extraction unless requested.
  • State the crawl boundary, evidence method, output location, and acceptance criteria briefly, then work. Ask only for information that changes the work and cannot be inferred. URL input in conversation is enough; a hosted crawler, URL-entry product, deployment, or Figma write is additional scope.

1. Observe before designing

Read references/inspection.md. Inspect the rendered site with available, documented browser tools, then inspect local source/CSS when available and authorized. Screenshots establish composition; computed styles and source declarations establish values. Neither alone proves a complete system.

Create a structured evidence ledger and coverage matrix before implementation. Each finding links to a URL, element or component, viewport, state, method, and capture time. Record source revision when local code is available. A screenshot estimate must never be labeled a measured CSS value.

Use these distinct evidence labels throughout the site and exports:

LabelMeaning
Observed / 实测Directly inspected in source or rendered behavior, with method and location recorded
Inferred / 推断Generalized from repeated evidence; state the reasoning and uncertainty
Proposed / 补全提案New rule, state, correction, or component added for usability/completeness
Unknown / 未知Not inspectable or not verified; no fabricated value

Evidence status is separate from owner approval. Observed does not mean approved, accessible, reusable, or correct. Mark blocked routes, unobserved modes, and coverage gaps explicitly. Continue supported work when some routes fail.

2. Reconstruct the system

Read references/system-model.md. Inventory all unique visual families within the inspected scope, including distinctive source-specific elements. Use the coverage matrix to account for foundations, components, composition, behavior, and governance; mark missing categories as absent, blocked, or proposed rather than silently skipping them.

For each candidate value:

  1. Retain raw observations, including exceptions and breakpoint differences.
  2. Merge only values with the same meaning and compatible evidence. Equal hex values do not imply equal semantic roles.
  3. Promote repeated values into primitives, roles into semantic aliases, and demonstrated component-specific needs into component aliases. Record naming as inferred when the original token names are unavailable.
  4. Keep one-off hero treatments, shaders, illustration styles, or choreography local unless repeated evidence supports reuse.
  5. Fill gaps needed for a coherent usable system with visibly Proposed additions. Do not invent a full 50–950 palette, dark mode, icon library identity, exact breakpoint, or timing curve from one screenshot.
  6. Keep observed defects visible in the source comparison; use a separately labeled correction in functional examples when necessary for accessibility. A repair must not silently rewrite the extraction.

3. Build the reference website

Read references/site-contract.md. Build foundations → components → compositions → handoff from one structured registry. Values shown in tables, CSS consumed by specimens, and exported tokens must agree.

Produce a site with section navigation, live specimens, usage and avoidance guidance, anatomy and state documentation, real composition examples, motion replay, responsive/stress controls, evidence details, and downloadable implementation data. Match the source's visual character while keeping documentation legible. Do not impose a universal SaaS dashboard or copy the reference site's brand.

Use reusable components in both the component gallery and composed examples. Forced state samples are labeled as samples and supplement actual keyboard/pointer behavior. Document which parts are observed and which are proposed at the item level, not only in one footer disclaimer.

Keep output styles scoped. In an existing application, add an isolated route or output directory; do not replace production pages or global tokens. The generated system remains a proposal until adopted. For later comment-driven edits, freeze unmentioned elements and change only the requested targets.

4. Verify and hand off

Use the checks in the site contract. Run supported project checks after reading their scripts; check the running website at desktop, narrow mobile, and source breakpoints, plus keyboard, focus, reduced motion, long content, missing media, and export behavior. Compare representative specimens to source evidence at matching viewports. Report skipped or blocked checks without claiming conformance.

The optional scripts/export_tokens.py validates the local registry contract in system-model.md and generates scoped CSS plus a resolved JSON export. Run it when using that contract. It validates alias/data consistency, not CSS semantics, accessibility, or third-party importer compatibility. Other typed registries are acceptable if they enforce equivalent invariants.

Finish with the verified running preview URL, output location, inspected coverage, material gaps, and verification result. Preserve any existing development service; use an isolated route or another available port. If the environment cannot leave a service running, verify the URL during the run, state that it stopped, and provide the exact restart command. Download links must return the generated files. Never describe a local custom JSON manifest as a universal Figma/Tokens Studio import, or claim design-tool synchronization without testing that destination.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Website Design System AI skill do?

Analyze a website URL and build a browsable design-system website with evidence-backed foundations, tokens, component states, usage rules, motion, and working composition examples. Use for URL-to-design-system, website visual-language extraction, or generating a system reference from an existing site. Not for a simple screenshot clone, isolated UI fix, or Figma-only library creation.

Why use Website Design System on TypingMind?

Because you install it once and use it with any model. Website Design System is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Website Design System in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/DiqingWWW/Web-Design-System-Skill/tree/main. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Website Design System?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Website Design System?

As many as you like. As long as a model supports skills, you can use Website Design System with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Website Design System AI skill free?

Yes. It is published on GitHub by DiqingWWW under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇