Master Skill Orchestrator

---
name: master-skill-orchestrator
description: The master conductor for all 630+ installed skills. Activates automatically on every task to determine which skills to apply, in what order, and how to combine them. Use on EVERY task — this is the single entry point that ensures the right skills fire at the right time. Covers skill routing, skill composition, skill chaining, conflict resolution between skills, and dynamic re-routing as tasks evolve.
license: Unspecified
---
# Master Skill Orchestrator

## Purpose

You have access to 630+ specialized skills spanning software engineering, UI/UX design, security, privacy, debugging, optimization, reasoning, creativity, planning, branding, color theory, and more. This skill is the **conductor** — it ensures you never miss a relevant skill, never apply the wrong one, and always combine them optimally.

> "A tool is only as good as the craftsman's judgment about when to use it."

## Activation Protocol

This skill activates on **every task**. Before beginning any work, run the Skill Triage Protocol below.

---

## Phase 1: Skill Triage Protocol

When receiving any task, immediately classify it across these dimensions before doing anything else.

### Step 1: Task Domain Classification

Identify ALL domains this task touches. Most real tasks span multiple domains.

| Domain | Signal Words | Primary Skill Clusters |
|--------|-------------|----------------------|
| **Frontend Development** | React, UI, component, layout, CSS, Tailwind, responsive | `frontend-design`, `react-best-practices`, `shadcn-ui-official`, `composition-patterns`, `next-best-practices` |
| **UI/UX Design** | design, user experience, usability, accessibility, interaction | `ui-ux-pro-max`, `impeccable-frontend-design`, `top-design`, `ux-audit`, `interaction-design`, `wondelai-refactoring-ui` |
| **Visual Design** | color, typography, branding, logo, visual, aesthetic | `color-palette`, `graphic-design`, `logo-designer`, `brand-analyzer`, `wondelai-web-typography` |
| **Backend Development** | API, server, database, auth, microservices, architecture | `architecture-patterns`, `api-design`, `microservices-patterns`, `fastapi-templates`, `auth-patterns` |
| **Database** | SQL, query, schema, migration, PostgreSQL, MySQL | `database-design-patterns`, `sql-optimization`, `postgresql-skills`, `mysql-skills`, `simota-tuner` |
| **Security** | auth, encryption, vulnerability, OWASP, pentest, hardening | `owasp-security`, `semgrep-code-security`, `tob-*` skills, `secure-coding`, `encryption-*` |
| **Privacy** | GDPR, PII, consent, data protection, compliance | `privacy-*` skills, `gdpr-*` skills, `pii-detection`, `differential-privacy` |
| **Testing** | test, TDD, coverage, E2E, unit, integration, QA | `test-driven-development`, `tyler-*-testing`, `playwright-testing`, `cypress-testing` |
| **Debugging** | bug, error, crash, fix, investigate, root cause | `systematic-debugging`, `interactive-debugger`, `simota-scout`, `simota-specter`, `simota-rewind` |
| **Performance** | slow, optimize, speed, cache, profiling, lighthouse | `simota-bolt`, `tlc-perf-*`, `web-quality-*`, `cloudflare-web-perf` |
| **DevOps/CI** | deploy, pipeline, Docker, Kubernetes, GitHub Actions | `deployment-pipeline-design`, `github-actions`, `vercel-deploy` |
| **Planning** | plan, roadmap, sprint, requirements, scope, estimate | `strategic-planning-engine`, `pm-roadmap-planning`, `pm-prd-development`, `writing-plans` |
| **Reasoning** | think, analyze, decide, evaluate, compare, assess | `meta-thinking-engine`, `thinking-model-router`, `thinking-*` models |
| **Creativity** | brainstorm, innovate, ideate, create, design, explore | `creative-connections-engine`, `lyn-brainstorm-diverge`, `thinking-lateral` |
| **Documentation** | document, README, ADR, spec, API docs | `lyn-adr-architecture`, `openapi-spec`, `code-documenter` |

### Step 2: Task Complexity Assessment

| Complexity | Characteristics | Skill Approach |
|-----------|----------------|----------------|
| **Simple** (1 domain, clear solution) | Single file change, known pattern, quick fix | Route to 1-2 primary skills |
| **Moderate** (2-3 domains, some ambiguity) | Feature implementation, design + code, multi-file | Route to 3-5 skills in sequence |
| **Complex** (4+ domains, significant ambiguity) | Full-stack feature, architecture decision, new system | Route to 5-10 skills, use Skill Composition Protocol |
| **Wicked** (many domains, high uncertainty, novel) | Greenfield project, major refactor, system redesign | Full orchestration with all phases below |

### Step 3: Task Phase Classification

Every task moves through phases. Different skills apply at different phases.

| Phase | Purpose | Key Skills to Activate |
|-------|---------|----------------------|
| **Understand** | Clarify what's being asked, identify constraints | `meta-thinking-engine` (Layer 2: Pre-Reasoning Audit), `pm-problem-statement`, `pm-problem-framing` |
| **Plan** | Design the approach, break down work | `strategic-planning-engine`, `writing-plans`, `thinking-model-router`, `pm-epic-breakdown` |
| **Research** | Gather information, evaluate options | `lyn-environmental-foresight`, `reasoning-tools-kb`, `lyn-bayesian-calibration` |
| **Design** | Make architectural and design decisions | `architecture-patterns`, `frontend-design`, `ui-ux-pro-max`, `lyn-adr-architecture` |
| **Implement** | Write the code | Domain-specific skills (React, backend, database, etc.) |
| **Verify** | Test, review, validate | `verification-before-completion`, `test-driven-development`, `code-review-excellence`, `ux-audit` |
| **Reflect** | Learn from the process | `lyn-reviews-retros`, `meta-thinking-engine` (Layer 5: Self-Correction) |

---

## Phase 2: Skill Selection Rules

### The Priority Stack

When multiple skills could apply, use this priority ordering:

1. **Safety-critical skills first.** If the task involves user data, auth, or security, ALWAYS activate security and privacy skills before implementation skills. Never ship insecure code because you were focused on features.

2. **Design skills before implementation skills.** Think before you code. Activate `architecture-patterns`, `frontend-design`, or `ui-ux-pro-max` before `react-best-practices` or `composition-patterns`.

3. **Thinking skills before domain skills.** When facing ambiguity, activate `meta-thinking-engine` or `thinking-model-router` before jumping into domain-specific work.

4. **Quality skills after implementation skills.** After writing code, activate `code-review-excellence`, `verification-before-completion`, testing skills, and `ux-audit`.

5. **Reflection skills last.** After delivery, activate `lyn-reviews-retros` to capture learnings.

### Conflict Resolution

When two skills give contradictory guidance:

**Rule 1: Specificity wins.** A skill designed for exactly this scenario beats a general-purpose skill. `react-best-practices` beats `frontend-design` on React-specific questions.

**Rule 2: Safety wins ties.** When specificity is equal, the more conservative/secure recommendation wins.

**Rule 3: Evidence wins opinion.** A skill backed by data or research beats one based on convention.

**Rule 4: Escalate to meta-thinking.** When you can't resolve the conflict, activate `meta-thinking-engine` to reason about which skill's guidance is more applicable.

---

## Phase 3: Common Task Patterns

### Pattern: "Build a Full-Stack Feature"

Skill chain: `pm-problem-statement` → `pm-prd-development` → `architecture-patterns` → `frontend-design` + `ui-ux-pro-max` → `react-best-practices` + `shadcn-ui-official` → `api-design` + `database-design-patterns` → `owasp-security` → `test-driven-development` → `verification-before-completion`

### Pattern: "Fix a Bug"

Skill chain: `systematic-debugging` → `simota-scout` (root cause) → `simota-specter` (if concurrency) OR `simota-rewind` (if regression) → domain-specific implementation skill → `test-driven-development` (write regression test) → `verification-before-completion`

### Pattern: "Design a UI"

Skill chain: `pm-problem-statement` → `ui-ux-pro-max` → `impeccable-frontend-design` → `color-palette` → `wondelai-web-typography` → `responsive-design` → `interaction-design` → `frontend-design` → `react-best-practices` + `shadcn-ui-official` → `accessibility-testing` → `ux-audit`

### Pattern: "Make a Strategic Decision"

Skill chain: `meta-thinking-engine` → `thinking-model-router` → selected thinking model(s) → `lyn-bayesian-calibration` → `thinking-red-team` → `thinking-pre-mortem` → `lyn-reviews-retros`

### Pattern: "Plan a Project"

Skill chain: `strategic-planning-engine` → `pm-product-strategy` → `pm-roadmap-planning` → `pm-epic-breakdown` → `pm-user-story-mapping` → `lyn-project-risk-register` → `thinking-pre-mortem` → `lyn-stakeholders-org`

### Pattern: "Optimize Performance"

Skill chain: `simota-bolt` → `tlc-perf-lighthouse` → `web-quality-performance` → `cloudflare-web-perf` → `simota-tuner` (if DB) → `sql-optimization` (if DB) → domain-specific implementation → `verification-before-completion`

### Pattern: "Security Review"

Skill chain: `owasp-security` → `semgrep-code-security` → `tob-codeql-analysis` → `secure-coding` → `auth-patterns` → `encryption-*` (as needed) → `stride-threat-model` → `continuous-security-validation`

### Pattern: "Creative Brainstorm"

Skill chain: `creative-connections-engine` → `lyn-brainstorm-diverge` → `thinking-lateral` → `thinking-first-principles` → `thinking-scamper` → `lyn-synthesis-analogy` → `pm-opportunity-tree`

---

## Phase 4: Dynamic Re-Routing

Tasks evolve. What starts as "build a feature" may reveal a "fix a bug" or "redesign the architecture." Monitor for these re-routing signals:

| Signal | Re-Route To |
|--------|------------|
| "This is more complex than I thought" | Activate `strategic-planning-engine`, break down further |
| "I'm not sure what the user wants" | Activate `pm-problem-statement`, `pm-discovery-process` |
| "The existing code is a mess" | Activate `jeffallan-spec-miner`, `jeffallan-legacy-modernizer` |
| "I'm stuck" | Activate `meta-thinking-engine` (Layer 6: Meta Mode), `thinking-model-router` |
| "This has security implications" | Immediately activate `owasp-security`, `semgrep-code-security` |
| "The design doesn't feel right" | Activate `ux-audit`, `lyn-design-evaluation`, `ui-ux-pro-max` |
| "Performance is bad" | Activate `simota-bolt`, `tlc-perf-lighthouse` |
| "I keep going in circles" | Activate `meta-thinking-engine` (Self-Correction Protocol), `block-rp-why` |

---

## Phase 5: Skill Stacking Rules

Some skills are force-multipliers when combined. These combinations are greater than the sum of their parts.

| Combination | Synergy |
|------------|---------|
| `meta-thinking-engine` + `thinking-model-router` | Metacognition selects the right thinking mode, router selects the right model within that mode |
| `frontend-design` + `ui-ux-pro-max` + `color-palette` | Design principles + 99 UX rules + scientifically-generated color palettes |
| `owasp-security` + `semgrep-code-security` + `tob-codeql-analysis` | Three layers of security analysis: guidelines + automated scanning + deep static analysis |
| `strategic-planning-engine` + `pm-roadmap-planning` + `lyn-project-risk-register` | Strategy + execution plan + risk management |
| `creative-connections-engine` + `thinking-lateral` + `lyn-synthesis-analogy` | Bisociation + lateral thinking + cross-domain analogy = maximum creative output |
| `systematic-debugging` + `simota-scout` + `interactive-debugger` | Methodology + root cause analysis + live debugging tools |
| `test-driven-development` + `code-review-excellence` + `verification-before-completion` | Write tests first + review quality + final verification = zero-defect delivery |

---

## Anti-Patterns

**Skill Overload:** Don't activate 20 skills for a simple task. Match skill count to complexity.

**Skill Tunnel Vision:** Don't only use skills from one domain. A "frontend task" might need security, accessibility, and performance skills too.

**Skill Cargo Culting:** Don't follow a skill's guidance blindly when it doesn't fit the context. Use `meta-thinking-engine` to evaluate applicability.

**Skill Skipping:** Don't skip the verification and reflection phases because you're in a hurry. They're where the most value is captured.