frontend-patterns

Most Claude Code plugins are bloated and over-engineered:

```

❌ 50+ skills you'll never use

❌ 30+ agents with overlapping responsibilities

❌ No guidance on WHEN to use WHAT

❌ You end up using nothing because it's overwhelming

```

cc10x is different. One intelligent router detects your intent and automatically orchestrates the right agents with the right skills. You just work.

---

```

┌──────────────────────────────────────────────────────────────────────────────┐

│ │

│ YOU: "build a user auth system" │

│ ┌────────────────────────────────────┐ │

│ ┌─────►│ component-builder │ │

│ │ │ + TDD enforcement │ │

│ ┌────────────────────┐ │ │ + code-generation skill │ │

│ │ │ │ └──────────────┬─────────────────────┘ │

│ │ cc10x-router │─────┤ │ │

│ │ (auto-detects │ │ ┌──────────────▼─────────────────────┐ │

│ │ BUILD intent) │ │ │ code-reviewer ∥ silent-failure │ │

│ │ │ │ │ (parallel execution) │ │

│ └────────────────────┘ │ └──────────────┬─────────────────────┘ │

│ │ │ │

│ │ ┌──────────────▼─────────────────────┐ │

│ └─────►│ integration-verifier │ │

│ │ + E2E validation │ │

│ └────────────────────────────────────┘ │

│ │

└──────────────────────────────────────────────────────────────────────────────┘

```

You say what you want. cc10x figures out the rest.

---

Step 1: Install Plugin

```bash

# Add marketplace

/plugin marketplace add romiluz13/cc10x

# Install plugin

/plugin install cc10x@romiluz13

```

Step 2: Setup Config Files

Copy this README, paste it into Claude Code, and say: "Set up cc10x for me"

Step 3: Restart Claude Code

Done!

---

When user says "set up cc10x", "install cc10x", or similar:

Step 1: Check Existing Files

• Read ~/.claude/CLAUDE.md (may not exist)
• Read ~/.claude/settings.json (may not exist)

Step 2: Update `~/.claude/CLAUDE.md`

If file doesn't exist: CREATE with the template below.

If file exists: PREPEND the cc10x section below, keep user's existing content.

```markdown

# CC10x Orchestration (Always On)

IMPORTANT: ALWAYS invoke cc10x-router on ANY development task. First action, no exceptions.

IMPORTANT: Explore project first, then invoke the router.

IMPORTANT: Prefer retrieval-led reasoning over pre-training-led reasoning for orchestration decisions.

IMPORTANT: Never bypass the router. It is the system.

IMPORTANT: NEVER use Edit, Write, or Bash (for code changes) without first invoking cc10x-router.

Skip CC10x ONLY when:

• User EXPLICITLY says "don't use cc10x", "without cc10x", or "skip cc10x"
• No interpretation. No guessing. Only these exact opt-out phrases.

[CC10x]|entry: cc10x:cc10x-router

---

Skills are additive, not exclusive. CC10x provides orchestration. Domain skills provide expertise. Both work together.

GATE: Before writing code, check if task matches a skill below. If match, invoke it via Skill(skill="...").

| When task involves... | Invoke |

|-----------------------|--------|

| (Add user's installed skills here) | |

```

Step 3: Update `~/.claude/settings.json`

If file doesn't exist: CREATE with the template below.

If file exists: MERGE these permissions into the existing permissions.allow array (don't overwrite!):

```json

"Bash(mkdir -p .claude/cc10x)",

"Bash(mkdir -p docs/plans)",

"Bash(mkdir -p docs/research)",

"Bash(git status)",

"Bash(git diff:*)",

"Bash(git log:*)",

"Bash(git branch:*)"

```

Step 4: Scan Installed Skills & Add to Table

Where to find installed skills:

1. ~/.claude/settings.json → check enabledPlugins object (plugins with value true)
2. ~/.claude/plugins/installed_plugins.json → detailed plugin info
3. ~/.claude/skills/ → personal skills (all projects)
4. .claude/skills/ → project-specific skills

Skill naming in table:

• Plugin skills: plugin-name:skill-name (e.g., mongodb-agent-skills:mongodb-schema-design)
• Personal/project skills: just the skill name (e.g., react-best-practices)

Example: If user has these:

```

# In enabledPlugins:

"mongodb-agent-skills@mongodb-agent-skills": true

# In ~/.claude/skills/:

react-best-practices/SKILL.md

```

Add to the Complementary Skills table:

```markdown

| When task involves... | Invoke |

|-----------------------|--------|

| MongoDB, schema, queries | mongodb-agent-skills:mongodb-schema-design |

| React, Next.js, UI | react-best-practices |

```

Step 5: Confirm

> "cc10x is set up! Please restart Claude Code to activate."

---

| Intent | Trigger Words | What Happens |

|--------|---------------|--------------|

| BUILD | build, implement, create, make, write, add | TDD cycle → Code review → Silent failure hunt → Integration verify |

| DEBUG | debug, fix, error, bug, broken, troubleshoot | Log-first investigation → Review fix → Verify works |

| REVIEW | review, audit, check, analyze, assess | Multi-dimensional review with 80%+ confidence scoring |

| PLAN | plan, design, architect, roadmap, strategy | Comprehensive planning with external research |

---

---

Build Something

```

"build a user authentication system"

→ Router detects BUILD intent

→ Clarifies requirements FIRST (won't skip this)

→ component-builder with TDD

→ code-reviewer + silent-failure-hunter (parallel)

→ integration-verifier

→ Memory updated

```

Fix a Bug

```

"debug the payment processing error"

→ Router detects DEBUG intent

→ Checks memory for Common Gotchas

→ bug-investigator with LOG FIRST

→ code-reviewer validates fix

→ integration-verifier confirms

→ Added to Common Gotchas

```

Review Code

```

"review this PR for security issues"

→ Router detects REVIEW intent

→ code-reviewer with git context

→ Only reports issues with ≥80% confidence

→ File:line citations for every finding

```

---

```

USER REQUEST

│

▼

┌─────────────────────────────────────────────────────────────────┐

│ cc10x-router (ONLY ENTRY POINT) │

│ Detects intent → Routes to workflow