Figma Design System Builder
warpdotdev/warp
Builds or updates a design system in Figma from a codebase in ordered phases: discovery, variables and tokens, components, theming and documentation, with checkpoints.
Use at project start and completion to OBSERVE and record how the user designs — the decisions they make, the styles they reach for, their habits and inclinations across projects.
$ npx skills add Owl-Listener/designpowers --skill design-memory -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install Owl-Listener/designpowers design-memory --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/design-memory .claude/skills/design-memory && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .claude/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memoryType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add Owl-Listener/designpowers --skill design-memory -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install Owl-Listener/designpowers design-memory --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/design-memory .agents/skills/design-memory && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .agents/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Owl-Listener/designpowers --skill design-memory -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install Owl-Listener/designpowers design-memory --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/design-memory .cursor/skills/design-memory && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .cursor/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/Owl-Listener/designpowers.git --path skills/design-memory--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add Owl-Listener/designpowers --skill design-memory -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install Owl-Listener/designpowers design-memory --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/design-memory .gemini/skills/design-memory && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .gemini/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install Owl-Listener/designpowers design-memoryInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add Owl-Listener/designpowers --skill design-memory -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/design-memory .github/skills/design-memory && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .github/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add Owl-Listener/designpowers --skill design-memory -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install Owl-Listener/designpowers design-memory --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/Owl-Listener/designpowers.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/design-memory .opencode/skills/design-memory && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "design-memory" agent skill from https://github.com/Owl-Listener/designpowers/tree/main/skills/design-memory into .opencode/skills/design-memory/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "design-memory", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
design-memoryUse at project start and completion to OBSERVE and record how the user designs — the decisions they make, the styles they reach for, their habits and inclinations across projects.
Design Memory is an agent skill from Owl-Listener/designpowers. Use at project start and completion to OBSERVE and record how the user designs — the decisions they make, the styles they reach for, their habits and inclinations across projects. This is a descriptive record (a mirror), NOT a controller — it is never fed back to steer the work. Per-project direction comes from design-taste and a DESIGN.md; design-memory only watches and reflects, surfaced to the user as a report out of curiosity
Its SKILL.md is about 2.4k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Frontend & Design, covering Design tokens. The repository describes itself as: An agent design team you control: 10 agents that run an inclusive design process while you direct. The licence is MIT.
3 steps, taken from the first numbered list in SKILL.md.
Read from SKILL.md and the folder at commit cb00757. It shows what the files ask for, not the result of running them.
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).
From the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Design Memory loads about 2.4k tokens when it runs. Until then it costs about 112 tokens; SKILL.md has 1,016 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
The full file from Owl-Listener/designpowers at commit cb00757, republished under its MIT licence (© Owl-Listener). 1,016 words, ~2,409 tokens.
.claude/skills/design-memory/SKILL.md (or your agent's skills folder).Design memory is an observational record of how you design — the decisions you make, the styles you reach for, the habits and inclinations that show up across projects. It is a mirror, not a controller. It notices what you do and reflects it back to you out of curiosity. It does not steer future work.
Design memory is descriptive, never prescriptive. It records what you did; it is not applied to drive new projects. The current project's direction comes from what you tell the team now (design-taste) and from any brand spec you provide (design-md / DESIGN.md) — never from this record. Observation that never feeds back into the work cannot mis-steer it, which is exactly why a record built across many different clients stays safe and honest: it's a journal, not a set of orders.
If you ever want to act on an observation, that's your call to make explicitly in the moment — the system will not quietly apply your past decisions to a new client's project.
BEFORE reading or updating design memory, check whether the Designpowers welcome sequence has been shown this session. If the user has not yet seen the welcome (the bird, the greeting, and the walkthrough offer), you MUST invoke the using-designpowers skill FIRST and complete the welcome sequence before returning here. The bird must appear before any work begins. No exceptions.
taste-profile.md)Lives at ~/.designpowers/taste-profile.md (cross-project). It is a journal of observations about how the user works — not a rulebook. Every entry is phrased as something observed, with evidence, never as an instruction for future work.
# Design Record — How [user] Designs
_An observational journal. Descriptive, not prescriptive — this is never applied to steer projects._
_Last updated: [date] after project [project name]_
_Projects observed: [count]_
## Recurring Decisions
Choices that have shown up more than once — noticed, not mandated.
| Observation | Times seen | Evidence |
|-------------|-----------|----------|
| [e.g., "Reaches for generous whitespace"] | 3 projects | A, C, D — chose it unprompted |
| [e.g., "Decides colour last, after structure"] | 2 projects | Sequence in B, D |
## Style & Habits
How the user tends to work and decide (not what to impose).
- **Visual leanings:** [e.g., "warm neutrals show up often; rarely picks saturated primaries"]
- **Process habits:** [e.g., "subtracts before adding — overrides usually remove an element"]
- **Decision style:** [e.g., "settles type and spacing before touching colour"]
- **Content voice tendencies:** [e.g., "consistently plain language, contractions, grade ~7"]
## Inclinations & Curiosities
Softer, single-occurrence or emerging things worth noticing — explicitly uncertain.
| Noticed | Where | Note |
|---------|-------|------|
| [e.g., "tried a serif display once and kept it"] | Project D | one occurrence, may not be a pattern |
## Things the user has moved away from
Choices they've reversed or corrected — observed, not a ban.
| Observation | Evidence |
|-------------|----------|
| [e.g., "removed gradient backgrounds twice"] | A, B |
## Project History
| Project | Date | What was decided | What it suggested about how they work |
|---------|------|------------------|----------------------------------------|
| [name] | [date] | [key decisions] | [the habit/inclination it revealed] |Watch for signals about how the user decides — and record them as observations, with evidence:
| Signal | What it tells you |
|---|---|
| User override | A strong signal of an inclination — note what they changed and to what |
| Explicit statement ("I always…", "that's not me") | The user naming their own habit — record their words |
| Emphatic approval | A choice that resonated — worth noting |
| Correction ("no, more like…") | A direction they lean away from |
| Silent approval | Weak — don't record until it recurs |
When you notice a signal:
When a project completes:
design-state.md and the user's overrides.DESIGN.md) — it is not an observation about the user. Only record things that reflect the user's own way of deciding, the kind that would still be true with a different client.The primary way the user experiences design memory is as a report they read out of curiosity — "here's how you design." Generate it from the record by synthesising across observations, not just listing them:
# How You Design
_Observed across [N] projects · descriptive, not applied_
## In one line
[The sharpest honest characterisation — e.g. "You're a subtractor who trusts whitespace and decides colour last."]
## How you tend to decide
[3-5 observations about process and decision-making, each with evidence.]
## What you reach for
[Recurring stylistic choices, framed as tendencies, with counts.]
## What you've moved away from
[Reversals/corrections, as observations.]
## Curiosities & emerging things
[Single-occurrence or uncertain signals — explicitly low-confidence.]
## Where the record is thin
[Honest note on what there isn't enough evidence to say yet.]Rules for the report:
design-taste (your live direction for this project), and any DESIGN.md.This is the deliberate design: by never feeding back, the record can accumulate across wildly different clients without ever contaminating a new project. Observation is safe precisely because it's inert.
using-designpowers (may offer the report), design-state/design-retrospective (at project end, to add observations)design-state.md, handoff chain, user overrides — to observe, not to extract constraints~/.designpowers/taste-profile.md (the observational record)design-taste (your live aesthetic direction for the current project, which IS applied) and design-md (the client's brand spec, which IS applied). Design memory only watches.| Pattern | Why It Fails |
|---|---|
| Feeding the record back into the build as constraints | This is the old prescriptive model. The record is descriptive — applying it silently is exactly the contamination we're avoiding |
| Recording a client's brand requirement as the user's taste | A client's DESIGN.md is that client's, not the user's way of working. Only record portable observations about how the user decides |
| Phrasing observations as rules ("always use X") | It's a journal, not a rulebook. "Reaches for X (3 projects)" is honest; "always use X" is a directive the system shouldn't issue |
| Recording every decision | Most choices are contextual. Note the ones that reveal something about how the user works |
| Treating the record as a grade | It's a mirror offered out of curiosity, not a scorecard |
© Owl-Listener, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in skills/design-memory of Owl-Listener/designpowers.
Open the folder on GitHubat commit cb00757
Design Memory next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Design Memory this skillOwl-Listener/designpowers | 251 | — | ~2.4k | Automated safety check: Pass | MIT | |
| Figma Design System Builderwarpdotdev/warp | 65k | 2 repos | ~4.4k | Automated safety check: Pass | AGPL-3.0 | |
| Figma use_figma Plugin API Ruleswarpdotdev/warp | 65k | 4 repos | ~4.4k | Automated safety check: Pass | AGPL-3.0 | |
| MCP Developmentcoollabsio/coolify | 63k | 1 repos | ~949 | Automated safety check: Pass | MIT | |
| Design SystemOhh-889/skyroc | 795 | 11 repos | ~1.7k | Automated safety check: Pass | MIT | |
| Design Dnazanwei/design-dna | 1.9k | 1 repos | ~2.1k | Automated safety check: Pass | MIT |
warpdotdev/warp
Builds or updates a design system in Figma from a codebase in ordered phases: discovery, variables and tokens, components, theming and documentation, with checkpoints.
warpdotdev/warp
Required groundwork before any use_figma call: the rules and reference files for running JavaScript in a Figma file through the Plugin API without common failures.
coollabsio/coolify
A skill your agent uses for Laravel MCP development. An agent skill from coollabsio/coolify.
Ohh-889/skyroc
Token architecture, component specifications, and slide generation.
zanwei/design-dna
Extract, define, and apply design DNA across three dimensions: design system (tokens), design style (qualitative feel), and visual effects (Canvas, WebGL, 3D, particles, shaders, scroll effects…
warpdotdev/warp
Turns a Figma frame or component into production code that matches the design, using the Figma MCP server and the project's own design system.
Owl-Listener/designpowers
A skill your agent uses when designing for user preferences — motion sensitivity, contrast needs, colour schemes, text sizing, information density, or any interface behaviour that should adapt to…
Owl-Listener/designpowers
A skill your agent uses when a design direction is uncertain, when the team could go multiple ways, or when the user wants to see competing approaches argued before committing — orchestrates…
Owl-Listener/designpowers
A skill your agent uses when critique or review produces deferred findings, when checking accumulated design compromises, or when deciding what to address in the next iteration.
Owl-Listener/designpowers
You MUST use this before any creative or design work — building features, creating components, designing interfaces, modifying user-facing behaviour.
Owl-Listener/designpowers
A skill your agent uses when design work is complete and needs to be communicated to engineering — creates specifications, documents rationale, accessibility requirements, and interaction details in…
Owl-Listener/designpowers
A skill your agent uses when the user wants to evaluate something that ALREADY EXISTS rather than build something new — "review this", "audit this screen", "what's wrong with this page", "is this…
Categories
Use at project start and completion to OBSERVE and record how the user designs — the decisions they make, the styles they reach for, their habits and inclinations across projects. Design Memory is an agent skill from Owl-Listener/designpowers. Use at project start and completion to OBSERVE and record how the user designs — the decisions they make, the styles they reach for, their habits and inclinations across projects.
Design Memory fits situations like: tasks that involve Design tokens.
Run `npx skills add Owl-Listener/designpowers --skill design-memory -a claude-code`. Or copy the skill folder (skills/design-memory in Owl-Listener/designpowers) into .claude/skills/design-memory in your project. Claude Code loads it when a task matches its description.
Run `npx skills add Owl-Listener/designpowers --skill design-memory -a codex`. Or copy the skill folder (skills/design-memory in Owl-Listener/designpowers) into .agents/skills/design-memory in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Owl-Listener/designpowers --skill design-memory -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/design-memory, .gemini/skills/design-memory, .github/skills/design-memory and .opencode/skills/design-memory in your project.
SKILL.md names no scripts, command-line tools or credentials: Design Memory is instructions for the agent only.
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
Design Memory is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 2.4k tokens (SKILL.md is roughly 9.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Design Memory: Figma Design System Builder (warpdotdev/warp, 65k stars), Figma use_figma Plugin API Rules (warpdotdev/warp, 65k stars), MCP Development (coollabsio/coolify, 63k stars) and Design System (Ohh-889/skyroc, 795 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Owl-Listener (a GitHub user) maintains it in Owl-Listener/designpowers, which has 251 GitHub stars. The repository holds 33 skills in this directory. The repository was last updated on June 23, 2026.
Source: Owl-Listener/designpowers on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.