Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/affaan-m/ECC/llms.txt

Use this file to discover all available pages before exploring further.

Every time an AI agent re-explores a codebase it already knows, re-discovers a debugging technique it has already used, or reconstructs the same step-by-step workflow from scratch, you are spending tokens on things that should already be known. Skills are ECC’s answer to that problem: self-contained knowledge modules that Claude Code loads on demand, giving the agent domain expertise, workflow definitions, and reusable patterns without burning context on rediscovery.

​
What a Skill Is

A skill is a directory (or single Markdown file) placed under ~/.claude/skills/ that encodes a focused, reusable unit of knowledge. When a task matches the skill’s domain — whether detected automatically from context or triggered explicitly — Claude Code loads the skill and executes against its patterns. Skills provide:
  • Domain expertise — framework idioms, language best practices, architecture patterns
  • Workflow definitions — step-by-step processes for common tasks (TDD, code review, deployment)
  • Reference material — checklists, decision trees, copy-pasteable code snippets
  • Codemaps — lightweight structural maps of a codebase that let the agent navigate quickly without reading every file
Skills are passive knowledge. They activate when relevant context is detected or when a command references them — they do not execute autonomously. For autonomous task execution, see Agents.

​
Skills vs. Commands

ECC ships both skills and commands. They are related but distinct:
SkillCommand
Lives in~/.claude/skills/~/.claude/commands/
ActivationContext-based (automatic) or referenced by a command/agentUser-invoked (/command-name)
PurposeDurable knowledge repositoryQuick-entry workflow shim
FormatDirectory with SKILL.md, or a single .md fileSingle .md file
LongevityThe canonical, versioned unitConvenience layer — logic lives in skills
The commands/ layer is best thought of as legacy slash-entry compatibility. The durable logic should live in skills; commands invoke skills as needed.

​
Skill Anatomy

A multi-file skill is a directory containing at minimum a SKILL.md entry point. Supporting files — examples, references, codemaps — live alongside it: 
~/.claude/skills/
└── tdd-workflow/
    ├── SKILL.md           # Required: main skill definition
    ├── examples/
    │   ├── basic.ts       # Copy-pasteable examples
    │   └── advanced.ts
    └── references/
        └── links.md       # External reference material
A minimal skill can also be a single .md file: 
~/.claude/skills/
├── pmx-guidelines.md      # Project-specific patterns
├── coding-standards.md    # Language best practices
├── tdd-workflow/          # Multi-file skill with SKILL.md
└── security-review/       # Checklist-based skill

​
SKILL.md Format

Every SKILL.md begins with YAML frontmatter followed by structured sections: 
---
name: react-patterns
description: React component patterns, hooks, state management, and performance best practices.
origin: ECC
tags: [react, frontend, javascript, typescript]
version: 1.0.0
---

# React Patterns

Brief overview of what this skill covers.

## When to Activate

- Creating new React components
- Refactoring existing components
- Debugging React state issues
- Reviewing React code for best practices

## Core Concepts

Main patterns and guidelines, with code examples.

## Anti-Patterns

Concrete examples of what NOT to do.

## Best Practices

- Actionable, specific guidelines
- Do's and don'ts

## Related Skills

- `react-testing`
- `react-performance`

​
YAML Frontmatter Fields

FieldRequiredDescription
nameYesLowercase, hyphenated identifier (e.g., react-patterns)
descriptionYesOne-line description used for skill list and auto-activation matching
originNoSource identifier (ECC, community, or project name)
tagsNoArray of tags for categorization
versionNoVersion string for tracking updates and rollbacks

​
How to Invoke a Skill

1

Automatic (context-based)

Claude Code detects that the active task matches the skill’s domain — for example, editing a .rs file triggers the rust-patterns skill automatically.
2

From a slash command

Commands reference skills internally. Running /tdd loads the tdd-workflow skill and executes its defined steps. Running /code-review loads the security-review and coding-standards skills as part of its process.
3

From an agent

Sub-agents reference skills when delegated tasks. A tdd-guide agent loading a project will pull the relevant testing skill for its target language.
4

By name in a harness prompt

You can reference a skill by name in your prompt: “Use the api-design skill to review these endpoints.”

​
Where Skills Live After Install

# Install ECC (installs skills, hooks, commands, agents)
npx ecc install --target claude

# Skills are written to:
~/.claude/skills/

# Verify:
ls ~/.claude/skills/

​
The 277-Skill Library

ECC ships 277 built-in skill directories spanning every major development domain:
python-patterns, rust-patterns, typescript-standards, cpp-coding-standards, react-patterns, react-performance, react-testing, react-native-patterns, vue-patterns, angular-developer, nextjs-turbopack, nuxt4-patterns, django-patterns, django-tdd, django-security, springboot-patterns, springboot-tdd, fastapi-patterns, quarkus-patterns, swiftui-patterns, dart-flutter-patterns, compose-multiplatform-patterns, go-patterns (via build skills), perl-patterns, vite-patterns, bun-runtime, and more.
security-review, security-scan, security-bounty-hunter, django-security, springboot-security, quarkus-security, defi-amm-security, perl-security, safety-guard, production-audit.
agentic-engineering, agentic-os, agent-architecture-audit, agent-eval, agent-harness-construction, agent-introspection-debugging, agent-self-evaluation, autonomous-agent-harness, autonomous-loops, continuous-agent-loop, team-agent-orchestration, plan-orchestrate, parallel-execution-optimizer, claude-devfleet.
pytorch-patterns, mle-reviewer (via agents), recsys-pipeline-architect, cost-aware-llm-pipeline, ai-regression-testing, ai-first-engineering, benchmark, benchmark-methodology, benchmark-optimization-loop.
docker-patterns, deployment-patterns, postgres-patterns, redis-patterns, database-migrations, prisma-patterns, clickhouse-io, cisco-ios-patterns, network-config-validation, network-interface-health, canary-watch, production-audit, terminal-ops.
article-writing, brand-discovery, brand-voice, content-engine, seo, competitive-platform-analysis, competitive-report-structure, crosspost, social-publisher.
tdd-workflow, python-testing, rust-testing, cpp-testing, csharp-testing, react-testing, verification-loop, delivery-gate, quality-nonconformance, ai-regression-testing, browser-qa, windows-desktop-e2e.
strategic-compact, context-budget, continuous-learning, continuous-learning-v2, token-budget-advisor, cost-tracking, configure-ecc.

​
Creating a Custom Skill

1

Choose a focused domain

Good skills are narrow and actionable. Prefer react-hook-patterns over react, postgresql-indexing over databases. One skill = one domain or concept.
2

Create the directory

mkdir -p ~/.claude/skills/my-skill-name
3

Write SKILL.md

Start with YAML frontmatter (name, description), then add a When to Activate section (this drives auto-activation), followed by Core Concepts, Code Examples, Anti-Patterns, and Related Skills.
4

Add examples and references (optional)

Place copy-pasteable code files in examples/ and reference links in references/. Keep examples tested and language-tagged.
5

Validate and test

# Check frontmatter is valid
head -10 ~/.claude/skills/my-skill-name/SKILL.md

# Test in a session
# Ask Claude to handle a task in the skill's domain
# Verify it references your patterns
For a complete walkthrough of skill content guidelines, anti-pattern sections, checklists, decision trees, and contribution instructions, see the Skill Development Guide.

Build docs developers (and LLMs) love

Get started for freeTalk to us