Decision Framework

The Three Types

ECC tools come in three types. Understanding the difference is key to using them effectively.

Aspect	Command	Skill	Agent
Trigger	You type /name explicitly	Auto-activates based on context	Delegated by commands or Claude
Scope	Single workflow execution	Always-on domain knowledge	Autonomous sub-task
Persistence	One-shot - runs and finishes	Active across entire session	Duration of delegated task
Model	Uses your session’s model	N/A - just knowledge	Has its own model tier
User action	Explicit invocation	Passive - just works	Invisible delegation

Decision Tree

”I want to do something specific right now”

Use a Command. Commands are explicit actions you trigger. They start a workflow, invoke an agent, and produce a result.

Examples: /tdd, /code-review, /build-fix, /plan, /eval

”I want Claude to always know about X while I work”

Use a Skill. Skills are domain knowledge that stays active. They don’t produce output directly - they guide how Claude approaches your code.

Examples: python-patterns, coding-standards, tdd-workflow, eval-harness

”I need a specialist to handle this sub-task”

That’s an Agent. Agents are specialized sub-processes. You rarely invoke them directly - commands delegate to them. But understanding which agent powers a command helps you pick the right one.

Examples: planner (powers /plan), code-reviewer (powers /code-review), tdd-guide (powers /tdd)

How They Connect

You type: /tdd
  ↓ Command invokes agent
Agent: tdd-guide (Sonnet model)
  ↓ Agent uses knowledge from skill
Skill: tdd-workflow (RED-GREEN-REFACTOR process)
  ↓ Language skill provides patterns
Skill: python-patterns or coding-standards

Tip

Think of it as: Commands are verbs (do this), Skills are knowledge (know this), Agents are specialists (delegate to this).

Quick Reference: Trigger Questions

Your question	Tool type	Example
”Plan this feature”	Command	/plan
”Write tests first”	Command	/tdd
”Review my code”	Command	/code-review
”Fix the build”	Command	/build-fix
”Run evaluations”	Command	/eval
”What’s the Pythonic way?”	Skill	python-patterns
”What’s the TDD process?”	Skill	tdd-workflow
”How do I set up evals?”	Skill	eval-harness
”Design the architecture”	Agent	architect (via /plan)
“Review Python specifically”	Agent	python-reviewer (via /code-review or direct)

Cost Implications

Agents use different model tiers, which affects cost and quality:

Tier	Used for	Examples
Opus	Complex analysis, architecture, security	architect, planner, code-reviewer
Sonnet	Implementation, build fixing, TDD	tdd-guide, build-error-resolver
Haiku	Simple lookups, documentation	docs-lookup

Skills have zero additional cost - they’re just knowledge loaded into the session. Commands use whatever agent they invoke (inheriting that agent’s model cost).