Supercharge Claude Code
with Orchestrated Skills & Agents

cc10x is what Claude Code should be.

cc10x-router is the only entry point and AUTO-EXECUTES the workflow based on intent.
Detect intent → Load memory → Clarify requirements → Execute agent chain → Update memory.

Memory persistence ensures context never gets lost. Every session builds on previous work.

LOG FIRST. RED→GREEN→REFACTOR. Exit code 0 or it didn't happen. Confidence ≥ 80% only.

Install cc10x → See Workflows Live Demo
Example output (cc10x v5.7.1)
$ _
Scroll to explore ↓
How It Works

Workflow Execution Engine

Single router • memory persistence • enforced quality gates

🎯

Workflow Selection

Recognizes intent, selects workflow automatically.

"This feels insecure" → REVIEW
"Add password reset" → PLAN → BUILD
"Tests failing" → DEBUG
💡

Skills Loaded by Agents

Skills are loaded BY agents via frontmatter (not invoked directly by users).

✓ Auto-loaded via agent frontmatter (e.g., component-builder loads session-memory, TDD, code-generation, verification)
✓ Conditional skills loaded via Skill tool:
• BUILD: frontend-patterns (if UI component), architecture-patterns (if API endpoint)
• REVIEW: frontend-patterns (if UI code), architecture-patterns (if API code)
• DEBUG: frontend-patterns (if UI bug), architecture-patterns (if integration issue)
• PLAN: frontend-patterns (if UI planning), brainstorming (if ideation needed)
✓ Prevents random skill picking - agents control what skills they use
⚡

Deterministic Agent Chains

Each workflow runs a specific agent chain in order.

BUILD: component-builder → code-reviewer → silent-failure-hunter (if error handling) → integration-verifier
DEBUG: bug-investigator → code-reviewer → integration-verifier
REVIEW: code-reviewer (or silent-failure-hunter for error handling focus)
PLAN: planner
The Result
Before: Guessing at bugs, skipping tests, claims without evidence, context loss
With cc10x: LOG FIRST, TDD enforcement, verification, memory persistence

Disciplined workflows. Evidence-first output.
Memory Persistence

Never Lose Context

Persistent memory across sessions • automatic context loading • seamless continuity

💾

Automatic Memory Loading

Every workflow starts by loading relevant memory files from previous sessions.

✓ Loads activeContext.md - current project state
✓ Loads patterns.md - learned patterns and preferences
✓ Loads progress.md - previous work and decisions
✓ No context loss between sessions
🔄

Continuous Updates

Memory files are automatically updated throughout the workflow execution.

BUILD: Updates progress with new components and tests
DEBUG: Records root causes and solutions
REVIEW: Tracks findings and improvements
PLAN: Saves architecture decisions and roadmaps
✓ Memory persists in .claude/memory/
🧠

Context-Aware Execution

Agents use memory to make informed decisions and avoid repeating past mistakes.

✓ Remembers previous architecture decisions
✓ Recalls coding patterns and preferences
✓ Tracks what's been built and tested
✓ Avoids redundant work
Result: Each session builds on previous work
Memory in Action
Session 1: "Build a user authentication system"
→ Memory saved: auth patterns, test structure, component decisions
Session 2: "Add password reset feature"
→ Memory loaded: existing auth structure, patterns used
→ Memory updated: new reset flow, additional tests
Session 3: "Review the auth code"
→ Memory loaded: complete auth system context
→ Review is informed by full project history
Memory files stored in: .claude/memory/
Persistent across sessions • Version controlled • Human-readable markdown

4 Workflows

Selected automatically based on your intent

🔍
REVIEW

REVIEW

You: "This feels insecure"
cc10x: code-reviewer (confidence ≥ 80%) + optional silent-failure-hunter

📋
PLAN

PLAN

You: "plan the microservices architecture"
cc10x: planner (architecture, risks, roadmap)

🔨
BUILD

BUILD

You: "build a user authentication system"
cc10x: component-builder (TDD) → code-reviewer → silent-failure-hunter (if error handling) → integration-verifier

🐛
DEBUG

DEBUG

You: "fix this error: …"
cc10x: bug-investigator (LOG FIRST) → code-reviewer → integration-verifier

Built-In Excellence

Quality Standards Enforced

LOG FIRST • TDD enforcement • confidence scoring • evidence-first verification

Example (from cc10x README): "review this PR for security issues"
cc10x: Detected REVIEW intent. Executing REVIEW workflow.
Critical Findings (confidence ≥ 80)
[95] SQL injection risk - src/api.ts:42
[85] Missing input validation - src/form.ts:18
Rule: Only report issues with confidence ≥ 80%.
✅ EXPECTED BEHAVIOR

Expected Behavior (cc10x v5.7.1)

Examples from the cc10x README

4
Workflows
6
Agents
11
Skills
💾
Memory Persistence
✓
BUILD (Correct)
Loads memory, then clarifies requirements (CRITICAL: DO NOT SKIP). Waits for answers before invoking component-builder.
✓
DEBUG (Correct)
LOG FIRST: gathers evidence (logs/stack traces) and clarifies expected vs actual behavior before invoking bug-investigator.
✓
REVIEW (Correct)
Invokes code-reviewer and only reports issues with confidence ≥ 80, with file:line citations and specific fixes. Optionally invokes silent-failure-hunter for error handling focus.
✓
PLAN (Correct)
Loads memory, then invokes planner to create comprehensive architecture, identify risks, and generate implementation roadmap. Saves plan to .claude/docs/plans/.
📝
BUILD (Wrong)
Writes code without asking questions, skips tests, and claims “it should work” without verification.
💻
DEBUG (Wrong)
Guesses at the cause, changes code without checking logs, and declares success without evidence.
🐛
REVIEW (Wrong)
Vague feedback (no file:line citations, no confidence levels).
📋
PLAN (Wrong)
Creates vague outline without architecture details, risks, or implementation steps. Doesn't save plan.
Built-In Excellence

Default Behaviors Enforced

Directly aligned to cc10x v5.7.1 agents and skills

🐛

LOG FIRST (DEBUG)

  • Evidence before fixes - gather logs and reproduce before changing code
  • Root cause analysis - fix the cause, not the symptom
  • Regression test - every bug fix gets a test
🧪

TDD Enforcement (BUILD)

  • RED → GREEN → REFACTOR - no production code before a failing test
  • Minimal implementation - make the test pass without scope creep
  • Refactor safely - tests must stay green
✅

Verification (Exit Codes)

  • Exit code 0 - “or it didn’t happen”
  • Tests and commands - must be run and reported with evidence
  • No assumptions - verify everything before marking done
🎯

Confidence Scoring (REVIEW)

  • Only report ≥ 80% - avoids noise and false positives
  • File:line citations - every finding is evidence-based
  • Actionable fixes - recommendations are specific
Also built-in: memory persistence (loads context automatically, updates throughout workflows), a single router entry point, user confirmation gates, and silent failure hunting for error handling.

Get cc10x

Memory persistence. TDD enforcement. Evidence-first verification.

Step 1: Add marketplace
/plugin marketplace add romiluz13/cc10x
Step 2: Install plugin
/plugin install cc10x@romiluz13
Step 3: Restart Claude Code
Required to activate the plugin
What cc10x adds to Claude Code:

✓ Single router entry point
✓ 4 auto-executing workflows
✓ 6 specialized agents
✓ 11 skills (loaded when needed)
✓ Memory persistence (context never lost)
✓ Automatic memory loading & updates
⭐ GitHub Repo 📚 Claude Code Docs ⚡ Get Claude Code

Claude Code plugin. You direct. cc10x guides. Work flows.