Home About Me

A Practical Guide to Everything Claude Code

2026-05-27

What Everything Claude Code is built for

Everything Claude Code (ECC) is a full optimization layer for AI coding agents, designed around tools such as Claude Code, Cursor, and OpenCode. It has been used in production for more than 10 months and brings together workflows, specialist agents, reusable skills, rules, and automation hooks into one system.

Its main pitch is straightforward:

  • cut token costs by as much as 60%
  • provide 136+ ready-made workflow skills
  • include 30+ specialized sub-agents
  • keep the experience consistent across platforms and languages

Rather than acting like a single feature plugin, ECC works more like an operating model for AI-assisted development.

The system at a glance

ECC is organized around six major parts: agents, skills, commands, rules, hooks, and MCP integrations.

Agents: specialized task delegation

The agent system includes more than 30 focused sub-agents that can take over specific kinds of work.

Common categories include:

  • Code review agents for general review and architecture guidance
  • Language specialists for TypeScript, Python, Go, Java, Kotlin, C++, Rust, and others
  • Build-fix agents that handle build failures across ecosystems
  • Domain specialists for security review, database review, test automation, and documentation work

These agents are meant to offload complex or narrowly scoped tasks instead of forcing everything through a single general session.

Skills: reusable workflow definitions

ECC ships with 136+ workflow skills. These are reusable knowledge modules that encode patterns for particular domains.

Coverage includes:

Backend development

  • Django, Spring Boot, and Laravel design patterns
  • RESTful API and GraphQL best practices
  • database design and optimization

Frontend development

  • React, Vue, and Angular architecture patterns
  • component design and state management
  • performance tuning techniques

Testing and quality

  • TDD workflows
  • E2E testing with Playwright integration
  • unit and integration testing

Security and compliance

  • security scanning and vulnerability detection
  • code auditing and validation loops
  • OWASP Top 10 protections

Business and content work

  • technical writing
  • presentation building
  • investor materials

Commands: fast access through slash commands

There are 60+ slash commands for common actions. A few representative ones:

<table> <thead> <tr> <th>Command</th> <th>Purpose</th> </tr> </thead> <tbody> <tr> <td>/plan</td> <td>Create an implementation plan</td> </tr> <tr> <td>/tdd</td> <td>Start a test-driven development workflow</td> </tr> <tr> <td>/code-review</td> <td>Run a code quality review</td> </tr> <tr> <td>/build-fix</td> <td>Fix build failures</td> </tr> <tr> <td>/security-scan</td> <td>Scan for security issues</td> </tr> <tr> <td>/e2e</td> <td>Generate end-to-end tests</td> </tr> <tr> <td>/multi-plan</td> <td>Plan with multiple agents</td> </tr> <tr> <td>/instinct-status</td> <td>Inspect learned patterns</td> </tr> </tbody> </table>

Rules: language-specific always-follow guidance

Rules are organized by language and define the principles the system should consistently apply.

Examples include:

  • TypeScript: type safety and best practices
  • Python: PEP 8 plus Django/FastAPI patterns
  • Go: idiomatic style and concurrency patterns
  • Swift: iOS development conventions
  • PHP: Laravel/Symfony guidance
  • plus Java, Kotlin, Rust, C++, Perl, and more

Hooks: event-driven automation

ECC supports 8+ hook event types for automation. These cover things like:

  • session persistence
  • pre/post tool processing
  • strategic memory compaction
  • automatic pattern extraction for learning

MCP support: external system integration

ECC also includes 14+ MCP server configurations through the Model Context Protocol, with support for:

  • GitHub and GitLab
  • PostgreSQL and MongoDB
  • AWS, GCP, and Azure
  • Slack, Jira, and Linear

Installation options

There are three main ways to install ECC.

Recommended: install from the plugin marketplace

# 1. 添加插件市场
/plugin marketplace add affaan-m/everything-claude-code

# 2. 安装插件
/plugin install everything-claude-code@everything-claude-code

# 3. 验证安装
/plugin list

Manual installation

Step 1: clone the repository

git clone https://github.com/affaan-m/everything-claude-code.git
cd everything-claude-code

Step 2: copy only the components you want

# macOS/Linux
# 复制智能体
cp -r agents/* ~/.claude/agents/

# 复制技能
cp -r skills/* ~/.claude/skills/

# 复制命令
cp -r commands/* ~/.claude/commands/

# 复制钩子
cp -r hooks/* ~/.claude/hooks/

# 复制规则 (必须手动安装,不能通过插件分发)
cp -r rules/typescript ~/.claude/rules/
cp -r rules/python ~/.claude/rules/
# ... 其他语言

# Windows PowerShell
# 复制智能体
Copy-Item -Recurse agents\* $env:USERPROFILE\.claude\agents\

# 复制技能
Copy-Item -Recurse skills\* $env:USERPROFILE\.claude\skills\

# 复制命令
Copy-Item -Recurse commands\* $env:USERPROFILE\.claude\commands\

# 复制钩子
Copy-Item -Recurse hooks\* $env:USERPROFILE\.claude\hooks\

# 复制规则
Copy-Item -Recurse rules\typescript $env:USERPROFILE\.claude\rules\
Copy-Item -Recurse rules\python $env:USERPROFILE\.claude\rules\

Language-targeted installation

If you only want support for a particular stack, you can install selectively.

# 仅 TypeScript/JavaScript 项目
cp -r rules/typescript ~/.claude/rules/
cp agents/typescript-reviewer.md ~/.claude/agents/
cp skills/typescript/* ~/.claude/skills/

# 仅 Python 项目
cp -r rules/python ~/.claude/rules/
cp agents/python-reviewer.md ~/.claude/agents/
cp skills/django-patterns.md ~/.claude/skills/

System requirements

  • Claude Code CLI: v2.1.0 or newer
  • OS: Windows 10+, macOS 10.15+, Linux (any modern distribution)
  • Node.js: 18+ for scripts and tests

One important detail: do not add a hooks field to plugin.json. In Claude Code v2.1+, hooks.json is loaded automatically, and declaring hooks explicitly can trigger duplicate hook detection errors.

Core components in more detail

Agents

Agents are specialized subprocesses for handling harder or more structured tasks.

Typical agent files include:

Architecture-related

  • planner.md — implementation planning
  • architect.md — system architecture design
  • code-reviewer.md — code review

Language specialists

  • typescript-reviewer.md — TypeScript reviewer
  • python-reviewer.md — Python reviewer
  • go-reviewer.md — Go reviewer

Domain specialists

  • security-reviewer.md — security audits
  • database-reviewer.md — database optimization
  • tdd-guide.md — TDD guidance

Example usage:

# 启动 TDD 工作流
/tdd

# 代码审查
/code-review

# 安全扫描
/security-scan

Skills

Skills package workflow knowledge in reusable form.

A typical structure looks like this:

skills/
├── coding-standards/
│   ├── typescript-patterns.md
│   ├── python-best-practices.md
│   └── go-idioms.md
├── testing/
│   ├── tdd-workflow.md
│   ├── e2e-playwright.md
│   └── unit-testing.md
├── security/
│   ├── security-scan.md
│   └── vulnerability-check.md
└── architecture/
    ├── api-design.md
    └── database-design.md

Skill files follow a simple structure:

---
name: tdd-workflow
description: Test-driven development workflow
---

## When to Use
当需要使用测试驱动开发方法时使用此技能

## How It Works
1. 编写失败的测试
2. 实现最小代码使测试通过
3. 重构代码
4. 重复

## Examples
...

Commands

Slash commands provide the operational layer of ECC.

Development workflows

  • /plan — create an implementation plan
  • /tdd — begin a TDD loop
  • /build-fix — repair build failures
  • /e2e — generate and run end-to-end tests

Quality assurance

  • /code-review — perform a code review
  • /security-scan — run a security scan
  • /test-coverage — inspect test coverage

Learning and optimization

  • /learn — extract patterns from sessions
  • /instinct-status — view learned instincts
  • /evolve — turn instincts into skills

Multi-agent collaboration

  • /multi-plan — collaborative task decomposition
  • /multi-execute — orchestrate multiple agents

Rules

Rules define guidance that should always be followed.

A representative layout:

rules/
├── typescript/
│   ├── coding-style.md
│   ├── testing.md
│   └── security.md
├── python/
│   ├── pep8.md
│   ├── django-patterns.md
│   └── testing.md
└── general/
    ├── git-workflow.md
    └── security-basics.md

Example TypeScript rule content:

# TypeScript 编码规范

## 类型安全
- 始终显式声明函数返回类型
- 避免使用 `any`,优先使用 `unknown`
- 使用严格的 TypeScript 配置

## 代码风格
- 使用 2 空格缩进
- 使用 ESLint 和 Prettier
- 遵循 Airbnb 风格指南

## 测试要求
- 所有公共函数必须有单元测试
- 最小测试覆盖率: 80%
- 使用 Jest 作为测试框架

Hooks

Hooks let ECC respond to events automatically.

Supported hook types include:

  • user-prompt-submit
  • tool-call-pre
  • tool-call-post
  • session-start
  • session-end

Example hooks.json:

{
  "hooks": [
    {
      "matcher": {
        "event": "tool-call-post",
        "tool": "Edit"
      },
      "hooks": [
        {
          "command": "node scripts/auto-format.js {{file_path}}"
        }
      ]
    },
    {
      "matcher": {
        "event": "session-end"
      },
      "hooks": [
        {
          "command": "node scripts/save-session.js"
        }
      ]
    }
  ]
}

Getting started quickly

ECC is easiest to understand through workflows.

Adding a new feature

# 1. 制定计划
/plan "添加用户认证功能"

# 2. 使用 TDD 开发
/tdd

# 3. 代码审查
/code-review

# 4. 安全扫描
/security-scan

# 5. E2E 测试
/e2e

# 6. 提交代码
/commit

Fixing a bug

# 1. 编写失败的测试重现 bug
# (Claude 会帮助你)

# 2. 使用 TDD 修复
/tdd

# 3. 验证修复
/test

# 4. 代码审查
/code-review

Performance optimization

# 1. 分析当前性能
/analyze-performance

# 2. 制定优化计划
/plan "优化数据库查询性能"

# 3. 实现优化
# (使用 Claude 辅助)

# 4. 基准测试
/benchmark

# 5. 代码审查
/code-review

Key commands and what they do

/plan

Used for structured implementation planning.

/plan "实现用户注册功能"

Typical output includes:

  • task breakdown
  • affected file list
  • key considerations
  • architecture trade-offs

/tdd

Starts a test-driven development cycle.

/tdd

Workflow:

  1. write a failing test
  2. add the minimum code needed
  3. run tests
  4. refactor
  5. repeat

/build-fix

Detects and repairs build errors.

/build-fix

Supported build systems include:

  • npm, yarn, pnpm, bun
  • Maven, Gradle
  • Go modules
  • Cargo (Rust)

/code-review

Runs a broad review of code quality.

/code-review

Review dimensions:

  • code quality and maintainability
  • performance and efficiency
  • security risks
  • test coverage
  • documentation completeness

/security-scan

Runs security checks through AgentShield.

/security-scan

It scans for:

  • leaked keys and credentials
  • permission problems
  • hook injection risks
  • MCP vulnerabilities
  • dependency issues

/e2e

Generates and runs end-to-end tests.

/e2e

Supported integrations:

  • Playwright (recommended)
  • Cypress
  • Puppeteer

Learning commands

/learn extracts reusable patterns from session history.

/learn

Expected output:

  • recognized patterns
  • confidence scores
  • suggested skills

/instinct-status shows what the system has already learned.

/instinct-status

It displays:

  • current instinct list
  • trigger frequency
  • confidence levels

/evolve turns clustered instincts into reusable skills.

/evolve

Process:

  1. analyze similar instincts
  2. cluster patterns
  3. generate skill definitions
  4. save them into the skill library

Multi-agent commands

/multi-plan allows several agents to collaborate on planning.

/multi-plan "构建电商平台"

Possible participants:

  • architect
  • frontend specialist
  • backend specialist
  • database specialist
  • security specialist

/multi-execute orchestrates multiple tasks.

/multi-execute

Orchestration strategy can include:

  • parallel execution for independent work
  • serial execution for dependent tasks
  • error handling and rollback

Advanced capabilities

Continuous Learning System v2

ECC includes an automatic learning system that identifies repeatable patterns from sessions.

How it works:

  1. Pattern recognition identifies recurring workflows
  2. Confidence scoring rates them by frequency and success
  3. Instinct generation converts patterns into instincts
  4. Skill evolution promotes validated instincts into formal skills

Typical flow:

# 1. 检查当前直觉
/instinct-status

# 2. 从会话中学习
/learn

# 3. 导入他人的直觉
/instinct-import <url-or-file>

# 4. 进化为技能
/evolve

# 5. 验证新技能
/skill-test <skill-name>

Instincts are represented like this:

{
  "id": "prefer-composition",
  "pattern": "使用组合而非继承",
  "context": "TypeScript 类设计",
  "confidence": 0.87,
  "frequency": 12,
  "last_used": "2026-03-28"
}

Session persistence

Hooks can preserve state across sessions.

Configuration example:

{
  "hooks": [
    {
      "matcher": {
        "event": "session-end"
      },
      "hooks": [
        {
          "command": "node scripts/persist-session.js"
        }
      ]
    },
    {
      "matcher": {
        "event": "session-start"
      },
      "hooks": [
        {
          "command": "node scripts/restore-session.js"
        }
      ]
    }
  ]
}

Persisted information can include:

  • current task state
  • learned instincts
  • project context
  • user preferences

Strategic compaction

ECC can manage context windows more deliberately.

Configuration:

{
  "env": {
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
  }
}

Compaction strategy:

  • compact at logical breakpoints when context usage reaches 50%
  • keep important information
  • discard redundant material
  • preserve session continuity

Manual control:

# 手动压缩会话
/compact

# 查看压缩状态
/compact-status

Multi-agent orchestration with PM2

PM2 can be used to run several agents as separate managed processes.

Install PM2:

npm install -g pm2

Sample ecosystem.config.js:

module.exports = {
  apps: [
    {
      name: 'frontend-agent',
      script: 'claude-code',
      args: '--agent frontend-reviewer',
      instances: 1
    },
    {
      name: 'backend-agent',
      script: 'claude-code',
      args: '--agent backend-reviewer',
      instances: 1
    },
    {
      name: 'security-agent',
      script: 'claude-code',
      args: '--agent security-reviewer',
      instances: 1
    }
  ]
};

Management commands:

# 启动所有智能体
pm2 start ecosystem.config.js

# 查看状态
pm2 status

# 查看日志
pm2 logs

# 停止所有
pm2 stop all

# 重启
pm2 restart all

Performance and token cost optimization

One of ECC’s strongest themes is practical cost control.

Strategy 1: choose the right model

{
  "model": "sonnet"
}

Cost comparison:

  • Opus: $15/1M input tokens, $75/1M output
  • Sonnet: $3/1M input tokens, $15/1M output
  • Haiku: $0.25/1M input tokens, $1.25/1M output

Recommendations:

  • use Sonnet by default for roughly 60% cost reduction
  • reserve Opus for deeper architecture decisions
  • use Haiku for lighter tasks

Strategy 2: cap thinking tokens

{
  "env": {
    "MAX_THINKING_TOKENS": "10000"
  }
}

Strategy 3: strategic compaction

{
  "env": {
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
  }
}

Strategy 4: manage MCP usage

# 查看活动的 MCP
/mcp list

# 禁用不需要的 MCP
/mcp disable <mcp-name>

# 每个项目保持 < 10 个活动 MCP

Monitoring usage

Cost tracking:

# 查看当前会话成本
/cost

# 查看项目总成本
/cost --project

# 设置预算警告
/cost --budget 100

Token analysis:

# 查看 token 使用详情
/tokens

# 按工具分类
/tokens --by-tool

# 按智能体分类
/tokens --by-agent

Optimization practices

  1. Context management - use /compact regularly - avoid unnecessary file reads - prefer precise queries over broad searches
  2. Agent delegation - delegate complex tasks to specialist agents - avoid forcing large data handling into the main session - run independent work in parallel
  3. Skill reuse - prefer existing skills first - avoid redefining the same workflow repeatedly - share and import community skills
  4. MCP optimization - only enable what the project needs - review MCP usage periodically - prefer lighter MCP alternatives where possible

Cross-platform support

ECC is not limited to one interface.

Claude Code

Full native support is available.

# 安装 Claude Code
npm install -g @anthropic-ai/claude-code

# 安装 ECC
/plugin install everything-claude-code@everything-claude-code

Cursor IDE

Supported through a DRY hook adapter approach.

Configuration in .cursor/settings.json:

{
  "claude.agents": "~/.claude/agents",
  "claude.skills": "~/.claude/skills",
  "claude.commands": "~/.claude/commands",
  "claude.rules": "~/.claude/rules"
}

Known limitations:

  • limited hook support
  • some commands need adaptation

Codex on macOS

Also supported, with a reference configuration.

{
  "pluginDirs": [
    "~/.claude/agents",
    "~/.claude/skills"
  ],
  "model": "sonnet"
}

OpenCode

Full plugin support is available, along with 11+ hook event types.

# 安装
opencode plugin add everything-claude-code

# 启用钩子
opencode hooks enable

Antigravity

Can be integrated for workflows and skills.

plugins:
  - name: everything-claude-code
    enabled: true
    paths:
      agents: ~/.claude/agents
      skills: ~/.claude/skills

Security features

AgentShield integration

ECC includes AgentShield for security scanning.

Reported stats:

  • 1282 tests
  • 98% coverage
  • 102 static analysis rules

Scan categories include:

  1. Secret scanning - detect hardcoded API keys - identify sensitive credentials - inspect config files
  2. Permission checks - filesystem permissions - network access rights - process permissions
  3. Hook injection checks - detect malicious hooks - validate hook signatures - isolate untrusted hooks
  4. MCP vulnerability checks - validate MCP servers - verify encrypted communication - check permission boundaries

Using AgentShield:

# 运行完整安全扫描
/security-scan

# 仅扫描密钥
/security-scan --secrets

# 扫描钩子
/security-scan --hooks

# 扫描 MCP
/security-scan --mcp

# 生成报告
/security-scan --report

Sample report:

╔════════════════════════════════════════════════════╗
║         AgentShield 安全扫描报告                   ║
╠════════════════════════════════════════════════════╣
║ 扫描时间: 2026-03-31 10:30:45                     ║
║ 扫描文件: 1,234                                   ║
║ 发现问题: 3                                       ║
╠════════════════════════════════════════════════════╣
║ [高危] 在 config/api.ts 发现硬编码 API 密钥       ║
║   → 行 23: const apiKey = "sk-1234..."           ║
║   → 建议: 使用环境变量                            ║
║                                                    ║
║ [中危] 钩子权限过于宽松: auto-deploy.json         ║
║   → 允许执行任意命令                              ║
║   → 建议: 限制命令白名单                          ║
║                                                    ║
║ [低危] MCP 服务器未启用 TLS: database-mcp         ║
║   → 建议: 启用加密通信                            ║
╚════════════════════════════════════════════════════╝

Sandboxing

Hook sandbox example:

{
  "security": {
    "hooks": {
      "sandbox": true,
      "allowedCommands": ["node", "npm", "git"],
      "blockedPaths": ["/etc", "/usr/bin"]
    }
  }
}

MCP sandbox example:

{
  "security": {
    "mcp": {
      "requireTLS": true,
      "validateCertificates": true,
      "allowedHosts": ["github.com", "api.example.com"]
    }
  }
}

CVE monitoring

Dependency vulnerabilities can be tracked as well.

# 检查 CVE
/security-scan --cve

# 更新漏洞数据库
/security-update-db

# 查看 CVE 报告
/security-cve-report

Working practices that fit ECC well

Project bootstrap

# 1. 初始化项目
cd your-project

# 2. 选择语言规则
/rules select typescript python

# 3. 配置 MCP
/mcp setup

# 4. 初始化学习系统
/instinct-init

# 5. 运行初始扫描
/security-scan

Daily workflows

Feature development

/plan "新功能描述" → /tdd → /code-review → /commit

Bug fixing

写失败测试 → /tdd → 验证 → /code-review → /commit

Refactoring

/plan "重构计划" → 实现 → /test → /code-review → /commit

Quality standards

Pre-commit checklist:

  • [ ] all tests pass
  • [ ] test coverage ≥ 80%
  • [ ] code review passes
  • [ ] no high-severity findings in security scan
  • [ ] documentation updated
  • [ ] performance benchmarks meet expectations

Example automated checks:

{
  "hooks": [
    {
      "matcher": {"event": "pre-commit"},
      "hooks": [
        {"command": "/test"},
        {"command": "/code-review"},
        {"command": "/security-scan"}
      ]
    }
  ]
}

Team collaboration

Shared configuration:

# 导出团队配置
/config export team-config.json

# 导入团队配置
/config import team-config.json

Shared skills:

# 导出技能
/skill export api-design-patterns

# 导入技能
/skill import team-skills.json

Shared instincts:

# 导出直觉
/instinct export team-instincts.json

# 导入直觉
/instinct import team-instincts.json

Continuous improvement

Weekly review:

# 1. 查看学习到的模式
/instinct-status

# 2. 进化新技能
/evolve

# 3. 查看成本分析
/cost --week

# 4. 优化配置
/config optimize

Monthly review:

# 1. 审查所有技能
/skill list --usage

# 2. 删除未使用的技能
/skill prune

# 3. 更新依赖
/update

# 4. 安全审计
/security-audit --full

Troubleshooting

Plugin install fails

If /plugin install fails:

# 检查 Claude Code 版本
claude --version  # 需要 ≥ v2.1.0

# 清除缓存
rm -rf ~/.claude/cache

# 重新安装
/plugin install everything-claude-code@everything-claude-code

Duplicate hook detection

If you see Error: Duplicate hook detected:

# 检查 plugin.json
cat ~/.claude/plugins/everything-claude-code/plugin.json

# 移除 hooks 字段 (如果存在)
# hooks.json 会被自动加载

Rules are not applied

If language rules do not take effect:

# 手动复制规则 (规则不能通过插件分发)
cp -r everything-claude-code/rules/typescript ~/.claude/rules/

# 验证规则
/rules list

# 重启 Claude Code

MCP connection failures

If an MCP server will not connect:

# 检查 MCP 状态
/mcp status

# 重启 MCP 服务器
/mcp restart <mcp-name>

# 检查日志
cat ~/.claude/logs/mcp.log

Token use is too high

If token usage exceeds expectations:

# 1. 切换到 Sonnet
/model sonnet

# 2. 限制思考 token
/config set MAX_THINKING_TOKENS 10000

# 3. 启用战略性压缩
/config set CLAUDE_AUTOCOMPACT_PCT_OVERRIDE 50

# 4. 禁用不必要的 MCP
/mcp disable <unused-mcp>

Learning system produces no output

If /learn returns nothing:

# 检查会话历史
ls ~/.claude/sessions/

# 重新初始化学习系统
/instinct-init --reset

# 手动触发学习
/learn --force

Debugging aids

Enable verbose logging:

{
  "logging": {
    "level": "debug",
    "file": "~/.claude/logs/debug.log"
  }
}

Inspect logs:

# 查看主日志
tail -f ~/.claude/logs/main.log

# 查看智能体日志
tail -f ~/.claude/logs/agents.log

# 查看钩子日志
tail -f ~/.claude/logs/hooks.log

Test configuration pieces directly:

# 验证配置文件
/config validate

# 测试钩子
/hooks test <hook-name>

# 测试技能
/skill test <skill-name>

# 测试智能体
/agent test <agent-name>

Supported stacks and integrations

ECC covers a wide spread of languages and frameworks.

Languages

  • TypeScript / JavaScript
  • Python
  • Go
  • Swift
  • PHP
  • Perl
  • Java
  • Kotlin
  • Rust
  • C++

Frontend frameworks

  • React
  • Vue.js
  • Angular
  • Svelte
  • Next.js
  • Nuxt.js

Backend frameworks

  • Node.js / Express
  • Django
  • FastAPI
  • Spring Boot
  • Laravel
  • Symfony
  • Ruby on Rails
  • ASP.NET Core

Testing frameworks

  • Jest
  • Vitest
  • Playwright
  • Cypress
  • pytest
  • Go testing
  • JUnit

Databases

  • PostgreSQL
  • MySQL
  • MongoDB
  • Redis
  • Elasticsearch

MCP coverage includes version control tools, databases, cloud providers, dev tools, filesystem access, and web search, with examples such as GitHub, GitLab, Bitbucket, PostgreSQL, MongoDB, Redis, AWS, GCP, Azure, Slack, Jira, Linear, and Sentry.

Example full configuration

A representative ~/.claude/settings.json setup:

{
"model": "sonnet",
"env": {
"MAX_THINKING_TOKENS": "10000",
"CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "50"
},
"logging": {
"level": "info",
"file": "\~/.claude/logs/main.log"
},
"security": {
"hooks": {
"sandbox": true,
"allowedCommands": ["node", "npm", "git"]
},
"mcp": {
"requireTLS": true,
"validateCertificates": true
}
},
"learning": {
"autoLearn": true,
"confidenceThreshold": 0.7,
"maxInstincts": 100
},
"cost": {
"budget": 100,
"alertThreshold": 80
}
}

ECC makes the most sense if you want more than isolated prompts. It is a structured layer for planning, reviewing, testing, securing, learning from repeated work, and keeping token usage under control across a real development workflow.

Related Posts