Agent skill

Design Memory

by Owl-Listener in 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.

MITAuto-check passedFrontend & Design

Install Design Memory

skills CLI
$ npx skills add Owl-Listener/designpowers --skill design-memory -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install Owl-Listener/designpowers design-memory --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ 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-src

Use ~/.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/

Facts

Skill name
design-memory
GitHub stars
251
Token cost
~2.4k tokens
SKILL.md length
1,016 words
Files
1
Skills in repo
33
Repo updated
First seen
Licence
MIT

At a glance

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.

  • Works in 3 steps: Phrase it as an observation ("reaches… → Check whether it reinforces an existing… → If it contradicts an earlier…
  • Tasks that involve Design tokens
  • SKILL.md covers The one rule that defines this…, Welcome Gate, When to Use and The Record (taste-profile.md), plus 5 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

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.

When your agent uses it

  • Tasks that involve Design tokens

Example prompts

  • “/design-memory”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Phrase it as an observation ("reaches for X", "tends to decide Y last"), never a rule ("always use X").
  2. Check whether it reinforces an existing observation (increase the count / add evidence) or is new (add it under the right section).
  3. If it contradicts an earlier observation, don't agonise — just note both; people change, and the record is a journal, not a contract.

What it can do on your machine

Read from SKILL.md and the folder at commit cb00757. It shows what the files ask for, not the result of running them.

  • Tool permissions

    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.

  • Runs code

    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.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

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.

Always · name and description, kept in context so the agent knows when to use it
~112
When it runs · the whole SKILL.md, loaded when a task matches
~2.4k

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.

Safety

Auto-check passed

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.

SKILL.md

The full file from Owl-Listener/designpowers at commit cb00757, republished under its MIT licence (© Owl-Listener). 1,016 words, ~2,409 tokens.

Download SKILL.mdSave it as .claude/skills/design-memory/SKILL.md (or your agent's skills folder).
name
design-memory
description
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

Design Memory

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.

The one rule that defines this skill

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.

Welcome Gate

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.

When to Use

  • At project completion — observe the project's decisions and add them to the record
  • When the user asks "how do I design?", "what are my habits?", "what's my style?" — produce the report
  • When the user makes a notably characteristic choice — note it as an observation
  • It is not loaded to constrain a new project. (Loading at project start is only to show the user their report if they want it, not to feed preferences into the pipeline.)

The Record (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.

Structure
markdown
# 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] |

Process

Observing (during and at end of a project)

Watch for signals about how the user decides — and record them as observations, with evidence:

SignalWhat it tells you
User overrideA 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 approvalA choice that resonated — worth noting
Correction ("no, more like…")A direction they lean away from
Silent approvalWeak — don't record until it recurs

When you notice a signal:

  1. Phrase it as an observation ("reaches for X", "tends to decide Y last"), never a rule ("always use X").
  2. Check whether it reinforces an existing observation (increase the count / add evidence) or is new (add it under the right section).
  3. If it contradicts an earlier observation, don't agonise — just note both; people change, and the record is a journal, not a contract.
Consolidating (end of project)

When a project completes:

  1. Review the decisions in design-state.md and the user's overrides.
  2. Add observations to the record, with evidence and project attribution.
  3. Keep it to how the user works, not what this client needed. A client's required brand colour is that client's taste (it lives in their 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.
  4. Offer the report: "Want to see what this project added to your design record?"
Show full SKILL.md (406 more words)Show less

The Report

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:

markdown
# 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:

  1. Synthesise, don't transcribe — the value is patterns across entries, not a table dump.
  2. Every claim cites evidence — no evidence, no claim.
  3. Describe, never prescribe — "you tend to…" never "you should…" and never "so I'll apply this."
  4. Be honest about confidence — separate well-evidenced habits from one-off curiosities.
  5. It's a mirror, offered with curiosity — the goal is self-awareness, not a grade and not a directive.

What design memory does NOT do

  • It does not pass preferences to design-lead, design-strategist, or any agent as constraints.
  • It does not gate or steer the build. The pipeline runs from the brief, the personas, design-taste (your live direction for this project), and any DESIGN.md.
  • It does not override or even nudge project decisions. If a past habit is relevant, the user raises it; the system won't apply it silently.

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.

Integration

  • Called by: using-designpowers (may offer the report), design-state/design-retrospective (at project end, to add observations)
  • Reads from: design-state.md, handoff chain, user overrides — to observe, not to extract constraints
  • Writes to: ~/.designpowers/taste-profile.md (the observational record)
  • Does NOT inform: the agents or the build — by design
  • Distinct from: 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.

Anti-Patterns

PatternWhy It Fails
Feeding the record back into the build as constraintsThis 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 tasteA 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 decisionMost choices are contextual. Note the ones that reveal something about how the user works
Treating the record as a gradeIt'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

Files

Just SKILL.md in skills/design-memory of Owl-Listener/designpowers.

Open the folder on GitHubat commit cb00757

Compare with similar skills

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.

Design Memory compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Design Memory this skillOwl-Listener/designpowers251—~2.4kAutomated safety check: PassMIT
Figma Design System Builderwarpdotdev/warp65k2 repos~4.4kAutomated safety check: PassAGPL-3.0
Figma use_figma Plugin API Ruleswarpdotdev/warp65k4 repos~4.4kAutomated safety check: PassAGPL-3.0
MCP Developmentcoollabsio/coolify63k1 repos~949Automated safety check: PassMIT
Design SystemOhh-889/skyroc79511 repos~1.7kAutomated safety check: PassMIT
Design Dnazanwei/design-dna1.9k1 repos~2.1kAutomated safety check: PassMIT

Similar skills

  • Builds or updates a design system in Figma from a codebase in ordered phases: discovery, variables and tokens, components, theming and documentation, with checkpoints.

    65k GitHub starsUsed in 2 repos~4.4k tokens
    Frontend & DesignAuto-check passed
  • 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.

    65k GitHub starsUsed in 4 repos~4.4k tokens
    Frontend & DesignAuto-check passed
  • MCP Development

    coollabsio/coolify

    A skill your agent uses for Laravel MCP development. An agent skill from coollabsio/coolify.

    63k GitHub starsUsed in 1 repo~949 tokens
    Frontend & DesignAuto-check passed
  • Design System

    Ohh-889/skyroc

    Token architecture, component specifications, and slide generation.

    795 GitHub starsUsed in 11 repos~1.7k tokens
    Frontend & DesignAuto-check passed
  • Design Dna

    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…

    1.9k GitHub starsUsed in 1 repo~2.1k tokens
    Frontend & DesignAuto-check passed
  • Figma Design to Code

    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.

    65k GitHub starsUsed in 4 repos~2.9k tokens
    Frontend & DesignAuto-check passed

More from Owl-Listener/designpowers

All 33 skills in this repo
  • Adaptive Interfaces

    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…

    251 GitHub stars~1.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Design Debate

    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…

    251 GitHub stars~2.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Design Debt Tracker

    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.

    251 GitHub stars~2.2k tokensUpdated 3 mo ago
    Auto-check passed
  • Design Discovery

    Owl-Listener/designpowers

    You MUST use this before any creative or design work — building features, creating components, designing interfaces, modifying user-facing behaviour.

    251 GitHub stars~2.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Design Handoff

    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…

    251 GitHub stars~1.1k tokensUpdated 3 mo ago
    Auto-check passed
  • Design Review

    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…

    251 GitHub stars~1.7k tokensUpdated 3 mo ago
    Auto-check passed

Questions about Design Memory

What does Design Memory do?

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.

When should I use Design Memory?

Design Memory fits situations like: tasks that involve Design tokens.

How do I install Design Memory in Claude Code?

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.

How do I install Design Memory in Codex?

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.

Can I use Design Memory in Cursor, Gemini CLI or GitHub Copilot?

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.

What does Design Memory need to run?

SKILL.md names no scripts, command-line tools or credentials: Design Memory is instructions for the agent only.

Does Design Memory access the network?

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.

Is Design Memory safe to install?

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.

What licence does Design Memory use?

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.

How many tokens does Design Memory use?

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.

What are the alternatives to Design Memory?

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.

Who maintains Design Memory?

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.