Everything Claude Code Component Types: 11 Modular Building Blocks Explained

Everything Claude Code organizes its functionality into 11 distinct component types—Agents, Skills, Commands, Rules, Hooks, Scripts, Tests, Contexts, Examples, MCP Configs, and a Plugin Manifest—each serving a specific role in the Claude-Code ecosystem.

Everything Claude Code is a modular framework that extends Claude's capabilities through well-defined, reusable components. Understanding these component types is essential for customizing workflows, extending functionality, and maintaining a clean separation of concerns. This guide breaks down each component type based on the source code structure in the WorldFlowAI/everything-claude-code repository.

Agents: Autonomous Task Workers

Agents are delegated autonomous workers that handle specific tasks in the development lifecycle. They reside in the agents/ directory and operate as specialized sub-agents that Claude can invoke for targeted work.

Key agents include:

• planner.md – Generates structured project plans
• architect.md – Provides design advice and folder layouts
• code-reviewer.md – Performs focused code reviews
• security-reviewer.md – Audits code for security issues

Invoke an agent using the @ syntax:

@architect
Can you suggest a folder layout for a new React feature module?

Claude resolves this request to agents/architect.md and returns a structured architectural plan.

Skills: Reusable Knowledge Modules

Skills are domain-specific workflow definitions that encode best-practice patterns, prompts, and domain logic. Located in the skills/ directory, they function as reusable knowledge modules that agents and commands can draw upon.

Notable skill directories:

• frontend-patterns/ – UI/UX implementation patterns
• backend-patterns/ – Server-side architecture guidance
• tdd-workflow/ – Test-driven development procedures
• continuous-learning/ – Knowledge accumulation strategies

Each skill follows a consistent structure with a SKILL.md entry point, such as skills/frontend-patterns/SKILL.md.

Commands: User Entry Points

Commands provide shorthand entry points that users invoke directly from Claude's chat interface. These slash commands trigger predefined workflows without requiring full natural language prompts.

Common commands in commands/:

Command	File	Purpose
/tdd	commands/tdd.md	Launches test-driven development workflow
/plan	commands/plan.md	Generates project plans via the planner agent
/e2e	commands/e2e.md	Executes end-to-end testing procedures
/code-review	commands/code-review.md	Initiates automated code review

Commands bridge user intent to underlying agent and skill execution.

Rules: Enforced System Guidelines

Rules are policy files that the system applies automatically to maintain code quality and consistency. Stored in rules/, these are non-negotiable guidelines that shape all generated output.

Core rule files:

• rules/security.md – Security requirements and prohibited patterns
• rules/coding-style.md – Style consistency enforcement
• rules/testing.md – Test coverage expectations
• rules/git-workflow.md – Version control procedures

Rules function as guardrails that prevent agents from producing non-compliant output.

Hooks: Lifecycle Automations

Hooks are trigger-based automations that execute at specific lifecycle events. The hooks/ directory contains event-driven scripts that persist context or suggest optimizations.

Hook structure:

• hooks/hooks.json – Configuration mapping events to handlers
• hooks/memory-persistence/ – Context preservation across sessions
  • session-start.sh – Loads previous session context
  • session-end.sh – Saves current session state
• hooks/strategic-compact/ – Optimization suggestions triggered pre-compact

Hooks enable stateful, long-running workflows that maintain continuity across Claude sessions.

Scripts: Cross-Platform Utilities

Scripts are supporting Node.js utilities that power commands and hooks. Located in scripts/, these handle platform-specific operations and shared functionality.

Key scripts:

• scripts/setup-package-manager.js – Auto-detects and configures npm/yarn/pnpm
• scripts/lib/utils.js – Common helper functions

These scripts abstract away environment differences, ensuring consistent behavior across operating systems.

Tests: Automated Validation

Tests ensure that agents, skills, and hooks behave as expected. The tests/ directory contains both unit and integration test suites.

Test structure:

• tests/run-all.js – Orchestrates complete test execution
• tests/lib/ – Shared testing utilities
• tests/hooks/ – Hook-specific validation tests

The testing framework validates component contracts and catches regressions when modifying core functionality.

Contexts: Behavioral Mode Shapers

Contexts are system-prompt injection files that pre-load prompt fragments to shape Claude's behavior for different operational modes. Found in contexts/, these define persona and scope constraints.

Available contexts:

• contexts/dev.md – Development mode with implementation focus
• contexts/review.md – Review mode emphasizing critique and quality
• contexts/research.md – Research mode prioritizing exploration and learning

Contexts switch Claude's operational mode without requiring repetitive prompt engineering.

Examples: Real-World Reference Implementations

Examples provide sample configuration files and session dumps that demonstrate proper plugin usage. The examples/ directory serves as living documentation.

Key examples:

• examples/CLAUDE.md – Sample Claude configuration
• examples/user-CLAUDE.md – User-specific customization patterns

These files illustrate how to configure and run the plugin in production scenarios.

MCP Configs: External Service Integration

MCP Configs (Multi-Cloud-Provider configurations) define connections to external services. The mcp-configs/ directory contains provider-specific settings.

Primary configuration:

• mcp-configs/mcp-servers.json – Settings for GitHub, Supabase, Vercel, Railway, and other services

These configs enable Claude to interact with third-party APIs and deployment platforms.

Plugin Manifest: System Registration

The Plugin Manifest at .claude-plugin/plugin.json is the metadata file that tells Claude where each component lives and how to load the plugin. This manifest binds all other component types together into a cohesive system.

How Component Types Interact

Everything Claude Code's architecture follows a clear dependency flow:

1. Users invoke Commands
2. Commands delegate to Agents
3. Agents apply Skills and respect Rules
4. Hooks trigger at lifecycle events, executing Scripts
5. Contexts shape behavior throughout
6. Tests validate the entire stack
7. The Plugin Manifest orchestrates loading

This modular design allows components to be developed, tested, and versioned independently.

Summary

• Agents (agents/) – Autonomous workers for specific tasks like planning and review
• Skills (skills/) – Reusable knowledge modules encoding domain expertise
• Commands (commands/) – Slash-command entry points for quick workflow activation
• Rules (rules/) – Enforced policies for security, style, and workflow compliance
• Hooks (hooks/) – Event-driven automations for session lifecycle management
• Scripts (scripts/) – Cross-platform utilities powering commands and hooks
• Tests (tests/) – Automated validation of component behavior
• Contexts (contexts/) – Prompt fragments that shape Claude's operational mode
• Examples (examples/) – Reference implementations demonstrating configuration patterns
• MCP Configs (mcp-configs/) – External service connection settings
• Plugin Manifest (.claude-plugin/plugin.json) – System registration and component discovery

Frequently Asked Questions

How do I create a custom agent in Everything Claude Code?

Create a new Markdown file in the agents/ directory following the pattern of existing agents like agents/architect.md. Define the agent's purpose, capabilities, and invocation patterns. Reference your new agent using the @agentname syntax from Claude's chat interface.

Can I override default rules without modifying core files?

Yes. Create a rules/ directory in your project root and add rule files with the same names as those in the plugin. The plugin's rule loading system checks for project-local overrides before falling back to defaults, allowing customization without forking the repository.

What triggers hooks to execute?

Hooks fire based on events defined in hooks/hooks.json. Standard events include session-start, session-end, and pre-compact. Each event maps to a shell script or Node.js script that executes when Claude reaches that lifecycle point, enabling automated context persistence and optimization suggestions.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}