Atomic Skills for Claude Code

Context-efficient development knowledge via progressive skill discovery

New? Start Here

Install in 30 seconds:

/plugin marketplace add rand/cc-polymath
/plugin install cc-polymath@cc-polymath

Your first 3 commands:

/skills                    # See what's recommended for your project
/discover-frontend         # Load React, Next.js, TypeScript skills (example)
bash ~/.claude/plugins/cc-polymath/scripts/verify-install.sh  # Verify installation

Learn more:

• 📖 Getting Started Guide - 5-minute quick start
• 💬 Example Conversations - See it in action
• 🆘 Troubleshooting - Common issues & solutions
• ❓ FAQ - Quick answers

---

This repository solves a tradeoff problem: how to give Claude Code access to comprehensive development knowledge without overwhelming its context window on boot. The solution is atomic, composable skills organized through a multi-tier discovery system.

The Problem: Context vs Coverage

Using the default mechanism with many atomic skills yields a dilemma:

• Load everything upfront → 25K+ tokens consumed before any real work begins
• Load nothing → Claude lacks essential patterns and best practices
• Manual loading → Users must know what exists to ask for it

This creates an challenging tradeoff between comprehensive coverage and context efficiency.

The Solution: Atomic Skills + Progressive Discovery

Atomic Skills (447 total)

Each skill is focused, self-contained, and composable:

• Average 320 lines - small enough to load quickly
• Single responsibility - covers one clear topic
• Production-tested - real patterns from building at scale
• Cross-referenced - links to related skills for composition

Why atomic matters: Loading 5 focused skills (1.5K tokens) beats loading one monolithic guide (8K tokens) when you only need specific knowledge. Granularity enables precision.

Three-Tier Architecture

Tier 1: Gateway Skills (31 auto-discovered Agent Skills)
Lightweight entry points that activate automatically based on keywords:

• discover-api → triggers on "REST", "GraphQL", "authentication"
• discover-database → triggers on "PostgreSQL", "MongoDB", "Redis"
• discover-zig → triggers on "Zig", "comptime", "allocators"

Each gateway is ~200 lines with quick reference and loading commands.

Tier 2: Category Indexes (30 detailed references)
Full skill listings with descriptions, use cases, and workflows:

• api/INDEX.md → All 7 API skills with integration patterns
• database/INDEX.md → All 11 database skills with decision trees
• Only loaded when browsing or planning work

Tier 3: Individual Skills (on-demand)
Complete implementation guides loaded only when needed:

• api/rest-api-design.md → Full REST patterns
• database/postgres-query-optimization.md → EXPLAIN plans, indexes

Why This Works

Context efficiency: 60-84% reduction vs monolithic index

• Old approach: Load 25K token index on boot
• New approach: Load 2-5K tokens of relevant gateways as needed
• Result: More context available for actual code and conversation

No boot overhead: Claude Code starts with zero skills loaded

• Gateway skills auto-discover based on your prompt keywords
• Manual loading available when auto-discovery isn't enough
• System scales to hundreds more skills without boot cost

Discoverability: Users don't need to know what exists

• Keywords in prompts trigger relevant gateways automatically
• Gateways show what's available in their domain
• Progressive loading: gateway → index → specific skill

What's Covered

Core Development (125 skills)

Languages & Frameworks:

• Backend: Python (uv), Zig, Rust, Go (31 skills)
• Frontend: React, Next.js, TypeScript, Elegant Design (9 skills)
• Mobile: SwiftUI, Swift concurrency, SwiftData, React Native (10 skills)

Infrastructure & DevOps:

• Build Systems: Make, CMake, Gradle, Maven, Bazel, cross-platform (8 skills)
• Debugging: GDB, LLDB, Python, browser, memory, concurrency, production, distributed systems (14 skills)
• Cloud: AWS (7), GCP (6), Modal.com, Cloudflare Workers, Vercel (13 skills)
• Containers: Docker, Kubernetes, security (5 skills)
• CI/CD: GitHub Actions, pipelines (4 skills)
• Observability: Logging, metrics, tracing, OpenTelemetry, incident response (8 skills)

Data & APIs:

• Databases: Postgres, MongoDB, Redis, Redpanda, Iceberg, DuckDB (11 skills)
• Caching: Multi-layer (browser, HTTP, CDN, Redis), invalidation strategies (7 skills)
• API Design: REST, GraphQL, auth, rate limiting, versioning (7 skills)
• Data Engineering: ETL, streaming, batch processing (5 skills)
• Testing: Unit, integration, e2e, TDD, coverage (6 skills)

Specialized Domains (85 skills)

Machine Learning & AI (33 skills):

• LLM Evaluation: Benchmarks (MMLU, HellaSwag), frameworks (Arize Phoenix, Braintrust), LLM-as-judge (Prometheus, G-Eval), RAGAS metrics
• Model Routing: RouteLLM, model comparison, multi-model orchestration
• Advanced RAG: Hybrid search, reranking (cross-encoder, LLM), GraphRAG, hierarchical retrieval
• DSPy Framework: Signatures, modules, optimizers, RAG, assertions (7 skills)
• HuggingFace: Hub, Transformers, Datasets, Spaces, AutoTrain (5 skills)
• Fine-tuning: Unsloth, LoRA/PEFT, dataset prep (3 skills)

Rust & PyO3 (19 skills):

• DSPy-PyO3 Integration: RAG pipelines, agents, async streaming, production deployment, optimization (7 skills with 36 production examples)
• Performance: GIL management, parallel execution, data science, collections/iterators (6 skills)
• Web: Axum frameworks, streaming responses, IPC, gRPC (2 skills)
• Production: Packaging, testing, debugging, modules/functions/errors (4 skills with 20 examples)

Information Retrieval (5 skills):

• Search fundamentals (TF-IDF, BM25, Elasticsearch)
• Vector search (dense retrieval, embeddings)
• Ranking & reranking (learning to rank, cross-encoders)
• Recommendation systems (collaborative, content-based, hybrid)
• Query understanding (expansion, spell correction, semantic search)

Programming Language Theory (13 skills):

• Lambda calculus, type systems, dependent types
• Curry-Howard correspondence, operational semantics
• Program verification with Hoare logic
• Typed Holes & Live Programming: Hazel/Hazelnut calculus, incremental typing
• AI-Assisted Programming: LLM + typed holes integration (OOPSLA 2024), type-driven code synthesis

Formal Methods (10 skills):

• SAT/SMT Solvers: Z3 basics, SAT strategies, SMT theory (3 skills)
• Lean 4: Proof basics, tactics, mathlib4, theorem proving (4 skills)
• Constraint Satisfaction: CSP modeling, propagation, backtracking (3 skills)

Advanced Mathematics (11 skills):

• Numerical: Linear algebra, optimization, probability/statistics (4 skills)
• Pure Math: Topology (point-set, algebraic), category theory, differential equations, abstract algebra, set theory, number theory (7 skills)

Systems Programming (8 skills):

• WebAssembly: Fundamentals, Rust toolchain, browser integration, server-side (4 skills)
• eBPF: Fundamentals, tracing/observability, networking, security monitoring (4 skills)

Collaboration & Process (14 skills):

• GitHub: Repository management, pull requests, issues/projects, security, Actions (5 skills)
• PRD Writing: Structure, requirements gathering, user stories, technical specs (4 skills)
• RFC Writing: Structure, technical design, consensus building, decision docs (4 skills)

Real-time & Networking (5 skills):

• WebSocket, Server-Sent Events, pub/sub patterns
• Tailscale VPN, mTLS, NAT traversal, Mosh
• Network resilience patterns

Workflow & Meta Skills (7 skills)

• Beads: AI-native task management, context strategies, multi-session workflows (4 skills)
• TUI Development: Bubble Tea (Go), Ratatui (Rust) (5 skills)
• Skill Discovery: Intelligent skill activation for repos and prompts (5 skills)
• Anti-Slop: Detection and cleanup of AI-generated patterns (Agent Skill)
• Elegant Design: World-class accessible interfaces, design systems (Agent Skill)
• Typed Holes Refactor: Systematic TDD-based refactoring (Agent Skill)

Quick Start

Installation

As Claude Code Plugin (Recommended):

/plugin install https://github.com/rand/cc-polymath

That's it! All 447 skills and the /skills command are immediately available.

For local development or testing:

/plugin install /Users/rand/src/cc-polymath

Auto-Discovery (How It Works)

Just start working. Claude Code automatically activates relevant gateway skills based on your task keywords.

Example: Mention "REST API with PostgreSQL" → discover-api and discover-database gateways activate automatically.

Manual Loading

When you need to browse or plan:

# Browse skills catalog
cat skills/README.md

# View a category
cat skills/api/INDEX.md          # All API skills
cat skills/database/INDEX.md     # All database skills

# Load a gateway
cat skills/discover-ml/SKILL.md  # ML gateway with quick reference

# Load specific skills
cat skills/api/rest-api-design.md
cat skills/database/postgres-query-optimization.md

Composing Workflows

Skills are designed to combine for complex workflows:

Full-stack web app:

cat skills/api/rest-api-design.md
cat skills/frontend/nextjs-app-router.md
cat skills/database/postgres-schema-design.md
cat skills/caching/redis-caching-patterns.md
cat skil