Proprietary Software of 10x.in — Designed, developed, and maintained by the 10x Team. This plugin is the intellectual property of 10x.in. All rights reserved.

What is 10x-Code?

10x-Code is a production-grade context engineering middleware built by the 10x Team that sits between your queries and Claude Code. It ensures every interaction has precisely the right context — no wasted tokens exploring irrelevant files, no losing track of what changed.

Before 10x-Code: Claude Code explores your codebase from scratch on every query, reading files it doesn't need, losing context when the window fills up.

With 10x-Code: Your codebase is indexed once, only relevant files are read per query, and everything is tracked in local MD files that persist across sessions.

Key Highlights

• 23 slash commands across 6 categories — context, workflow, testing, research, git, operations
• 6 specialist agents — context builder, test runner, code auditor, git tracker, knowledge guide, team lead
• Dependency-aware indexing — files ranked by import centrality, not just name matching
• Zero-token context injection — Glob + Grep lookups cost no API tokens
• Session persistence — commit-style task logging in local MD files
• Hook system — automated lifecycle hooks for session management and path protection
• MCP server integration — remote tools endpoint at 10x.in/api/mcp
• Cross-model optimized — Haiku for scanning, Sonnet for coding, Opus for reasoning

Installation

npx (recommended)

npx 10x-code init

bun

bunx 10x-code init

Global install

npm install -g 10x-code
ccs init

Manual

git clone https://github.com/10x-Anit/10x-Code-Context.git
# Copy each skill as its own directory (Claude Code requires one level deep)
for d in 10x-Code-Context/skills/*/; do
  name=$(basename "$d")
  cp -r "$d" ".claude/skills/ccs-$name/"
done
# Copy shared resources
cp -r 10x-Code-Context/{agents,templates,references} .claude/skills/_ccs/
# Copy MCP config
cp 10x-Code-Context/.mcp.json .mcp.json

Important: Skills must be at .claude/skills/<name>/SKILL.md (one level deep). Do NOT nest deeper — Claude Code won't discover them.

Slash Commands

Context Management

| Command | Description | |---------|-------------| | /ccs-init | Deep-research the codebase, generate project-map, architecture, file-index, conventions | | /ccs-status | Show what's indexed, staleness, file counts, token savings estimate | | /ccs-refresh | Rebuild index (full, incremental, or session-based) | | /ccs-query [question] | Preview which files would be selected for a given query |

Workflow

| Command | Description | |---------|-------------| | /ccs-plan [task] | Plan a task with full dependency-aware context | | /ccs-build [task] | Create/implement with tracked context and commit-style logging | | /ccs-refactor [scope] | Scope a refactor — identify all affected files and dependencies | | /ccs-fix [issue] | Fix bugs with dependency tracking, root-cause analysis, and verification | | /ccs-team [task] | Spawn an agent team for complex multi-part tasks |

Testing & Quality

| Command | Description | |---------|-------------| | /ccs-test [scope] | Run tests, track results locally, suggest and auto-fix failures | | /ccs-audit [scope] | Audit code for security, performance, patterns, accessibility, dead code | | /ccs-review [scope] | Code review with full context — style, logic, security, performance |

Research & Docs

| Command | Description | |---------|-------------| | /ccs-research [query] | Search official docs, resolve errors, check deps, find best practices |

Setup

| Command | Description | |---------|-------------| | /ccs-connect | Set up MCP server — creates/updates .mcp.json, verifies connection |

Git Workflow

| Command | Description | |---------|-------------| | /ccs-branch | Create/switch branches with auto-generated context reference files | | /ccs-pr | Prepare PR with full context — title, summary, blast radius, review areas | | /ccs-merge | Merge with dependency checking — conflict prediction, resolution context | | /ccs-diff | Smart diff with impact analysis — dependency chains, blast radius | | /ccs-sync | Pull/rebase/push with conflict context and resolution recommendations | | /ccs-stash | Stash with tracked context — remembers what you were working on | | /ccs-log | Smart commit history — groups by branch, cross-references with task.md |

Operations

| Command | Description | |---------|-------------| | /ccs-deploy | Pre-deployment checklist — tests, build, env vars, deps, breaking changes | | /ccs-track | View/manage session task log, see all changes made this session |

How It Works

1. Initialization (/ccs-init)

Scans your entire codebase and generates local reference files in .ccs/:

• project-map.md — File tree + dependency graph (imports/exports/references)
• architecture.md — Tech stack, patterns, entry points, data flow
• file-index.md — Files ranked by importance (most-imported = highest rank)
• conventions.md — Coding style, naming patterns, test patterns

2. Per-Query Context (automatic)

When you ask Claude Code anything, the skill:

1. Looks up the pre-built index for matching files/symbols
2. Runs targeted Glob + Grep (zero API cost) to find candidates
3. Follows import/dependency chains of matched files
4. Claude Code reads ONLY the files that matter

3. Session Tracking

Every action is logged in .ccs/task.md with git-commit-style entries:

• Task description, files read/modified/created/deleted
• Dependencies identified, status, diff summary
• Persists context without consuming API tokens

Agents

| Agent | Role | |-------|------| | Context Builder | Deep codebase analysis, generates .ccs/ index files | | Test Runner | Runs tests, tracks results, auto-fixes failures | | Code Auditor | Security, performance, dead code, accessibility audits | | Git Tracker | Git workflow — branches, PRs, merges, diffs, sync | | Knowledge Guide | Proactive methodology guidance, note quality, connection suggestions | | Team Lead | Multi-agent team coordination, task decomposition, parallel dispatch |

Model Strategy

| Model | Used For | Commands | |-------|----------|----------| | Haiku 4.5 | Lightweight lookups, scanning, status checks | status, refresh, query, track, stash, log | | Sonnet 4.6 | Standard coding execution | build, fix, test, branch, sync | | Opus 4.6 | Deep reasoning, architecture, complex analysis | init, plan, refactor, audit, review, research, deploy, pr, merge, diff, team |

MCP Server Connection

The plugin ships with a .mcp.json that configures the CCS remote MCP server automatically:

{
  "mcpServers": {
    "ccs": {
      "type": "http",
      "url": "https://10x.in/api/mcp"
    }
  }
}

This provides 6 MCP tools: skill info, all 23 command docs, OS-specific install commands, model strategy, and context file details. Run /ccs-connect to configure or verify.

Hooks System

Automated lifecycle hooks for session management. All hooks are Node.js — fully cross-platform (Windows, Mac, Linux), zero bash dependency.

| Hook | Trigger | What It Does | |------|---------|-------------| | path-guard.js | PreToolUse | Blocks writes to immutable paths, warns on guarded paths | | session-orient.js | SessionStart | Injects workspace tree, goals, conditions, maintenance signals | | session-summary.js | SessionStart | Injects compact project summary for prompt cache hits | | context-inject.js | UserPromptSubmit | Injects relevant context on every query via CCS engine | | index-update.js | PostToolUse | Incrementally updates index after file writes/edits | | write-validate.js | PostToolUse | Validates YAML frontmatter on note files | | auto-commit.js | PostToolUse | Auto-commits changes to git after writes | | session-capture.js | Stop | Saves session state, commits artifacts |

Hooks are automatically registered in ~/.claude/settings.json during installation with absolute node paths — no PATH dependency.

Generated Files

All context files are stored in .ccs/ (add to .gitignore):

.ccs/
├── project-map.md      # File structure + dependency graph
├── architecture.md     # Tech stack, patterns, data flow
├── file-index.md       # Files ranked by importance
├── conventions.md      # Coding style and patterns
├── task.md             # Session task log (commit-style)
├── preferences.json    # User preferences (refresh mode, etc.)
├── branches/<name>.md  # Per-branch reference files
├── pulls/<name>.md     # PR documentation
├── merge-history.md    # Append-only merge log
├── commit-log.md       # Summarized commit history
└── team-board.md       # Multi-agent team task board

Project Structure

10x-Code/
├── skills/             # 23 slash command definitions
├── agents/             # 6 specialist subagent definitions
├── references/         # Strategy docs, quality standards, feature docs
├── templates/          # MD templates for generated files
├── hooks/              # Claude Code lifecycle hooks
├── src/                # TypeScript source
├── dist/               # Compiled output
├── bin/                # CLI entry points
├── statusline/         # Statusline integration
├── manifest.json       # Machine-readable skill/agent definitions
├── SKILLS-TREE.md      # Master skill index
├── AGENTS-INDEX.md     # Agent lookup reference
├── CLAUDE.md           # Plugin orchestrator
├── package.json        # v2.0.2
└── LICENSE             # Proprietary

Requirements

• Node.js 16+
• Claude Code (or compatible AI coding assistant)
• Python 3.8+ (optional, for some analysis features)

License

Proprietary Software — Copyright (c) 2025-2026 10x.in. All rights reserved.

This software is the exclusive intellectual property of 10x.in. No part of this software may be reproduced, distributed, modified, or transmitted without prior written permission from 10x.in.

See LICENSE for full terms. For licensing inquiries, contact the 10x Team at 10x.in.