К основному содержанию
скилл CX Codex

design-system-context — скилл для Claude Code: контекст системы

Скилл design-system-context помогает удерживать токены и решения дизайн-системы в контексте Claude Code. Используйте его, когда сгенерированный интерфейс отходит от заданного стиля.

MIT ★ 126 обновлён 2026-10-04

Установить в Claude Code · Через маркетплейс плагинов Все способы и платформы ↓
/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install context-management@libreuiux
Открыть на GitHub

Что делает design-system-context

Скилл предлагает раскладывать контекст по четырём слоям: бренд и система, токены, компоненты, задача. Базовые сведения и токены доступны постоянно, а описание конкретного компонента загружается по запросу. Так агенту не приходится держать весь каталог компонентов в каждом запросе.

В примерах есть Python-классы для загрузки слоёв и сжатия токенов: палитру можно сократить до ключевых оттенков, а типографику — до основных параметров. Для компонентов описан набор характеристик, вариантов, свойств и примеров. Токенов контекста всё равно нужно придерживаться: полная загрузка дизайн-системы расходует окно и ухудшает работу модели.

Установка через маркетплейс Claude Code состоит из двух команд: сначала добавьте репозиторий, затем установите context-management@libreuiux. В инструкции также приведён способ через npx skills add для этого скилла.

Какие задачи решает

  • удерживать токены дизайн-системы в контексте агента
  • сохранять решения о бренде между сессиями
  • подгружать описание нужного компонента по запросу
  • сокращать сведения о цветах и типографике
  • разделять общие правила и требования текущей задачи

Примеры запросов агенту

  • Используй скилл design-system-context, чтобы загрузить токены и правила бренда перед созданием интерфейса.
  • Сгенерируй компонент по дизайн-системе: подключи контекст компонента и учти его варианты и свойства.
  • Сохрани решения о бренде и требования этой задачи в отдельных слоях контекста.

Как установить design-system-context

1Через маркетплейс плагинов

/plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code
/plugin install context-management@libreuiux

Команда ставит плагин context-management целиком, со всеми его скиллами

2Через Skills CLI (Vercel)

npx skills add Ormus-Solutions/LibreUIUX-Claude-Code --skill design-system-context -a claude-code

3Вручную: положить файлы

~/.claude/skills/design-system-context/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/design-system-context/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о design-system-context

Как установить design-system-context в Claude Code?

В Claude Code выполните команды по порядку: /plugin marketplace add Ormus-Solutions/LibreUIUX-Claude-Code, затем /plugin install context-management@libreuiux.

Что делает скилл design-system-context?

Он описывает, как организовать контекст дизайн-системы для генерации интерфейсов: разделить его на слои, загружать компоненты по запросу и сжимать токены.

Как устроены слои контекста в design-system-context?

Четыре слоя охватывают бренд и систему, токены, компоненты и текущую задачу. Контекст компонента загружается по запросу, а задача получает отдельные ограничения, предпочтения и предыдущие решения.

Исходный текст

SKILL.md · MIT
---
name: design-system-context
description: "Keeping a design system in an LLM's context: loading tokens compactly, persisting design decisions across sessions, handling multiple variants, and budgeting the context window. Use when generated UI drifts from the design system, or when setting up tokens and decisions so every session and agent uses the same ones."
---

# Design System Context Management

Master the art of managing design system context for LLM-driven UI development. This skill covers strategies for loading design tokens, persisting decisions, and optimizing context window usage.

---

## When to Use This Skill

- Loading design tokens into LLM context efficiently
- Persisting design decisions across sessions
- Optimizing context window for large design systems
- Managing multiple design system variants
- Building context-aware UI generation pipelines
- Maintaining consistency across agent conversations

---

## The Context Challenge

Design systems contain vast amounts of information:
- **Design tokens**: Colors, spacing, typography, shadows, etc.
- **Component specs**: 50-200+ components with variants
- **Usage guidelines**: Do's, don'ts, examples
- **Brand guidelines**: Voice, imagery, personality

**The Problem**: Context windows are finite. Loading everything wastes tokens and degrades performance.

**The Solution**: Strategic context management - load what's needed, when it's needed.

---

## Context Architecture

### Layered Context Model

Organize design system context in layers of specificity:

```
Layer 4: Task-Specific Context (highest priority)
         ↑
Layer 3: Component Context
         ↑
Layer 2: Design Token Context
         ↑
Layer 1: Brand/System Context (foundation)
```

**Implementation**:

```python
class DesignSystemContext:
    """
    Layered context management for design systems.
    """

    def __init__(self, system_name: str):
        self.layers = {
            "brand": self.load_brand_context(),      # ~500 tokens
            "tokens": self.load_design_tokens(),     # ~2000 tokens
            "components": {},                         # On-demand
            "task": {},                               # Per-request
        }

    def load_brand_context(self) -> dict:
        """
        Layer 1: Foundational brand context.
        Always loaded, rarely changes.
        """
        return {
            "brand_name": "Acme Corp",
            "brand_voice": "Professional, approachable, confident",
            "core_values": ["Simplicity", "Trust", "Innovation"],
            "color_philosophy": "Blue conveys trust, accent sparingly",
            "typography_philosophy": "Clean sans-serif, generous line-height",
        }

    def load_design_tokens(self) -> dict:
        """
        Layer 2: Design tokens.
        Loaded per session, reference frequently.
        """
        return {
            "colors": {
                "primary": {"50": "#EEF2FF", "500": "#6366F1", "900": "#312E81"},
                "gray": {"50": "#F9FAFB", "500": "#6B7280", "900": "#111827"},
                "success": "#10B981",
                "warning": "#F59E0B",
                "error": "#EF4444",
            },
            "spacing": {
                "0": "0", "1": "0.25rem", "2": "0.5rem",
                "4": "1rem", "6": "1.5rem", "8": "2rem",
            },
            "typography": {
                "font_family": "Inter, system-ui, sans-serif",
                "sizes": {"xs": "0.75rem", "sm": "0.875rem", "base": "1rem"},
                "weights": {"normal": 400, "medium": 500, "bold": 700},
            },
            "radius": {"sm": "0.25rem", "md": "0.375rem", "lg": "0.5rem"},
            "shadows": {
                "sm": "0 1px 2px rgba(0,0,0,0.05)",
                "md": "0 4px 6px rgba(0,0,0,0.1)",
            },
        }

    def load_component_context(self, component_name: str) -> dict:
        """
        Layer 3: Component-specific context.
        Loaded on-demand when working on specific components.
        """
        component_docs = self.fetch_component_docs(component_name)
        return {
            "specification": component_docs.spec,
            "variants": component_docs.variants,
            "props": component_docs.props,
            "examples": component_docs.examples[:3],  # Limit examples
            "related_components": component_docs.related[:5],
        }

    def set_task_context(self, task: dict) -> None:
        """
        Layer 4: Task-specific context.
        Fresh per request, highest priority.
        """
        self.layers["task"] = {
            "objective": task.get("objective"),
            "constraints": task.get("constraints", []),
            "preferences": task.get("preferences", {}),
            "previous_decisions": task.get("decisions", []),
        }
```

---

## Token-Efficient Context Strategies

### Strategy 1: Compressed Token Format

Reduce verbosity while maintaining meaning:

```python
# Verbose format (~200 tokens)
verbose_tokens = """
The primary color palette consists of:
- Primary 50 (lightest): #EEF2FF, used for backgrounds
- Primary 100: #E0E7FF
- Primary 200: #C7D2FE
- Primary 500 (base): #6366F1, used for primary actions
- Primary 600: #4F46E5
- Primary 900 (darkest): #312E81, used for text on light
"""

# Compressed format (~50 tokens)
compressed_tokens = """
colors.primary: {50:#EEF2FF(bg), 500:#6366F1(action), 900:#312E81(text)}
"""

# Ultra-compressed format (~20 tokens)
ultra_compressed = "pri:#6366F1 bg:#EEF2FF txt:#312E81"
```

**Compression Techniques**:

```python
class TokenCompressor:
    """
    Compress design tokens for efficient context usage.
    """

    def compress_colors(self, colors: dict) -> str:
        """
        Compress color palette to essential values.
        Only include: 50 (light), 500 (base), 900 (dark)
        """
        essential = {}
        for name, shades in colors.items():
            essential[name] = {
                k: v for k, v in shades.items()
                if k in ["50", "500", "900"]
            }
        return json.dumps(essential, separators=(",", ":"))

    def compress_spacing(self, spacing: dict) -> str:
        """
        Compress spacing to pattern description.
        """
        # Instead of listing all values
        return "spacing: 4px base unit, scale: 1,2,4,6,8,12,16,24,32"

    def compress_typography(self, typography: dict) -> str:
        """
        Compress typography to essentials.
        """
        return f"font:{typography['font_family'].split(',')[0]} sizes:xs/sm/base/lg/xl"
```

---

### Strategy 2: Semantic Chunking

Split context into semantic chunks for retrieval:

```python
class SemanticContextChunks:
    """
    Organize design system into retrievable semantic chunks.
    """

    def __init__(self, design_system: dict):
        self.chunks = self.create_chunks(design_system)
        self.embeddings = self.embed_chunks()

    def create_chunks(self, system: dict) -> list[dict]:
        """
        Create semantic chunks from design system.
        """
        chunks = []

        # Color chunks
        chunks.append({
            "type": "colors",
            "category": "primary",
            "description": "Primary brand colors for actions and emphasis",
            "content": system["tokens"]["colors"]["primary"],
        })

        chunks.append({
            "type": "colors",
            "category": "semantic",
            "description": "Semantic colors for feedback states",
            "content": {
                "success": system["tokens"]["colors"]["success"],
                "warning": system["tokens"]["colors"]["warning"],
                "error": system["tokens"]["colors"]["error"],
            },
        })

        # Component chunks
        for component in system["components"]:
            chunks.append({
                "type": "component",
                "category": component["category"],
                "description": component["description"],
                "content": component["spec"],
            })

        return chunks

    def retrieve_relevant(self, query: str, top_k: int = 5) -> list[dict]:
        """
        Retrieve chunks relevant to the current task.
        """
        query_embedding = self.embed(query)
        scores = [
            (chunk, cosine_similarity(query_embedding, emb))
            for chunk, emb in zip(self.chunks, self.embeddings)
        ]
        return sorted(scores, key=lambda x: x[1], reverse=True)[:top_k]
```

---

### Strategy 3: Progressive Disclosure

Load context progressively as needed:

```python
class ProgressiveContextLoader:
    """
    Load context progressively based on task needs.
    """

    def __init__(self, design_system: DesignSystem):
        self.system = design_system
        self.loaded_context = {}
        self.context_budget = 8000  # tokens

    def initial_context(self) -> dict:
        """
        Minimal context for task understanding.
        ~500 tokens
        """
        return {
            "system_summary": self.system.summary,
            "available_components": list(self.system.component_names),
            "color_palette_summary": self.system.color_summary,
        }

    def expand_for_component(self, component_name: str) -> dict:
        """
        Expand context when working on specific component.
        +1000-2000 tokens
        """
        if component_name in self.loaded_context:
            return self.loaded_context[component_name]

        context = {
            "component_spec": self.system.get_component(component_name),
            "related_tokens": self.system.get_tokens_for(component_name),
            "examples": self.system.get_examples(component_name, limit=2),
        }

        self.loaded_context[component_name] = context
        return context

    def expand_for_layout(self) -> dict:
        """
        Expand context for layout work.
        +500 tokens
        """
        return {
            "spacing_scale": self.system.spacing,
            "breakpoints": self.system.breakpoints,
            "grid_system": self.system.grid,
            "container_widths": self.system.containers,
        }

    def get_current_context(self) -> str:
        """
        Get current accumulated context within budget.
        """
        context_str = json.dumps(self.loaded_context)
        token_count = self.count_tokens(context_str)

        if token_count > self.context_budget:
            return self.prune_context(context_str)

        return context_str
```

---

## Persisting Design Decisions

### Decision Memory Pattern

Store and recall design decisions for consistency:

```python
class DesignDecisionMemory:
    """
    Persistent memory for design decisions.
    """

    def __init__(self, project_id: str, storage: Storage):
        self.project_id = project_id
        self.storage = storage
        self.decisions = self.load_decisions()

    def record_decision(self, decision: DesignDecision) -> None:
        """
        Record a design decision for future reference.
        """
        entry = {
            "id": str(uuid4()),
            "timestamp": datetime.now().isoformat(),
            "category": decision.category,  # color, spacing, component, etc.
            "component": decision.component,
            "decision": decision.description,
            "rationale": decision.rationale,
            "tokens_affected": decision.tokens,
            "embedding": self.embed(decision.description),
        }

        self.decisions.append(entry)
        self.storage.save(self.decisions)

    def recall_for_context(self, current_task: str) -> list[dict]:
        """
        Recall relevant past decisions for current task.
        """
        task_embedding = self.embed(current_task)

        relevant = []
        for decision in self.decisions:
            similarity = cosine_similarity(task_embedding, decision["embedding"])
            if similarity > 0.7:
                relevant.append({
                    "decision": decision["decision"],
                    "rationale": decision["rationale"],
                    "relevance": similarity,
                })

        return sorted(relevant, key=lambda x: x["relevance"], reverse=True)[:5]

    def format_for_prompt(self, decisions: list[dict]) -> str:
        """
        Format decisions for prompt injection.
        """
        if not decisions:
            return ""

        lines = ["## Previous Design Decisions (maintain consistency):"]
        for d in decisions:
            lines.append(f"- {d['decision']}")
            if d.get("rationale"):
                lines.append(f"  Rationale: {d['rationale']}")

        return "\n".join(lines)


# Usage in prompt construction
memory = DesignDecisionMemory("project-123", storage)
relevant_decisions = memory.recall_for_context("Create a modal dialog")

prompt = f"""
{base_prompt}

{memory.format_for_prompt(relevant_decisions)}
"""
```

---

### Version-Controlled Context

Treat design context as versioned artifacts:

```python
class VersionedDesignContext:
    """
    Version-controlled design system context.
    """

    def __init__(self, repo_path: str):
        self.repo_path = repo_path
        self.current_version = self.get_current_version()

    def get_context_at_version(self, version: str) -> dict:
        """
        Load design context at specific version.
        Useful for reproducing past generations.
        """
        tokens_path = f"{self.repo_path}/tokens/{version}/tokens.json"
        components_path = f"{self.repo_path}/components/{version}/"

        return {
            "version": version,
            "tokens": self.load_json(tokens_path),
            "components": self.load_components(components_path),
        }

    def diff_versions(self, v1: str, v2: str) -> dict:
        """
        Show differences between context versions.
        Useful for understanding changes.
        """
        ctx1 = self.get_context_at_version(v1)
        ctx2 = self.get_context_at_version(v2)

        return {
            "tokens_added": self.diff_tokens(ctx1["tokens"], ctx2["tokens"]),
            "tokens_changed": self.changed_tokens(ctx1["tokens"], ctx2["tokens"]),
            "components_added": self.diff_components(ctx1, ctx2),
        }

    def get_migration_context(self, from_v: str, to_v: str) -> str:
        """
        Generate context for migrating components between versions.
        """
        diff = self.diff_versions(from_v, to_v)

        return f"""
        ## Design System Migration: {from_v} -> {to_v}

        ### Token Changes
        {self.format_token_changes(diff['tokens_changed'])}

        ### New Tokens
        {self.format_new_tokens(diff['tokens_added'])}

        ### Update Instructions
        When updating components, apply these token mappings...
        """
```

---

## Context Window Optimization

### Token Budget Allocation

Allocate context window strategically:

```python
class ContextBudgetManager:
    """
    Manage context window token budget.
    """

    def __init__(self, total_budget: int = 100000):  # Claude's context
        self.total = total_budget
        self.allocations = {
            "system_prompt": 2000,    # Fixed instructions
            "design_tokens": 3000,    # Core tokens
            "component_context": 4000, # Current component
            "examples": 2000,         # Few-shot examples
            "memory": 1000,           # Past decisions
            "task": 500,              # Current request
            "output_buffer": 10000,   # Reserved for response
        }

    def remaining_budget(self) -> int:
        """
        Calculate remaining tokens for dynamic content.
        """
        allocated = sum(self.allocations.values())
        return self.total - allocated

    def can_load(self, content: str, category: str) -> bool:
        """
        Check if content fits in category budget.
        """
        token_count = self.count_tokens(content)
        return token_count <= self.allocations.get(category, 0)

    def optimize_context(self, context: dict) -> dict:
        """
        Optimize context to fit within budget.
        """
        optimized = {}

        for key, content in context.items():
            budget = self.allocations.get(key, 1000)
            content_tokens = self.count_tokens(str(content))

            if content_tokens <= budget:
                optimized[key] = content
            else:
                optimized[key] = self.truncate_intelligently(content, budget)

        return optimized

    def truncate_intelligently(self, content: any, budget: int) -> any:
        """
        Truncate content preserving most important information.
        """
        if isinstance(content, list):
            # For lists, keep first N items
            result = []
            tokens = 0
            for item in content:
                item_tokens = self.count_tokens(str(item))
                if tokens + item_tokens <= budget:
                    result.append(item)
                    tokens += item_tokens
            return result

        if isinstance(content, dict):
            # For dicts, prioritize by key importance
            priority_keys = ["essential", "primary", "core", "main"]
            result = {}
            tokens = 0

            # First pass: priority keys
            for key in priority_keys:
                if key in content:
                    result[key] = content[key]
                    tokens += self.count_tokens(str(content[key]))

            # Second pass: remaining keys if budget allows
            for key, value in content.items():
                if key not in result:
                    value_tokens = self.count_tokens(str(value))
                    if tokens + value_tokens <= budget:
                        result[key] = value
                        tokens += value_tokens

            return result

        # For strings, truncate with ellipsis
        return self.truncate_string(content, budget)
```

---

## Context Injection Patterns

### Pattern: Structured Context Block

Inject context as a structured, parseable block:

```markdown
<!-- DESIGN_CONTEXT_START -->
## Active Design System: Acme Design v2.3

### Tokens
```json
{
  "colors": {"primary": "#6366F1", "gray": "#6B7280"},
  "spacing": {"base": "4px", "scale": [1,2,4,6,8,12,16]},
  "radius": {"default": "8px"}
}
```

### Component: Button
- Variants: primary, secondary, ghost, danger
- Sizes: sm (32px), md (40px), lg (48px)
- States: default, hover, focus, active, disabled, loading

### Constraints
- Tailwind CSS only
- Accessibility: WCAG 2.1 AA
- Must support dark mode
<!-- DESIGN_CONTEXT_END -->
```

### Pattern: Inline Context References

Reference context inline rather than loading fully:

```markdown
Generate a Card component.

Use these token references (from loaded design system):
- Background: `tokens.colors.surface.primary`
- Border: `tokens.colors.border.subtle`
- Padding: `tokens.spacing.lg` (maps to p-6)
- Radius: `tokens.radius.lg` (maps to rounded-xl)
- Shadow: `tokens.shadows.md` (maps to shadow-md)

The component should resolve these references to actual Tailwind classes.
```

---

## Quick Reference

| Challenge | Strategy |
|-----------|----------|
| Too many tokens | Compressed Token Format |
| Finding relevant context | Semantic Chunking + Retrieval |
| Large design systems | Progressive Disclosure |
| Maintaining consistency | Decision Memory Pattern |
| Reproducing results | Version-Controlled Context |
| Budget constraints | Token Budget Allocation |

---

## Integration Points

This skill integrates with:
- `agent-orchestration/ui-agent-patterns` - Context for agent workflows
- `llm-application-dev/prompt-engineering-ui` - Token injection in prompts
- `llm-application-dev/rag-implementation` - Retrieval of context chunks
- `mcp-integrations/browser-devtools-mcp` - Live context from running UI

---

*"Context is not just what the model sees - it is what the model becomes."*

© Seth Hobson · MIT · Ormus-Solutions/LibreUIUX-Claude-Code

Похожие скиллы

Все скиллы по теме «Настройка агента: память, контекст, субагенты» →
design-system BuilderOS Скилл design-system собирает дизайн-систему по скриншотам или макетам и записывает её сразу в два файла: docs/design.md для агента и docs/design.html для браузера. CX Codex +1 1 900установок migrate-design-system plugin87 Скилл migrate-design-system для Claude Code связывает внутренние токены интерфейса со сторонними дизайн-системами. Помогает переносить темы на Material Design 3, Apple HIG, Carbon или shadcn/ui. CX Codex +1 564установок design-system-creation aj-geddes Скилл design-system-creation для Claude Code собирает дизайн-систему: компоненты, токены, правила и документацию. Держит структуру, когда растут интерфейсы или команды. CX Codex +1 545установок design-system-starter davila7 Скилл design-system-starter помогает заложить дизайн-систему в проекте: генерирует дизайн-токены в JSON, структуру React-компонентов и проверяет контрастность по WCAG 2.1 AA. CX Codex +1 186установок design-system-generator OneWave-AI Скилл design-system-generator для Claude Code и других агентов: собирает дизайн-систему из токенов, базовых компонентов и документации. Выручает, когда цвета расползаются по второму экрану. CX Codex +1 324установок ui-design-system Alireza Rezvani Скилл ui-design-system для Claude Code собирает дизайн-токены, палитры, типографику и структуру компонентов. Помогает создавать дизайн-системы и передавать макеты разработчикам. CX Codex +1 1 076установок

Из того же набора42

Весь набор →
synthesis-master Субагент synthesis-master координирует UI- и UX-плагины LibreUIUX в Claude Code. Применяет принципы дизайна, доступности, безопасности и скорости перед выпуском интерфейса в прод. CX Codex ★ 126звёзд репо ui-synth Команда ui-synth собирает запрос на интерфейс в план дизайна и реализации: от визуальной системы до тестов и SEO. Используйте её, когда хотите описать компонент или функцию и получить согласованный UI/UX. CX Codex +1 ★ 126звёзд репо major-arcana Скилл major-arcana для Claude Code сопоставляет 22 карты Старшего Аркана с цветовыми палитрами, освещением и атмосферой интерфейсов. Создаёт символическую систему дизайна по названной пользователем карте. CX Codex +1 ★ 126звёзд репо ui-agent-patterns Скилл ui-agent-patterns описывает архитектурные паттерны оркестрации ИИ-агентов для вёрстки интерфейсов, дизайн-систем и передачи контекста между исследователем, дизайнером и ревьюером. CX Codex +1 ★ 126звёзд репо browser-devtools-mcp Скилл browser-devtools-mcp подключает автоматизацию браузера через MCP, чтобы Claude Code проверял реальный интерфейс, снимал скриншоты, читал computed styles и собирал код по макету. CX Codex +1 ★ 126звёзд репо smart-fix Команда smart-fix для Claude Code, которая запускает цепь специализированных агентов для анализа и исправления production-проблем. CX Codex +1 ★ 126звёзд репо libreuiux-hooks Плагин libreuiux-hooks добавляет в Claude Code три хука: автоопределение UI-стека, подтверждение перед правкой секретов и подсказки по доступности после редактирования интерфейса. ★ 126звёзд репо vibe-coding Скилл vibe-coding помогает быстро собирать временные UI-прототипы, сравнивать варианты и решать, когда переходить к производственной реализации. Пригодится на этапе проверки идей и пользовательских сценариев. ★ 126звёзд репо

Спонсоры проекта

Компании, которые помогают держать аналитику открытой