Brand identity

---
name: brand-identity
description: >-
  Design a brand's visual identity from scratch — color palette, logo/wordmark,
  production-ready asset files (SVG/PNG/WebP + favicon), and a brand guide — through
  a guided, interactive process. Use this whenever the user wants to create or refine
  a brand: "design a logo", "make a color palette", "I need a brand kit / visual
  identity / brand guidelines", "pick brand colors and fonts", "rebrand my shop",
  "我要做一个 logo / 配色 / 品牌识别 / VI". Especially for small and medium local
  businesses, shops, startups, and products. Trigger even when the user only names one
  piece (just a logo, or just colors) — the skill scopes to what they need. Do NOT use
  it for merely applying an already-decided brand to a page (that's implementation), or
  for data-visualization color scales (use a dataviz skill for that).
---

# Brand Identity

Build a small business or product's visual identity the way a thoughtful studio would:
decide the *feeling* first, design a disciplined **color palette**, craft a **logo** with a
real concept, then produce **font-independent asset files** and a **brand guide**. Work
*with* the user — this is a conversation with visible options at each step, not a one-shot
dump.

## The one idea that makes brands feel designed

**Contrast + restraint + one spark.** A brand reads as "designed, premium, alive" when it is
mostly calm (a neutral base + one anchor color) with a single small, deliberate accent doing
the emotional work. The opposite — many colors at equal weight and full saturation — reads
cheap. Hold this in mind through every phase; it drives the palette structure, the logo, and
where the accent is allowed to appear.

## Process overview

Six phases. Move through them in order, but stay flexible — if the user only wants a logo,
do 1 → 3 → 4 → 6. Confirm the output of each phase before spending effort on the next.

1. **Design intent** — pin the feeling and 2-3 directional choices.
2. **Color palette** — the 3-part formula, shown applied, iterated.
3. **Logo** — motif → concepts → refine → decide.
4. **Production** — outline glyphs to paths, generate the variant set, rasterize.
5. **Licensing** — confirm the font is free for commercial + logo use.
6. **Documentation** — a brand guide capturing colors, logo rules, type, assets.

Render options **visually and inline** at every design step (see "Showing your work" below).
The user should react to things *applied and on screen*, never to a list of hex codes.

---

## Phase 1 — Design intent

Before any color or shape, get the target *feeling* into one sentence, plus a few
constraints. This is what everything else is judged against, so it is worth 3 minutes.

Write a one-line intent with the user, e.g. *"a living, modern web — warm and human,
deliberately not cold corporate SaaS."* A good intent names both what to be **and what to
avoid** (the "not X" is what keeps you off the generic path).

Then ask **2-3 directional questions** (use a quick multiple-choice question if the tool
supports it). Pick the ones that actually change the outcome:

- **Typography feel**: modern grotesk (techy, confident) · editorial serif (warm, has taste)
  · humanist/clean sans (neutral, safe). This sets the first impression.
- **Color boldness / anchor**: keep an existing/expected brand color, or go somewhere less
  obvious? How much "life" vs. how conservative?
- **Motion / expressiveness** (only if the identity will live on a website): restrained,
  medium, or none.
- **Language coverage**: which scripts must the type support now and later (e.g. EN now,
  Thai/CJK next)? This constrains font and fallback choices — decide the architecture early.

Do not proceed until the intent sentence feels right to the user. Everything downstream
inherits it.

---

## Phase 2 — Color palette

Read `references/color.md` for the full method. The essentials:

**Structure every palette in three roles** (name them for the user):
- **Neutral base** — page backgrounds, tints, borders. Give it a temperature that matches the
  intent (warm "paper" neutrals read human; cool greys read clinical). This is where most of
  the surface area lives, so it sets the mood more than the accent does.
- **Primary / anchor** — the trust color: actions, links, focus. Usually the "expected" brand
  color if there is one.
- **Spark accent** — one energetic color for **small areas only**: marks, underlines, stars,
  numbers, hover, a logo detail. Never large fills. Its power comes from scarcity.

Build a small **ramp** for each role (a few steps light→dark) so there are real tokens to
build UI with, not single colors. Include semantic notes (which step is text, which is
border, which is a tint fill).

**Show it applied, then iterate.** Render (a) the swatch ramps *and* (b) an in-context preview
— a dark hero with the anchor+spark as a glow, a primary button, a light card with the accent
as a small detail. Seeing colors *used* is the only way the user can judge them; a swatch grid
alone hides how they'll actually feel. Take feedback ("the accent feels cheap", "too warm")
and adjust chroma/temperature — `references/color.md` has the moves.

Lock the palette (hex values for each ramp) before starting the logo — the logo uses these
colors.

---

## Phase 3 — Logo

Read `references/logo.md` for the full method, including the failure-mode fixes and how to
give an objective evaluation. The spine:

1. **Find a motif**, not just a nice letterform. Mine the business name, what it does, and any
   double meaning. The AlphaBlue example used `<AB/>` — a code tag that means both *code* and
   *A/B testing*. A concept the user can retell in one sentence beats a generic monogram.
2. **Generate 3-4 distinct construction concepts** and render each **on both light and dark**.
   Vary how literal vs. abstract, and what carries the idea (a symbol, a wordmark, a tile).
3. **Narrow to one direction**, then produce **refined executions** that fix its specific
   problems. Common fix, worth memorizing: a **cold + warm two-color mark at equal weight and
   full saturation looks cheap** — resolve it by deepening/muting both colors to share one
   value, or by demoting one color to a single small accent.
4. **When the user is torn, give an objective, principled evaluation** — don't just pile on
   more options. Useful principles: a logo need **not literally depict its name** (name-color
   matching is a weak, decorative idea); distinctiveness comes from **contrast with the
   surrounding UI, not matching it**; *restraint + one deliberate spark* is the premium
   formula. If the name-color still matters to the user, resolve the tension by keeping the
   **mark** restrained while the literal name-color appears only in the **wordmark lockup**.

Confirm the final direction and its exact colors before production.

---

## Phase 4 — Production

Read `references/production.md`. Goal: **font-independent** vector assets (outlined paths, so
they render identically everywhere with no webfont), plus rasters for the web/app.

Use the bundled scripts — they encode the pipeline so you don't reinvent it:

- **`scripts/outline_glyphs.py`** — download the chosen font, instance a variable font at the
  target weight, and extract the needed glyphs as SVG `<path>` data via fontTools. It has a
  `CONFIG` block at the top: set the font, weight, and a list of asset specs (each = text +
  per-glyph colors + output name). Copy it next to your work, edit CONFIG, run it. It also
  builds a favicon tile. Needs a venv with `fonttools brotli`.
- **`scripts/generate-raster.sh`** — rasterize every SVG in a folder to multi-size **PNG**
  (`rsvg-convert`) and lossless **WebP** (`cwebp`). Re-runnable after any SVG edit.

Produce the standard **variant set**:
- Symbol **mark**: light, dark, and mono (`fill="currentColor"`).
- Horizontal **wordmark lockup**: light and dark. (If a name-color lives anywhere, it's here.)
- **Favicon tile**: a compact **2-3 glyph** mark in a rounded tile — legible at 16px. Do *not*
  cram a wide full logo into a square; pick the smallest recognizable fragment.

**One canonical asset folder is the single source of truth** (e.g. `assets/brand/` at the repo
root: source SVGs + `png/` + `webp/` + the raster script). Apps that need the assets
**symlink** to it — never re-copy, or the copies drift.

---

## Phase 5 — Licensing check

Before shipping, confirm the font may be used commercially and in a logo. Most good free fonts
are **SIL Open Font License (OFL) 1.1** (e.g. Space Grotesk, Inter): free for commercial use,
logos explicitly allowed, and outlined glyphs count as artwork (not "font software"), so the
mark is unrestricted. The only real rules: don't sell the font by itself, and don't release a
*modified font* under a reserved name. If you self-host the webfont, ship its `LICENSE`.
Read the actual license from the font file's metadata rather than assuming —
`references/production.md` shows how.

---

## Phase 6 — Documentation

Capture the decisions so the brand stays consistent as it's used:

- **Color tokens** — every ramp with hex values, plus the usage rules (anchor = actions;
  spark = small accents only; base = surfaces).
- **Logo** — the variants, minimum size, clear-space, and a short do / don't list.
- **Typography** — display + body families and per-script fallbacks; the OFL note.
- **Asset locations** — where the canonical files live and how to regenerate rasters.

A single markdown brand guide is enough for most SMBs. If the user wants something polished
(a typeset VI memo / PDF), a document-typesetting skill can format it — but the content above
is the deliverable.

---

## Showing your work (rendering options inline)

The whole method depends on the user *seeing* options, so use whatever inline visual surface
the environment offers — a visualization widget, an HTML artifact, or a rendered SVG/HTML
preview. For palettes: swatch ramps **plus** an applied mockup (hero, button, card). For
logos: each concept **on both light and dark** backgrounds. If no rich visual tool exists,
write a self-contained HTML file and tell the user to open it. Never substitute a wall of hex
codes for a rendered preview — the entire value of this skill is judging design *applied*.

## A worked example

`assets/alphablue-example.md` is the full AlphaBlue run (a local-business web studio): the
intent sentence, the final palette hex values, the `<AB/>` logo decision and the reasoning
that resolved a "cheap clash" and a name-vs-mark tension. Read it to see the method in
practice — but treat its specific colors/fonts as *one instance*, not defaults. Every business
gets its own intent, palette, and motif.