Core Concepts

ECC is built on six core building blocks. Understanding how they differ and interact is key to getting the most out of the system.

Agents

Specialized AI sub-processes that handle specific tasks autonomously. Each agent has a defined role, toolset, and model tier.

# agents/architect.md frontmatter
name: architect
description: Software architecture specialist
tools: ["Read", "Grep", "Glob"]
model: opus

Model tiers:

Opus - Complex analysis: code review, architecture, security
Sonnet - Implementation: build fixing, TDD, refactoring
Haiku - Lookup: documentation search, simple queries

Agents are invoked by commands or directly by Claude Code when delegation is appropriate.

Skills

Workflow definitions and domain knowledge that guide how Claude approaches specific tasks. Skills are like expert playbooks.

skills/
  python-patterns/SKILL.md     # Python idioms and best practices
  tdd-workflow/SKILL.md        # Test-driven development process
  security-review/SKILL.md     # Security checklist and patterns

Skills activate automatically based on context (e.g., python-patterns activates when writing Python) or are triggered by commands.

Commands

Slash commands that invoke specific workflows. They’re the user-facing entry point to agents and skills.

/tdd          # Start test-driven development workflow
/code-review  # Run code quality review
/build-fix    # Fix build and type errors
/e2e          # Generate and run end-to-end tests
/plan         # Create implementation plan

Rules

Always-follow guidelines organized by language. Rules are installed to ~/.claude/rules/ and are always active.

rules/
  common/           # Universal standards (9 files)
    coding-style.md
    security.md
    testing.md
  typescript/       # Language-specific (5 files each)
  python/
  golang/
  ...11 languages total

Hooks

Event-driven automations that fire on specific tool calls or lifecycle events. Unlike skills, hooks execute shell commands.

Hook Type	When It Fires
`PreToolUse`	Before a tool executes
`PostToolUse`	After a tool finishes
`UserPromptSubmit`	When you send a message
`Stop`	When Claude finishes responding
`PreCompact`	Before context compaction

Example: A PreToolUse hook that warns before git push, or a PostToolUse hook that runs Prettier after file edits.

MCP Servers

Model Context Protocol integrations that connect Claude to external services. ECC ships with 24 MCP configurations.

Examples: GitHub operations, Supabase database, Playwright browser automation, Vercel deployments, web search.

How They Work Together

User runs /tdd
  -> Command invokes tdd-guide agent (Sonnet model)
  -> Agent follows tdd-workflow skill
  -> Rules enforce coding standards
  -> Hooks run tests after file edits
  -> MCP servers provide external context