ECC was built from the start as an operating system for AI coding assistants, not a configuration layer bolted onto an existing tool. The agentic pattern skills are the clearest expression of that design philosophy: they encode the patterns that make an AI harness behave as a reliable, self-correcting, continuously-learning engineering partner. From test-driven development loops to multi-agent orchestration to session-to-session knowledge extraction, these skills define what it means to work AI-natively.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.
The Agentic Module (capability:agentic)
Component ID: capability:agenticModule:
agentic-patternsStability: stable
Cost: medium The
agentic-patterns module installs 22 skills and one supporting script (scripts/claw.js) covering autonomous loops, agent harness construction, LLM pipeline optimisation, and multi-agent coordination.
The Workflow Quality Module (baseline:workflow)
Several of the most important agentic skills — the ones concerned with quality assurance, continuous learning, and session management — live in the workflow-quality module, which is installed by default:
Installing Agentic Skills
workflow-quality skills ship by default. Run npx ecc install without flags to confirm they are present.
Agentic Skills: Autonomous Loops and Agent Architecture
agentic-engineering
The foundational skill for AI-first engineering. Encodes the patterns that distinguish genuinely agentic development — structured planning before action, verification loops after implementation, evidence-based decisions, and context-efficient execution.
Activates when: Starting a complex multi-step task, planning a feature implementation, reasoning about how to decompose work.
agentic-os
Agent operating system patterns — the meta-level skill about how to configure, organise, and evolve an ECC installation itself. Covers the relationship between skills, commands, agents, hooks, and rules; how to audit harness health; and when to promote a pattern from a skill into a rule or agent.
agent-architecture-audit
Structured audit of an agent harness design. Use this skill to evaluate whether an ECC installation is well-structured: are skills scoped correctly? Are rules over- or under-specified? Are agents doing too much? Are hooks firing at the right events?
Activates when: Reviewing an ECC configuration, auditing a harness before team onboarding, debugging unexpected harness behaviour.
agent-harness-construction
Patterns for building and configuring agent harnesses from scratch. Covers target selection, skill module composition, agent definition, hook wiring, and initial rule authoring.
autonomous-loops
Continuous autonomous execution patterns — how to structure work that runs through multiple tool-use cycles without requiring per-step user prompts. Covers loop termination conditions, progress reporting, error recovery, and context budget management inside long-running loops.
continuous-agent-loop
Loop management and termination patterns. Where autonomous-loops covers the high-level design, this skill handles the mechanics: checking termination conditions, detecting stalls, managing intermediate state, and producing a clean handoff summary when the loop ends.
ai-first-engineering
Engineering practices designed for the AI-assisted workflow. Covers how to structure code for maximum AI navigability, how to write effective task descriptions, when to use sub-agents vs. sequential prompting, and how to review AI-generated changes efficiently.
claude-devfleet
Patterns for running multiple Claude instances (a “devfleet”) in parallel on a codebase using git worktrees. Covers task decomposition for parallel agents, worktree setup, conflict avoidance, and result integration.
team-agent-orchestration
Multi-agent coordination patterns for teams of specialised agents working on a shared codebase. Covers task routing, agent-to-agent handoffs, shared context management, and result aggregation.
team-builder
Patterns for composing a team of ECC agents from individual agent definitions — selecting the right agents for a project, defining their scopes and tool permissions, and wiring them together.
enterprise-agent-ops
Operational patterns for running AI agents at enterprise scale — logging, auditing, cost management, access control, and integration with enterprise toolchains.
dynamic-workflow-mode
Patterns for switching between different workflow modes (plan-first, code-first, review-first) based on task type and context. Covers how to detect which mode is appropriate and how to transition between modes cleanly.
blueprint
Structured planning patterns for complex features. The blueprint skill encodes a planning-first workflow: produce a written blueprint before writing any code, review it, then use the blueprint as the source of truth for implementation.
nanoclaw-repl
Patterns for using a lightweight REPL-style execution loop for rapid prototyping and exploration inside a Claude Code session.
data-scraper-agent
Agent patterns for web data extraction — structuring a scraping agent, handling pagination and rate limits, cleaning and normalising extracted data, and storing results.
Agentic Skills: Quality Loops and Evaluation
tdd-workflow (workflow-quality module)
The most comprehensive skill in the ECC library — a full test-driven development workflow with 8 steps, a test-runner detection matrix, RED/GREEN gate enforcement, git checkpoint protocol, and a TDD evidence report format.
Key workflow:
Detect the test runner
Run
node scripts/setup-package-manager.js --detect. Resolve the package manager, then identify the actual test runner from package.json scripts.test. Distinguish bun run test (runs the npm script) from bun test (Bun’s native runner).Write user journeys
If a
*.plan.md was provided, extract journeys and acceptance criteria from it. Otherwise write them fresh: As a [role], I want to [action], so that [benefit].Generate test cases
For each journey, write comprehensive tests covering happy path, edge cases, error scenarios, and boundary conditions.
Run tests — confirm RED
Execute the test suite. Confirm the new tests fail for the intended reason. This is the mandatory RED gate — do not modify production code until RED is confirmed and a checkpoint commit is created.
Implement minimal code
Write the smallest implementation that makes the failing tests pass. Stage changes.
Run tests — confirm GREEN
Rerun the same target. Confirm all tests pass. Create a checkpoint commit.
Refactor and verify coverage
Improve code quality while keeping tests green. Run coverage — target ≥ 80%.
eval-harness (workflow-quality module)
Systematic evaluation harness for AI-generated output. Provides patterns for defining evaluation criteria, running structured assessments, recording results, and catching regressions before they reach production.
Activates when: Evaluating AI output quality, setting up regression tests for a model or prompt, comparing two implementations.
verification-loop (workflow-quality module)
Output verification patterns for code quality assurance. A lightweight loop that runs after implementation: lint, typecheck, test, coverage, and a final review pass. Ensures changes meet the project’s quality bar before marking a task complete.
agent-introspection-debugging (workflow-quality module)
Patterns for debugging agent thought processes — examining tool-use sequences, identifying where the agent went wrong, and correcting course without restarting from scratch. Useful when an autonomous loop produces unexpected results.
ai-regression-testing (workflow-quality module)
Patterns for building regression test suites specifically for AI-generated code — capturing the expected behaviours of AI outputs and running them as part of CI to catch model-induced regressions.
strategic-compact (workflow-quality module)
Intelligent context compaction strategies for long sessions. When a session approaches the context limit, this skill guides the compaction decision: what to preserve verbatim, what to summarise, what to drop, and how to reconstruct context efficiently after compaction.
continuous-learning (workflow-quality module)
Legacy v1 session pattern extraction skill. Activated by the Stop hook at session end, it extracts patterns, decisions, and lessons from the completed session and writes them as a learned skill to ~/.claude/skills/learned/.
For new installs, prefer
continuous-learning-v2. The v1 skill remains available for backward compatibility.continuous-learning-v2 (workflow-quality module)
The current session-to-session learning extraction system. Produces structured skill documents from session analysis, with proper provenance metadata (.provenance.json) and placement in ~/.claude/skills/learned/.
skill-scout (workflow-quality module)
Discovers which ECC skills are relevant to a given task or codebase. Use this skill when you’re not sure which skill modules to activate — it analyses the context and recommends the right skills.
skill-stocktake (workflow-quality module)
Produces a full inventory of installed skills, their health status, and any gaps relative to the current project’s tech stack.
Agentic Skills: LLM Pipeline Optimisation
cost-aware-llm-pipeline
Patterns for building LLM pipelines that manage token costs explicitly — routing tasks to the appropriate model (Haiku vs. Sonnet vs. Opus), batching requests, caching embeddings, and tracking spend per workflow stage.
prompt-optimizer
Patterns for systematically improving prompts — identifying vagueness, adding examples, tightening constraints, and measuring the impact of changes.
token-budget-advisor
Real-time guidance on context budget management during a session — how much context is being used, what is taking the most space, and how to restructure the session to extend the effective window.
regex-vs-llm-structured-text
Decision framework for choosing between regex/deterministic parsing and LLM-based structured text extraction. Covers accuracy, cost, latency, and maintainability trade-offs.
content-hash-cache-pattern
Caching patterns for LLM pipelines using content-addressed storage — avoiding redundant model calls by hashing inputs and caching outputs.
search-first
A discipline for AI-assisted research and implementation: always search (codebase, web, documentation) before generating. Reduces hallucination and avoids re-implementing existing functionality.
ralphinho-rfc-pipeline
Patterns for turning RFC-style design documents into structured implementation plans that agents can execute.
Machine Learning Skills (capability:machine-learning)
Component ID: capability:machine-learningModule:
machine-learningStability: beta
Cost: medium
mle-workflow
Production machine-learning engineering workflow. This is a comprehensive skill covering the full ML lifecycle:
| Phase | What the skill covers |
|---|---|
| Data contracts | Schema validation, drift detection, data quality gates |
| Reproducible training | Experiment tracking, seed management, config-as-code |
| Evaluation | Offline metrics, eval harnesses, A/B test design |
| Deployment | Model serving, canary rollout, feature flags |
| Monitoring | Prediction drift, data drift, alert thresholds |
| Rollback | Rollback triggers, model version management, incident runbooks |
machine-learning module depends on framework-language, workflow-quality, database, devops-infra, and security — install it knowing those modules will be pulled in as well.
Install:
Optimisation Skills (capability:optimization)
Component ID: capability:optimizationModule:
optimization-workflowsStability: beta
| Skill | What it covers |
|---|---|
benchmark-optimization-loop | Iterative benchmark-driven optimisation with automated measurement and improvement cycles |
data-throughput-accelerator | High-throughput data pipeline patterns — batching, streaming, backpressure |
latency-critical-systems | Latency measurement, profiling, and optimisation for real-time systems |
parallel-execution-optimizer | Task parallelisation patterns — identifying independent work, managing concurrency |
recursive-decision-ledger | Evidence-tracking pattern for complex multi-step decisions |