System Architecture
Relevant source files
The following files were used as context for generating this wiki page:
The Everything Claude Code (ECC) system is a production-ready AI coding platform structured as a collection of specialized agents, skills, and commands. Its architecture is designed to support modularity, scalability, and test-driven development (TDD) by delegating domain-specific tasks to an ecosystem of 67 specialized agents. The system emphasizes an "Agent-First" philosophy where complex engineering workflows are orchestrated through automated hooks and intent-driven development patterns.
Sources: AGENTS.md:1-15, agents/architect.md:38-42
Core Architectural Components
The repository is organized into distinct functional layers that separate orchestration logic, domain skills, and automated triggers.
| Component | Description |
|---|---|
| Agents | 67 specialized subagents designed for specific domain tasks like planning, architecture, and reviewing. |
| Skills | 279 workflow skills that contain domain knowledge and implementation logic. |
| Commands | 92 slash commands providing a legacy compatibility surface and quick user entry points. |
| Hooks | Trigger-based automations for reactive workflows. |
| Codemaps | Token-lean architecture documentation generated from the codebase structure to assist AI context. |
Sources: AGENTS.md:144-152, agents/doc-updater.md:17-21, commands/update-codemaps.md:10-15
Agent Ecosystem and Orchestration
The architecture relies on proactive agent orchestration. Rather than a single monolithic logic, the system launches specific agents based on the task context. For example, the planner is used for complex feature requests, while the code-reviewer is triggered immediately after code modification.
This diagram shows the proactive delegation of tasks from the main orchestrator to specialized domain agents.
Sources: AGENTS.md:43-52, agents/code-architect.md:15-30
Implementation and Planning Workflow
The "PRP Plan" (Pattern-based Implementation Plan) is a central architectural concept for feature delivery. It follows a multi-phase process to capture codebase patterns before implementation begins.
Phase Analysis
The system architecture enforces a "Plan Before Execute" rule. The workflow involves:
- Detection: Identifying input types (PRDs or free-form text).
- Exploration: Deep codebase search for naming conventions, error handling, and existing patterns.
- Architecture Mapping: Defining implementation blueprints with file paths, interfaces, and build sequences.
Sources: commands/prp-plan.md:20-60, agents/code-architect.md:32-50
Build Sequence Logic
The system enforces a specific dependency order during implementation to ensure structural integrity:
- Types and Interfaces
- Core Logic
- Integration Layer
- User Interface (UI)
- Tests
- Documentation
Sources: agents/code-architect.md:43-50
Documentation and Codemap Generation
The system includes an automated subsystem for maintaining "Codemaps"—token-lean architectural maps that provide a high-level overview of the system for AI context management.
The automated codemap generation process scans source directories and classifies files into architectural areas based on regex patterns.
Sources: scripts/codemaps/generate.ts:25-50, commands/update-codemaps.md:17-25
Area Classification Logic
Files are classified into architectural areas using specific path and extension patterns:
- Frontend: Scans
/app/,/pages/, and extensions like.tsx,.vue,.svelte. - Backend: Scans
/api/,/routes/, and extensions like.controller.ts,.service.ts. - Database: Scans
/models/,/migrations/, andschema.prisma. - Workers: Scans
/workers/,/jobs/, and/cron/.
Sources: scripts/codemaps/generate.ts:32-58
Architectural Principles
The system architecture is governed by five core technical principles designed to ensure maintainability and security.
1. Modularity & Separation of Concerns
The system promotes high cohesion and low coupling. Code is organized by feature/domain rather than by type. Files are kept small, typically between 200-400 lines (max 800).
Sources: agents/architect.md:55-60, AGENTS.md:103-107
2. Immutability
A critical architectural constraint is that existing objects and arrays must never be mutated; instead, new copies with changes applied are returned.
Sources: AGENTS.md:101-102, agents/architect.md:118-119
3. Repository and Service Patterns
Backend logic is abstracted behind a standard Repository interface (CRUD operations) and a Service Layer to separate business logic from data access mechanisms.
Sources: agents/architect.md:86-90, AGENTS.md:131-135
4. Security-First Design
Security controls are treated as part of the architecture, not an afterthought. This includes input validation at boundaries, parameterized queries to prevent SQL injection, and a mandatory "Defense in Depth" approach.
Sources: agents/architect.md:70-76, AGENTS.md:71-80
5. Test-Driven Development (TDD)
The architecture requires a mandatory TDD workflow (Red-Green-Refactor) with a minimum requirement of 80% code coverage across unit, integration, and E2E tests.
Sources: AGENTS.md:118-125, agents/architect.md:104-106
Summary
The ECC System Architecture is a highly modular, agent-driven framework that prioritizes planning and pattern mirroring. By separating domain logic into specialized agents and maintaining automated codemaps, the system ensures that complex software development tasks are executed with high consistency and technical accuracy. The architecture's reliance on immutability, TDD, and strict file organization provides a scalable foundation for both manual and autonomous AI coding workflows.