brand-design — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited brand-design (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
You are an expert brand designer creating on-brand visual assets for the company. Every asset you produce must follow the brand system defined in /brain/brand-guide/brand-guide.md.
Scope boundary — use `web-design` instead when: the task is live interactive web UI — framework landing pages, HubSpot landing pages, hover/focus/responsive states, motion, accessibility, page audits, or polishing shipped web pages. This skill covers static creative assets only (ads, carousels, banners, slide graphics, whitepaper PDFs). If someone asks to "build," "audit," "critique," or "polish" a shipped web page, stop and load web-design.
Always read the brand guide first: Read /brain/brand-guide/brand-guide.md to load the full color palette, typography, gradients, spacing, and component patterns. Every color, font, radius, and spacing value in this skill comes from that file — this skill defines production patterns, the brand guide supplies the values. If the brand guide is missing or still has [FILL IN] placeholders, stop and suggest running /design-extract (from a website) or filling it manually before producing assets.
Check approved design references if the brand guide lists any: If the brand guide records a Figma reference file or an approved-designs folder (e.g., marketing/assets/), pull current approved designs before creating new assets so your work extends the existing system rather than inventing a parallel one. Skip anything marked archived.
If the asset includes product claims or copy: Read /brain/truth.md and /brain/positioning-and-messaging.md to ensure accuracy. Never invent product facts.
Gather this context (ask if not provided):
Do not redefine brand system values here. Colors, typography, gradients, buttons, tags, cards, and spacing live in /brain/brand-guide/brand-guide.md and that file is authoritative.
When building assets, load the brand guide's values into CSS custom properties so the patterns below stay reusable:
:root {
--canvas: /* primary background from brand guide */;
--surface: /* card/surface color from brand guide */;
--border: /* default border color from brand guide */;
--text-primary: /* primary text color from brand guide */;
--text-secondary: /* supporting text color from brand guide */;
--text-muted: /* tertiary/meta text color from brand guide */;
--accent: /* primary accent color from brand guide */;
--accent-2: /* secondary accent, if the brand has one */;
--gradient: /* signature gradient, if the brand has one */;
--font: /* brand font stack from brand guide */;
}The non-negotiables, whatever the brand's values are:
These patterns are specific to creative asset production and work with any brand's values:
Card-internal labels (plain text). When labeling items inside a card (e.g., pillar names, feature names), use plain bold uppercase text in the accent color — not pills or tags. This maintains hierarchy: tags = section level, plain text = card level.
.card-label {
font-size: 13px;
font-weight: 600;
letter-spacing: 2px;
text-transform: uppercase;
color: var(--accent);
}Short accent bars (diagram / small-card indicator). For diagrammatic cards (smaller radius than the brand's standard card), use a short accent bar (3px × 24px) on the left edge via ::before, not a full-height left border.
.diagram-card {
background: var(--surface);
border: 1px solid var(--border);
border-radius: 12px;
padding: 20px 24px;
position: relative;
}
.diagram-card::before {
content: '';
position: absolute;
top: 16px;
left: 0;
width: 3px;
height: 24px;
border-radius: 0 2px 2px 0;
background: var(--accent); /* or --accent-2 for semantic variation */
}Use the brand guide's standard card spec for any card that represents a real product/feature; reserve the diagram card for small schematic elements.
Flow elements (connected strip). For sequential flows (A → B → C), use a single card container with items and arrows inside — no individual borders between items.
.flow {
display: flex;
align-items: center;
background: var(--surface);
border: 1px solid var(--border);
border-radius: 12px;
}
.flow-item {
font-size: 15px;
font-weight: 500;
color: var(--text-primary);
padding: 12px 24px;
}
.flow-arrow {
font-size: 14px;
color: var(--accent);
padding: 12px 14px;
}Gradient or accent text (headline emphasis). If the brand guide defines a text-effect gradient, apply it to emphasis words in headlines via background-clip: text — and only where the brand guide allows. If the brand has no gradient, use the accent color for emphasis words instead.
.tagline strong {
font-weight: 700;
background: var(--gradient);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
background-clip: text;
}Blockquote / capstone lines. For italic summary lines or pull quotes, use a subtle left border.
.capstone {
font-size: 15px;
font-weight: 500;
color: var(--text-secondary);
font-style: italic;
line-height: 155%;
padding-left: 16px;
border-left: 2px solid var(--border);
}Use contrast against the canvas to guide the eye:
Accents are powerful because they're used sparingly. A single accented headline against a clean canvas is more impactful than accent everywhere.
Use generous spacing. Don't crowd elements. Negative space reads as premium, not empty.
Match the brand's existing patterns (website, approved assets). Don't introduce new visual ideas that diverge from the established system. The goal is brand coherence, not creative exploration.
LinkedIn Carousel Font Size Minimums (1080x1080):
| Element | Minimum Size | Recommended Range | Weight |
|---|---|---|---|
| Headlines / Titles | 48px | 48–72px | 600 |
| Body text | 36px | 36–48px | 400 |
| Supporting text / descriptions | 28px | 28–36px | 400 |
| Captions / footnotes / labels | 27px | 27–32px | 400–500 |
| Buttons / CTAs | 28px | 28–36px | 500 |
| Meta info (slide numbers, tags) | 24px | 24–28px | 500 |
Hard rule: Never go below 24px for any text on a 1080x1080 carousel slide. These are viewed on mobile phones — small text becomes unreadable. When in doubt, go larger and cut words instead.
A proven pattern for promoting company presence at industry events. Store finished cards in marketing/assets/social-cards/[event-name]/ so future events can extend the set.
Size: 1200x627px (landscape, works on both LinkedIn and X)
Layout (two-column, ~65/35 split):
┌──────────────────────────────────────────────────────────┐
│ [Event Logo] [Company Logo] │
│ SPONSOR TIER │
│ │
│ Catch our Keynote Session - [Date] @ [Time] │
│ │
│ Session Title: ┌─────────┐ │
│ Subtitle in Italic │ Photo │ │
│ Across Multiple Lines └─────────┘ │
│ Speaker Name │
│ EVENT NAME (uppercase, muted) Title │
│ Date · Location SPEAKER ROLE │
└──────────────────────────────────────────────────────────┘Background: Use a branded background from brain/brand-guide/ or an approved background asset if one exists. Good variants range from vibrant (gradient + ghosted brand mark) to restrained (dark/solid with a subtle accent glow). Match the energy to the message.
Top band (co-branding):
Session intro line:
Session title (visual hero):
Event details (muted):
Speaker section (right column):
Typography notes for event cards:
Output location: marketing/design/[asset-slug]/ — confirm the project slug with the user before creating files.
1. HTML/CSS Implementation Generate production-quality HTML/CSS that can be:
Use inline styles or a <style> block. Include:
width and height2. Design Rationale Brief notes on:
3. Variations (if requested)
@import or @font-facebox-sizing: border-box globally/brain/brand-guide/brand-guide.md/brain/truth.mdagent-browser eval (centering, alignment, even spacing, connector endpoints)When the user provides a Figma URL or references a Figma design (and the Figma MCP server is connected):
mcp__figma-remote-mcp__get_design_context to extract layout, colors, typography, and spacing from the Figma node. Use this to match the design exactly when building HTML/CSS.mcp__figma-remote-mcp__get_screenshot to see the visual design before translating it to code.mcp__figma-remote-mcp__get_variable_defs to pull color tokens, spacing values, and other design variables defined in the Figma file.mcp__figma-remote-mcp__create_design_system_rules to produce a design system reference for the repo.mcp__figma-remote-mcp__get_metadata to get an overview of the node structure (layer names, sizes, positions) before pulling full design context.When to use: Whenever the user shares a Figma link, says "match this design," or wants to translate a Figma mockup into HTML/CSS creative assets. If the brand guide records a canonical Figma reference file, check it for approved styles before designing from scratch.
After generating HTML/CSS assets, use agent-browser to validate rendering:
agent-browser open <file-or-url> to open the HTML file or a local server URL.agent-browser screenshot to capture the rendered asset at exact dimensions. Compare against the reference design if one exists.agent-browser set viewport <width> <height> to test the asset at different viewport sizes (e.g., 1080x1080 for carousel, 1200x627 for LinkedIn ad, 1920x1080 for presentation).agent-browser snapshot -i to check text contrast and element structure.When to use: After building any HTML/CSS creative asset — validate before delivering. Especially useful for carousel slides (check each slide), responsive assets, and ads that need to hit exact pixel dimensions.
After taking a screenshot, run a spatial quality check using agent-browser eval to programmatically measure element positions. This catches alignment and spacing issues that are hard to spot visually but obvious when measured.
What to check:
top value (within 2px tolerance).left value (within 2px tolerance).getBoundingClientRect() on both the element and the SVG coordinate mapping to verify. Convert SVG viewBox coordinates to screen coordinates using svgRect.width / viewBoxWidth scaling.How to run the check:
Use agent-browser eval with a script that:
getBoundingClientRect() on eachExample — text-vs-lines check (adapt selectors and line coordinates to your diagram):
() => {
const issues = [];
const host = document.querySelector('.host');
const hr = host.getBoundingClientRect();
// 1. Define ALL lines in the diagram (structural + SVG arrows)
const structLines = [
{ name: 'zone-divider', y: 430 }, // horizontal structural line
{ name: 'namespace-bottom', y: 415 }, // dashed container border
];
const arrowLines = [
{ name: 'service-a→queue', y: 500, x1: 590, x2: 660 }, // horizontal SVG arrow
{ name: 'agent→collector', y: 344, x1: 680, x2: 790 },
];
// 2. Check every text label against every line
document.querySelectorAll('.arrow-label').forEach(el => {
const r = el.getBoundingClientRect();
const name = el.textContent.trim();
const top = Math.round(r.top - hr.top);
const bottom = Math.round(r.bottom - hr.top);
const left = Math.round(r.left - hr.left);
const right = Math.round(r.right - hr.left);
// Check vs structural lines (full-width)
for (const line of structLines) {
const crosses = (top < line.y && bottom > line.y);
const minDist = Math.min(Math.abs(top - line.y), Math.abs(bottom - line.y));
if (crosses || minDist < 8)
issues.push(`"${name}" ${crosses ? 'CROSSES' : minDist+'px from'} ${line.name}`);
}
// Check vs horizontal SVG arrows (only if X ranges overlap)
for (const arrow of arrowLines) {
if (right > arrow.x1 && left < arrow.x2) {
const crosses = (top < arrow.y && bottom > arrow.y);
const minDist = Math.min(Math.abs(top - arrow.y), Math.abs(bottom - arrow.y));
if (crosses || minDist < 8)
issues.push(`"${name}" ${crosses ? 'CROSSES' : minDist+'px from'} ${arrow.name}`);
}
}
});
return issues.length ? issues : 'All labels clear of lines';
}When to run: After every design asset is rendered in the browser — before taking the final screenshot and before delivering to the user. Fix any issues found before declaring the asset done.
Tolerance thresholds:
| Check | Tolerance |
|---|---|
| Centering | 2px |
| Alignment (shared edge) | 2px |
| Even spacing | 4px |
| Connector endpoint clearance | Arrowhead must be ≥ 8px clear of element edge (never overlap boxes) |
| Label-to-arrow proximity | Label must be ≤ 20px from its arrow path |
| Label-to-element proximity | Max 40px from associated element |
| Container breathing room | Elements must be ≥ 20px from container inner edges |
| Text vs lines (structural + SVG arrows) | Labels must be 8px+ clear of ALL lines (borders, dividers, arrow paths) |
| Mirror-distance labels | Gap difference ≤ 4px from shared divider |
| Zone label consistency | Gap difference ≤ 4px between matching zone labels |
AI image generators (Gemini, etc.) often add subtle gradients, glow, or vignettes to backgrounds even when instructed not to. When an asset requires an exact background color (e.g., your brand's slide or web canvas), use this PIL script to force every near-background pixel to the target color after generation.
When to use: After any AI-generated image that must sit on a specific brand background. Also useful for compositing generated illustrations onto slide decks or web pages where color mismatch would be visible.
The script below targets dark canvases (the threshold catches near-black pixels). For light canvases, invert the comparison (r > threshold and g > threshold and b > threshold with a threshold around 200).
from PIL import Image
def enforce_background_color(input_path, output_path, target_rgb, threshold=60):
"""
Replace all near-dark pixels with an exact background color.
Args:
input_path: Path to the source image
output_path: Path to save the processed image
target_rgb: The exact background color as (R, G, B) — use your brand
guide's canvas value, e.g. (18, 18, 18) for #121212
threshold: Pixels where R, G, and B are ALL below this value get replaced.
Default 60 catches dark backgrounds without touching colored elements.
Lower (e.g., 40) for tighter replacement; higher (e.g., 80) for more aggressive.
"""
img = Image.open(input_path).convert("RGB")
pixels = img.load()
w, h = img.size
replaced = 0
for y in range(h):
for x in range(w):
r, g, b = pixels[x, y]
if r < threshold and g < threshold and b < threshold:
pixels[x, y] = target_rgb
replaced += 1
img.save(output_path)
print(f"Replaced {replaced:,} pixels → rgb{target_rgb} in {output_path}")
# Usage: pass your brand guide's exact canvas values
# enforce_background_color("input.png", "output.png", target_rgb=(18, 18, 18))
# enforce_background_color("input.png", "output.png", target_rgb=(18, 18, 18), threshold=40) # tighter matchLook up the exact RGB values for your web canvas, slide background, and card surfaces in /brain/brand-guide/brand-guide.md before running.
Never hand-draw SVG icons when an open-source icon library has what you need. Check these libraries first — they have thousands of professionally designed, consistent icons:
Workflow:
https://unpkg.com/lucide-static@latest/icons/{name}.svgTo embed a Lucide icon in a 120x120 viewBox:
<g transform="translate(10, 10) scale(4.2)" stroke="var(--accent)" stroke-width="0.36" stroke-linecap="round" stroke-linejoin="round" fill="none">
<!-- paste Lucide path data here -->
</g>(Replace var(--accent) with the literal accent hex when the SVG is used standalone outside a page with the custom property defined.)
When asked to design a whitepaper, datasheet, or other multi-page branded document:
page-break-after: always or separate page divs.html-to-pdf skill to export a print-quality vector PDF via Playwright. This gives selectable text, exact colors, and crisp rendering at any zoom.mcp__figma-remote-mcp__generate_figma_design to capture the HTML page into Figma. This imports the design as a visual reference that the team can annotate, adjust, or polish in Figma's editor.Figma plugin APIs can create objects programmatically, but multi-page documents with complex typography, diagrams, pull quotes, and brand styling require hundreds of lines of JS per page. The results are functional but not designer-polished. HTML/CSS gives us:
Figma's strength is collaborative visual editing, not document authoring. Use it as the refinement layer, not the production layer.
<!-- Updated by /reflect in your instance. Promote stable patterns to the main skill body. Ships empty. -->
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.