Brand Workshop

Brand Workshop

A collaborative branding skill that assembles a virtual creative team, runs a structured brainstorming session, and delivers a brand strategy brief, tagline, and logo.

STOP — When NOT to use this skill

This skill generates brand identity from a business overview. It is NOT a remix tool for a brand that already exists. Hand off to team-composer — do not run the workshop — if any of these are true:

• The user already has a logo in use and is asking to refresh / update / audit it
• The user already has a style guide and is asking to modernize or refresh it
• The user says "our current brand", "our existing voice", "our logo", "our palette"
• The request is "update our brand voice" / "refresh our style guide" / "our brand has evolved"
• The deliverable is a style-guide update, voice audit, or brand refresh — not a net-new identity

How to hand off:

Invoke team-composer:team-composer as the next skill. Use the literal skill identifier — do NOT pick a plausibly-adjacent skill by name match alone.

Anti-patterns — do NOT invoke any of these in place of team-composer:

• brand-voice:guideline-generation — this is for extracting voice from existing

sales calls / uploaded brand documents. It's a voice-discovery workflow, not a refresh workshop. Using it here will pull the user into a discovery loop they didn't ask for.

• brand-voice:discover-brand — this searches Notion / Slack / Drive for scattered

brand materials. The user already knows where their brand lives — they want to evolve it, not find it.

• brand-voice:brand-voice-enforcement — this applies an already-written voice

guide to new content. It does not produce a refresh.

• brand-workshop:brand-workshop (this skill) — do not recursively re-enter after

the STOP check.

Once inside team-composer:team-composer, use @brand_strategist + @senior_copywriter for voice work, or @naming_specialist for naming. Do not proceed with the Discovery → Concept → Creation workshop described below.

---

Overview

This skill simulates a brand workshop with specialized roles working together. The process moves through three phases: Discovery → Concept → Creation. The output is always:

1. Brand Strategy Brief (brand-brief.md) — the team's rationale, concepts explored, and final direction
2. Tagline — embedded in the brief and called out prominently
3. Logo (.svg rendered to .png) — code-generated, defaulting to minimalist style
4. Favicon Pack — favicon.svg, raster sizes (16/32/180/512), site.webmanifest, and a copy-paste HTML `` install snippet
5. Social Banner Set — Open Graph (1200×630), X header (1500×500), LinkedIn banner (1584×396), Instagram square (1080×1080), profile avatar (400×400)
6. Descriptions Pack (descriptions.md) — tagline + short/medium/long bios + elevator pitch + press boilerplate, all matched to brand voice
7. Starter Design System (DESIGN.md) — tokens only: color, typography, spacing, radius, and voice principles (no component specs)

Scope boundary: pitch decks (both the deck template and filled slide content) and the Business Model Canvas are intentionally out of scope. The pitch-deck skill reads DESIGN.md directly and generates a brand-skinned deck on its own — brand-workshop does not pre-emit a deck template. See Skill Boundaries below.

---

Skill Boundaries

This skill overlaps partially with team-composer. Both assemble a virtual team and run structured discussion. The difference is what they produce.

Use team-composer instead of this skill when:

• The user wants general project brainstorming, planning, or review — even if branding is part of it
• The user wants to name a product/feature (use @naming_specialist), discuss positioning (use @brand_strategist), or review brand voice (use @humorist + @senior_copywriter)
• The deliverable is NOT a logo + tagline + brief package
• The user is making multi-dimensional product decisions where branding is one input among many

Stay in this skill when:

• The primary deliverable is a brand identity package: logo (SVG) + tagline + brand strategy brief
• The user says: "help me brand my [startup/product/app]", "I need a logo", "create a brand identity", "design a brand concept", "give me a tagline and logo"
• The user provides a business overview and asks for visual identity work

Boundary examples:

| Request | Skill | |---------|-------| | "Help me brand my new fintech startup" | brand-workshop (this skill) | | "I need a logo for X" | brand-workshop (this skill) | | "Brainstorm my startup — product, positioning, go-to-market, branding" | team-composer (branding is one dimension) | | "Name my product" | team-composer with @naming_specialist | | "Review our product positioning" | team-composer with @brand_strategist | | "Does our copy sound right?" | team-composer with @humorist + @senior_copywriter |

Stop-rule — existing brands:

If the user's request is to audit, refresh, document, or extend an existing brand (logo already in use, style guide already drafted, "make our current brand more X", "update our brand voice"), stop and invoke team-composer instead. This skill generates brand identity from a business overview — it is not a remix/audit tool for a live brand.

> Future refactor note (Option D): Today this skill has its own internal team > (see Phase 2). Long-term, this skill could invoke team-composer as the > discussion engine and focus only on the Creation phase (logo SVG, brief > assembly). That refactor is not scheduled — revisit only if the role catalog > drift between the two skills causes real maintenance pain. When revisited, > unify role tag format (@hyphen-case here vs. @snake_case in team-composer).

> Companion plugins (the startup pipeline). This skill is step 1 of 5: > brand-workshop → validation-canvas → riskiest-assumption-test → > pitch-deck → startup-grill. Each lives in its own plugin directory. > They are intentionally not folded together: each requires founder inputs > (traction, revenue model, ask size, test results) that are out of scope > for a brand workshop. After this skill ships, suggest validation-canvas > as the next step — see Phase 7 (Closing). An umbrella startup-launch-kit > plugin may later orchestrate all five.

---

Phase 1: Discovery

Step 0.0 — Path resolution + manifest awareness (v2.2.0+)

Resolve the brand root once at invocation, in this precedence order (canonical chain):

1. Explicit output_dir arg (passed by startup-launch-kit) → use as-is.
2. STARTUP_KIT_DOCS_ROOT env var set → ${STARTUP_KIT_DOCS_ROOT}/brand/.
3. Smart default — docs/startup-kit/ exists → docs/startup-kit/brand/.

Surface the smart-default notice: "Writing to docs/startup-kit/brand/ (smart default). Set STARTUP_KIT_DOCS_ROOT=./docs to write standalone instead."

1. Solo fallback → docs/brand/.

Note (v2.2.0 path migration): prior versions wrote artifacts to the working-directory root and downstream skills expected brand-kit/ as the prefix — these were inconsistent. v2.2.0 standardizes on / (default docs/brand/). Downstream skills include legacy brand-kit/ fallback reads for backward compat.

Manifest awareness. Look for kit-manifest.json at /kit-manifest.json first; fall back to the working-directory root for backward compat. Use it as a hint, never as a bypass:

• If the manifest lists brand-workshop as completed with a recent mtime,

surface that fact: "Manifest says you ran brand-workshop on [date]. Update mode (revise specific assets), fresh run (rebuild everything), or skip to the next step?"

• If the manifest's intake_answers cache is populated, the founder has run

the orchestrator's intake — use those answers as defaults for the discovery questions below (still surface them; do not silently skip).

• Manifest read failures (corrupt JSON, missing fields) are non-fatal — log

the issue inline and proceed as if no manifest exists.

After this skill ships its artifacts (Phase 6 — output), if a manifest exists, append/update this skill's entry. Use atomic write (write .tmp, then rename). If the manifest doesn't exist, do NOT create it — that's the startup-launch-kit orchestrator's job. See [startup-launch-kit/references/manifest-schema.md](../startup-launch-kit/references/manifest-schema.md) for the schema.

Gather Inputs

Collect the following from the user. If some are missing, ask concisely — but don't block on everything. Make reasonable assumptions and state them.

| Input | Required | Notes | |-------|----------|-------| | Business / product name | Yes | — | | Business overview | Yes | What it does, who it serves | | Vision | Helpful | Long-term aspiration | | Mission | Helpful | How it delivers value | | App features (if app) | Optional | Helps understand the product's nature | | Target audience | Helpful | Demographics, psychographics | | Existing brand assets | Optional | Colors, fonts, prior logos | | Logo style preference | Optional | Defaults to minimalist w/ negative space | | Tagline language | Optional | Defaults to English |

Style Default

If the user does not specify a logo style, default to minimalist with negative space. This style emphasizes clean geometry, hidden meaning through negative space, and timeless simplicity. It works well across digital and print.

If the user asks for style suggestions, read references/logo-styles.md and present the options with brief descriptions and famous examples.

---

Phase 2: Concept — The Workshop

Assemble the virtual team and run a structured brainstorming. Each role contributes a distinct perspective. The workshop is NOT a free-for-all — it follows a deliberate sequence.

The Team

Read references/team-roles.md for detailed role definitions. Summary:

| Role | Primary Contribution | |------|---------------------| | @senior-brand-strategist | Positioning, brand architecture, competitive differentiation | | @senior-copywriter | Tagline candidates, verbal identity, tone of voice | | @lead-visual-designer | Logo direction, color palette, typography | | @product-designer | How the brand lives in-product (if app/digital) | | @growth-strategist | Memorability, virality, market fit of the brand | | @regional-cultural-advisor | Cultural sensitivity, linguistic pitfalls, local resonance | | @lead-ux-ui-designer | Digital-first considerations, favicon/app-icon viability |

Not every role needs to speak on every project. Scale participation to the project:

• Minimum (simple logo request): strategist, copywriter, visual designer
• Full team (app/product branding): all roles
• Add roles if context demands it (e.g., @accessibility-specialist for inclusive branding)

Workshop Flow

Run these steps sequentially. Write each role's contribution in first person with their role tag (e.g., **@senior-brand-strategist:**). This becomes the brainstorming transcript in the brand brief.

Step 1: Strategic Foundation (Strategist)

• Define brand positioning: what makes this distinct?
• Identify 2-3 brand archetypes that fit
• Propose core brand attributes (3-5 adjectives)

Step 2: Verbal Exploration (Copywriter)

• Generate 5-7 tagline candidates based on positioning
• Note tone of voice direction
• Flag any naming/linguistic concerns
• Draft the descriptions pack variants (short / medium / long bio, elevator pitch,

boilerplate) — these feed directly into Phase 3 and must match the tagline's voice. Each variant should stand alone, not read as a truncation of the next.

Step 3: Visual Direction (Visual Designer + UX/UI Designer)

• Propose 2-3 logo concepts (described verbally — shape, symbolism, approach)
• Suggest color palette direction (with hex values)
• Recommend typography family
• UX/UI designer weighs in on digital viability (favicon test, dark/light modes)

Step 4: Cultural & Market Check (Cultural Advisor + Growth Strategist)

• Cultural advisor flags any issues with symbols, colors, or words across cultures
• Growth strategist evaluates memorability and market positioning

Step 5: Convergence (Strategist leads)

• Synthesize: pick the winning tagline and logo direction
• State the rationale clearly
• The team votes (brief inline votes from each role)
• Declare the final concept

---

Phase 3: Creation

Brand Strategy Brief

Output a .md file with this structure:

# Brand Strategy Brief: [Business Name]

## Executive Summary
One paragraph: what was created and why.

## Inputs
- Business overview, vision, mission (as provided)

## Positioning
2–4 sentences naming the target segment, the category the brand plays in, and
the one axis of differentiation. This is the section downstream plugins
(`pitch-deck`) parse for the problem/solution narrative — keep it short and
literal, not aspirational.

## Voice & Tone
3–5 bullets from the copywriter describing how the brand speaks (e.g.,
"confident but not arrogant", "plain language over jargon", "contractions OK").
Must match the bullets written into `DESIGN.md → Voice` (the custom Voice
section that brand-workshop appends after Do's and Don'ts) — these are the
same ruleset, surfaced in two places.

## Workshop Transcript
The full brainstorming from Phase 2, role by role.

## Final Concept

### Tagline
> "[The chosen tagline]"

Rationale: Why this tagline wins.

### Logo Concept
Description of the chosen logo direction, symbolism, and style.

### Color Palette
| Color | Hex | Usage |
|-------|-----|-------|
| Primary | #XXXXXX | ... |
| Secondary | #XXXXXX | ... |
| Accent | #XXXXXX | ... |

### Typography
Recommended font families and usage.

## Rejected Alternatives
Brief note on other tagline/logo concepts explored and why they were passed over.

Section-contract note: ## Positioning and ## Voice & Tone are named anchor headings — pitch-deck greps by them. If you rename, update pitch-deck/SKILL.md Phase 1 Step 1 in lockstep.

Logo Creation

Generate the logo as SVG using Python. Follow these principles:

Design Principles (Minimalist / Negative Space default):

• Clean geometric shapes — circles, rectangles, triangles, arcs
• Negative space to embed hidden meaning (e.g., the arrow in FedEx, the bear in Toblerone)
• Maximum 2-3 colors from the chosen palette
• The logo must work at 32x32 (favicon) and 512x512
• No raster effects — pure vector geometry
• Text in the logo (if any) should use basic sans-serif or be drawn as paths
• Aim for a logomark (icon) + optional logotype (wordmark) lockup

Technical approach:

1. Generate SVG using Python string construction or svgwrite library
2. Keep the SVG clean — no unnecessary groups or transforms
3. Render to PNG at multiple sizes (64px, 256px, 512px) using cairosvg or librsvg
4. If rendering tools aren't available, output the SVG and note that PNG conversion

can be done externally

Code quality:

• Write the SVG generation code clearly with comments explaining each shape's purpose
• Test the SVG is valid XML before saving
• Include viewBox for proper scaling

If the user requests AI-generated imagery instead: Use the Hugging Face dynamic_space tool to find and invoke an image generation space. This is opt-in only — never default to it.

Favicon Pack

Generate a favicon set from the logomark. The mark must remain legible at 16×16 — if fine detail disappears at that size, author a simplified favicon-optimized variant (same concept, fewer strokes) rather than scaling the full mark blindly.

Outputs (under favicons/):

| File | Purpose | |------|---------| | favicon.svg | Vector source (modern browsers prefer SVG favicons) | | favicon-16.png, favicon-32.png | Classic browser favicons | | favicon-180.png | apple-touch-icon (iOS home-screen) | | favicon-512.png | PWA / hig

…

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: sorawit-w
• Source: sorawit-w/agent-skills
• License: MIT

Install and usage instructions live in the source repository linked above.