Designbrief logo

Designbrief

Organization
Heiberg-Industries
designbrief

A library of UI design direction files that provide style guardrails for building tasteful, consistent interfaces. Use when building any UI — select a style or let the AI recommend one based on the project context.

Overview

PublisherHeiberg-Industries
Repositorydesignbrief
Skill namedesignbrief
Stars
10
Forks
2
Bundled files
38
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 38 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by Heiberg-Industries on GitHub. Read the source before you install it.

Installation

Install the Designbrief AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/Heiberg-Industries/designbrief/tree/main
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/Heiberg-Industries/designbrief.git \
  .claude/skills/designbrief
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Designbrief in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Designbrief on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Designbrief is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

designbrief

A library of rich design direction files — one per UI style — that provide guardrails for building tasteful, consistent interfaces without prescribing exact values.

How It Works

Each style is a standalone markdown file in styles/ that defines the design DNA of a visual direction: typography families, color theory, spacing philosophy, border/shadow characteristics, layout principles, component behavior, and implementation guidance.

These are guardrails, not templates. They define what kind of font, color, spacing — not the exact values. The developer (or AI) makes specific choices within the style's constraints.

When This Skill Activates

Use this skill when the user:

  • Asks to build any UI, page, component, or app
  • Mentions a specific design style by name
  • Asks for style recommendations or comparisons
  • Wants to change the visual direction of an existing project

Workflow

1. Determine the Style

If the user specifies a style (e.g., "use Bauhaus", "make it glassmorphic"):

  • Read the corresponding file from styles/{style-name}.md
  • Apply its guardrails to all UI decisions

If the user does NOT specify a style:

  • Read styles/_index.md for the full catalog with mood/industry tags
  • Ask the user what mood, audience, and industry they're targeting
  • Recommend 2-3 styles with brief reasoning
  • Let them choose, then load the full style file

2. Apply the Style

When generating UI code, use the style file as your design system:

  • Typography: Choose specific fonts from within the style's recommended families/characteristics
  • Colors: Build a palette that follows the style's color theory and contrast rules
  • Spacing: Apply the style's spacing philosophy (generous vs. tight, rhythmic vs. uniform)
  • Components: Shape buttons, cards, inputs, navbars according to the style's component guidance
  • Layout: Follow the style's grid and composition principles
  • Effects: Apply borders, shadows, blur, gradients per the style's visual depth rules
  • Dark/Light Mode: Check the style's Dark Mode & Light Mode section. If the user hasn't specified, use the style's recommended primary mode. If they ask for both, implement the style's palette adaptation for each.
  • Responsive: Apply the style's Responsive & Mobile guidance. Ensure touch targets (44px minimum), compress spacing and typography for mobile, and handle any performance concerns (e.g., heavy blur on mobile devices).
  • Content & Voice: Match headline tone, body copy style, CTA language, and microcopy personality to the style's Content & Voice section.
  • Icons & Illustrations: Choose icon sets and illustration approaches that match the style's guidance.
  • Accessibility: Verify contrast ratios per the style's Accessibility section. Implement style-appropriate focus states. Add prefers-reduced-motion fallbacks for animations.

3. Teach Along the Way

When making a design decision, briefly explain why (one sentence) to help the user build taste over time. For example: "Using a warm off-white (#FAF8F5) instead of pure white because Japandi draws from natural materials — pure white feels clinical, not crafted." This is optional but encouraged, especially when the user is learning.

4. Stay Consistent

Once a style is selected for a project:

  • Reference the style file for every new component or page
  • Do not mix styles unless explicitly asked to create a hybrid
  • When in doubt about a design decision, re-read the relevant section of the style file
  • The style's "Don'ts" section is as important as its "Do's"
  • Ensure dark mode, responsive behavior, content tone, and accessibility remain consistent across all pages

File Structure

styles/
├── _index.md              # Catalog of all styles with tags, mood, best-for
├── bauhaus.md             # Each style is a rich guardrail document
├── glassmorphism.md
├── neubrutalism.md
├── flat-design.md
├── ... (21 styles total)

Style File Anatomy

Every style file follows this structure:

  1. Non-Negotiables — The 3 defining characteristics that MUST be present for the style to be recognizable
  2. Identity — Name, origin, mood keywords, best-for industries
  3. Typography — Font families/characteristics, scale philosophy, weight usage
  4. Color — Palette theory, contrast approach, accent strategy
  5. Spacing & Layout — Grid system, whitespace philosophy, rhythm, composition
  6. Borders & Shadows — Radius, depth, elevation, visual effects
  7. Components — How buttons, cards, inputs, navbars, modals should look and feel
  8. Motion — Animation philosophy, transition characteristics
  9. Dark Mode & Light Mode — Palette adaptation, mode preference, implementation
  10. Responsive & Mobile — Typography scaling, spacing compression, layout collapse, touch targets, performance
  11. Content & Voice — Headline tone, body copy style, CTA language, microcopy personality
  12. Icons & Illustrations — Icon style, illustration approach, photography direction
  13. Accessibility — Contrast verification, focus states, motion sensitivity, screen reader considerations
  14. Do's and Don'ts — Critical guardrails to maintain style integrity
  15. Implementation Hints — Tailwind classes, CSS custom properties, token ranges

Important Notes

  • These files define direction, not specification. Two projects using the same style should look related but not identical.
  • Always prioritize readability and accessibility over style purity. If a style's aesthetic conflicts with usability, usability wins. Check the style's Accessibility section for known risks and remediation.
  • The user can override any guardrail — the style file is a starting point, not a cage.
  • When building for mobile, follow the style's Responsive & Mobile section — adapt the principles to touch targets and smaller viewports rather than abandoning them.
  • Match the content tone to the visual style. A Neubrutalism site with corporate copy feels wrong; a Corporate Modern site with slang feels unprofessional. The Content & Voice section guides this.
  • When teaching: good design is not arbitrary. Every rule exists for a reason — the "why" matters more than the "what." Help users understand the reasoning behind choices so they build taste over time.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Designbrief AI skill do?

A library of UI design direction files that provide style guardrails for building tasteful, consistent interfaces. Use when building any UI — select a style or let the AI recommend one based on the project context.

Why use Designbrief on TypingMind?

Because you install it once and use it with any model. Designbrief is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Designbrief in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/Heiberg-Industries/designbrief/tree/main. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Designbrief?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Designbrief?

As many as you like. As long as a model supports skills, you can use Designbrief with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Designbrief AI skill free?

Yes. It is published on GitHub by Heiberg-Industries under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇