Everything Claude Code 三十节课程大纲

王小酱
14 阅读29分钟

面向希望系统掌握 AI 编程助手 Harness 工具体系的开发者。 聚焦编程与架构领域 Skill。 每节课一个明确收获，知识点之间严格递进，不跳跃、不超纲。

课程设计理念

节奏控制

30 节课分为六个阶段，每阶段有明确的能力目标：

第一阶段：认知建立（第1-3课）     → 能说清 ECC 是什么、为什么、怎么组织
第二阶段：组件精讲（第4-11课）    → 能读懂并创建每种核心组件
第三阶段：工作流实战（第12-16课）  → 能在真实项目中跑通完整开发流程
第四阶段：语言与框架（第17-22课）  → 能针对具体技术栈深度使用 ECC
第五阶段：进阶能力（第23-27课）   → 能处理安全、性能、学习等高级主题
第六阶段：综合与创造（第28-30课）  → 能独立设计和贡献 ECC 配置方案

知识依赖链

第一阶段：认知建立
┌─────┐   ┌─────┐   ┌─────┐
│ 1课 │──→│ 2课 │──→│ 3课 │
│ 哲学 │   │ 架构 │   │目录 │
└─────┘   └─────┘   └──┬──┘
                        │
第二阶段：组件精讲       │
┌─────┐   ┌─────┐   ┌──▼──┐   ┌─────┐
│ 4课 │──→│ 5课 │   │ 6课 │──→│ 7课 │
│Rules│   │Rules│   │Agent│   │Agent│
│通用 │   │语言 │   │格式 │   │设计 │
└──┬──┘   └──┬──┘   └──┬──┘   └──┬──┘
   │         │         │         │
   ▼         ▼         ▼         ▼
┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐
│ 8课 │──→│ 9课 │   │10课 │──→│11课 │
│Skill│   │Skill│   │Hook │   │Scrip│
│结构 │   │编写 │   │事件 │   │底层 │
└──┬──┘   └──┬──┘   └──┬──┘   └──┬──┘
   │         │         │         │
第三阶段：工作流实战     │         │
   ▼         ▼         ▼         ▼
┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐
│12课 │──→│13课 │──→│14课 │──→│15课 │──→│16课 │
│调用 │   │TDD流│   │验证 │   │上下文│   │多代理│
│链   │   │程   │   │循环 │   │管理 │   │编排 │
└─────┘   └─────┘   └─────┘   └─────┘   └─────┘
                                            │
第四阶段：语言与框架                         │
┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐   ┌──▼──┐   ┌─────┐
│17课 │   │18课 │   │19课 │   │20课 │   │21课 │──→│22课 │
│后端 │   │前端 │   │移动 │   │数据库│   │API  │   │微服务│
│语言 │   │框架 │   │开发 │   │模式 │   │设计 │   │架构 │
└─────┘   └─────┘   └─────┘   └─────┘   └─────┘   └─────┘
                                                       │
第五阶段：进阶能力                                      │
┌─────┐   ┌─────┐   ┌─────┐   ┌─────┐   ┌──────────┐
│23课 │──→│24课 │   │25课 │──→│26课 │   │  27课    │
│安全 │   │安全 │   │学习 │   │Eval │   │Agent开发 │
│威胁 │   │防御 │   │系统 │   │驱动 │   │与LLM工程 │
└─────┘   └─────┘   └─────┘   └─────┘   └──────────┘
                                               │
第六阶段：综合与创造                            │
┌─────┐   ┌─────┐   ┌──────────────────┐      │
│28课 │──→│29课 │──→│      30课        │◀─────┘
│跨平台│  │ECC2 │   │ 综合实战毕业项目  │
└─────┘   └─────┘   └──────────────────┘

每节课的标准收获

每节课结束后，学员都能带走一个可验证的成果：

课次带走成果
1一份五大原则的个人理解笔记
2一张手绘的组件关系图
3一次完整的仓库浏览和安装体验
4能解释 Rules 分层优先级
5一份为新语言草拟的 Rule 文件
6能说出 Agent 四个字段各自的作用
7一个自己创建的 Agent 文件
8能说出 Skill 和文档的本质区别
9一个自己编写的 Skill 草稿
10一个自定义的 Hook 配置
11一个可运行的 Hook 脚本
12一张完整的命令调用链流程图
13一次完整的 TDD RED-GREEN-IMPROVE 体验
14一次通过验证循环的代码提交
15能在三种动态上下文间切换使用
16一个多 Agent 并行编排方案
17一份你主力后端语言的 ECC 配置
18一份你主力前端框架的 ECC 配置
19了解移动端（Swift/Dart）的 ECC 模式
20一次数据库 Migration 的 ECC 辅助体验
21一份符合 ECC 规范的 API 设计方案
22理解微服务/六边形架构的 ECC 支持
23能列出 5 个 AI 代理特有的攻击向量
24一次 AgentShield 扫描 + 一个安全 Hook
25从会话中提取出一个 Instinct
26一次 Eval 的设计和运行
27理解 Agent Harness 构建和 LLM 成本优化
28了解 Plugin Manifest 和安装 Profile
29体验 ECC 2.0 Dashboard
30一个为真实项目设计的完整 ECC 方案

编程/架构 Skill 覆盖范围

本课程聚焦以下 85 个编程相关 Skill：

领域数量代表 Skill
核心开发10coding-standards, tdd-workflow, api-design, backend-patterns
语言专用28python-patterns, golang-patterns, rust-patterns, kotlin-patterns 等
框架专用19django-patterns, springboot-patterns, laravel-patterns, nestjs-patterns 等
测试验证7e2e-testing, eval-harness, verification-loop, benchmark
安全2security-review, security-scan
DevOps4docker-patterns, deployment-patterns, github-ops
AI/Agent11agent-harness-construction, cost-aware-llm-pipeline, claude-api
流程工具8strategic-compact, codebase-onboarding, git-workflow

第一阶段：认知建立（第 1-3 课）

目标：能说清 ECC 是什么、为什么这样设计、怎么组织的。

第 1 课：设计哲学 — ECC 为什么存在

项目内容
前置条件无
本课收获能用自己的话解释五大原则，理解 ECC 在 AI 编程工具生态中的定位

知识点

  1. 什么是 AI Harness

    • AI 编程助手的增强框架
    • 类比：Claude Code 是引擎，ECC 是赛车套件
    • 支持 6 种 Harness：Claude Code、Codex、Cursor、OpenCode、Gemini、Antigravity

  2. 五大核心原则（SOUL.md）

    • Agent-First：尽早将工作路由给专家代理
    • Test-Driven：先写测试，再信任实现
    • Security-First：验证输入、保护密钥、安全默认
    • Immutability：偏好显式状态转换，避免就地修改
    • Plan Before Execute：复杂变更拆解为审慎阶段

  3. 原则之间的内在逻辑

    • Plan Before Execute（想清楚）→ Agent-First（分给专家做）→ Test-Driven（做完要验证）→ Security-First（验证要包括安全）→ Immutability（安全的基础是状态可控）

必读 SOUL.md（全文）、README.md（Quick Start 部分）

练习 用一段话写出五大原则的内在逻辑链

第 2 课：架构全景 — 六大组件如何协作

项目内容
前置条件第 1 课
本课收获能画出六大组件关系图，能说清每个组件的职责边界

知识点

  1. 六大组件

    组件本质类比数量
    Rules约束条件公司制度89 文件
    Agents专业执行者部门员工47 个
    Skills知识文档操作手册286 个
    Commands交互入口前台接待79 个
    Hooks事件监听监控探头7 种事件
    Scripts工具函数基础设施126 个

  2. 协作模型

    用户 → Command → Skill → Agent → (遵循 Rules)
                               ↑
                        Hooks 在各阶段自动介入
                               ↑
                        Scripts 提供底层能力

  3. 三组关键区分

    • Skill vs Agent：知识（"怎么做"） vs 执行者（"去做"）
    • Command vs Skill：入口 shim（过渡中） vs 持久知识单元（未来主力）
    • Hook vs Script：声明（"何时触发什么"） vs 实现（"具体怎么执行"）

必读 CLAUDE.md、CONTRIBUTING.md、the-shortform-guide.md

练习 手绘一张六大组件关系图，标注数据流方向

第 3 课：上手体验 — 安装与目录漫游

项目内容
前置条件第 2 课
本课收获完成安装，浏览过每个核心目录，对文件格式有感性认识

知识点

  1. 安装方式

    • Plugin marketplace：/plugin install ecc@ecc
    • Shell 脚本：./install.sh --profile full
    • npx：npx ecc-install typescript

  2. 目录漫游清单

    • 每个目录随机打开 2-3 个文件，感受格式
    • 注意 YAML frontmatter 在各组件中的不同用法
    • 留意 docs/zh-CN/ 中文文档

  3. 运行测试验证环境

    node tests/run-all.js

  4. 关键参考文件定位

    • AGENTS.md：Agent 完整目录
    • COMMANDS-QUICK-REF.md：命令速查
    • examples/：各技术栈的 CLAUDE.md 模板

必读 AGENTS.md、COMMANDS-QUICK-REF.md

练习 执行安装并运行测试，浏览 agents/、skills/、commands/、hooks/、rules/ 各打开 2 个文件

第二阶段：组件精讲（第 4-11 课）

目标：能读懂并创建每种核心组件。每两课深入一个组件。

第 4 课：Rules（上）— 通用规则体系

项目内容
前置条件第 3 课
本课收获掌握 10 个通用规则文件的内容，理解分层继承模型

知识点

  1. 分层继承模型

    rules/common/          ← 通用层（所有语言共享）
    ↓ 继承 + 可覆盖
rules/<language>/      ← 语言层（12 种）
    ↓ 继承 + 可覆盖
.claude/rules/         ← 项目层

    优先级：项目 > 语言 > 通用（类似 CSS 特异性）

  2. 10 个通用规则全景

    文件核心要点
    coding-style.md不可变性（CRITICAL）、小文件（200-400 行）、错误处理
    testing.md80% 覆盖率、TDD（RED→GREEN→IMPROVE）、单元/集成/E2E
    security.md无硬编码密钥、参数化查询、OWASP Top 10
    git-workflow.mdConventional Commits（feat/fix/refactor/docs/test/chore）
    performance.md模型分层（Haiku/Sonnet/Opus）、上下文窗口
    patterns.mdRepository 模式、API 响应信封格式
    agents.md何时委派、并行执行
    hooks.mdHook 类型、TodoWrite 用法
    development-workflow.mdPlan → TDD → Review → Commit
    code-review.md审查标准和质量门

必读 rules/common/coding-style.md、rules/common/testing.md、rules/common/security.md

练习 阅读全部 10 个通用规则文件，用一张表格总结每个文件的核心要点

第 5 课：Rules（下）— 语言特定规则与实战

项目内容
前置条件第 4 课
本课收获能对比通用与语言规则的差异，能为新语言草拟规则

知识点

  1. 语言规则如何继承通用规则

    • 每个文件以 > This file extends common/xxx.md 开头
    • 可以覆盖通用规则中不适合该语言的部分

  2. 典型覆盖案例

    • Go：指针接收器可变性覆盖通用不可变性
    • Rust：所有权系统替代了垃圾回收相关规则
    • Python：PEP 8 覆盖通用命名规范

  3. 12 种语言的规则结构 每种语言通常有 5 个文件：coding-style.md、testing.md、patterns.md、hooks.md、security.md

  4. ⚠️ 误区提醒

    • 安装时不能用 /* 扁平化复制（同名文件会互相覆盖）
    • 必须保持 common/ 和 <language>/ 的目录结构

必读 rules/README.md（安装说明）、你的主力语言目录

练习 对比 rules/common/coding-style.md 与 rules/golang/coding-style.md，写出 3 个覆盖点；为 Ruby 草拟一份 coding-style.md

第 6 课：Agents（上）— 文件格式与 Frontmatter

项目内容
前置条件第 5 课（理解 Rules，因为 Agent 遵循 Rules）
本课收获掌握 Agent 的四个 frontmatter 字段及其设计要点

知识点

  1. Agent 文件结构

    ---
name: code-reviewer
description: 代码质量审查    # 决定何时被自动触发（极关键）
tools: [Read, Grep, Glob]  # 能力边界（最小权限原则）
model: sonnet              # 成本/能力权衡
---
# Markdown 正文 = 系统提示词

  2. 四个字段的设计决策

    字段关键常见错误
    name简短语义明确太长或太模糊
    description越精确触发越准写得太泛导致误触发
    tools只给需要的给太多工具导致行为不可控
    model按任务复杂度选所有 Agent 都用 opus（浪费）

  3. Agent 分类全景（47 个）

    类别数量代表
    核心流程3planner, architect, tdd-guide
    代码质量3code-reviewer, security-reviewer, refactor-cleaner
    语言审查7+python-reviewer, go-reviewer, rust-reviewer 等
    构建修复7+build-error-resolver 及各语言变体
    测试运维2e2e-runner, doc-updater
    特殊领域5+database-reviewer, loop-operator 等

必读 AGENTS.md（完整目录）、agents/code-reviewer.md（先只看 frontmatter 部分）

练习 浏览 10 个不同类型的 Agent，对比它们的 tools 和 model 选择差异

第 7 课：Agents（下）— 系统提示词设计

项目内容
前置条件第 6 课
本课收获掌握提示词四段式结构，能创建一个自定义 Agent

知识点

  1. 系统提示词四段式结构

    • 职责声明：你是什么角色，负责什么
    • 工作流程：分步骤的操作指南
    • 输出格式：确保结果结构化可预测
    • 约束条件：不能做什么、边界在哪里

  2. 设计技巧

    • 约束比指令更重要 — 说清"不要做什么"比"要做什么"更能防止失控
    • 输出格式要具体 — 模糊的"给出建议"不如"按 CRITICAL/HIGH/MEDIUM 分级输出"
    • 工作流程要可执行 — 每一步都应该对应一个具体动作

  3. 经典案例深度分析

    • code-reviewer.md：只读不写（tools 无 Write/Edit），审查输出按严重度分级
    • planner.md：只读和搜索（深度理解代码再规划），不直接修改代码
    • tdd-guide.md：有完整读写权限（需要写测试和实现代码）

必读 agents/code-reviewer.md（全文精读）、agents/planner.md、agents/tdd-guide.md

练习 创建一个"依赖审查 Agent"：检查项目依赖的安全性和版本时效性。要求四段式结构完整。

第 8 课：Skills（上）— 结构与本质

项目内容
前置条件第 7 课（理解 Agent，因为 Skill 指导 Agent）
本课收获掌握 Skill 标准结构，理解 Skill 与传统文档的本质差异

知识点

  1. Skill 的本质 — 给 AI 执行的知识

    维度传统文档ECC Skill
    受众人类AI 代理
    风格描述性叙事结构化指令
    触发人主动查阅系统自动匹配
    效果需理解再执行直接遵循执行

  2. 标准四段式结构

    ---
name: skill-name
description: 触发描述
---
# Skill Name
## When to Use     ← 何时触发
## How It Works    ← 工作原理
## Examples        ← 具体示例
## Anti-Patterns   ← 常见错误

  3. description 字段的极端重要性

    • 这是 Skill 被自动发现和加载的唯一依据
    • 写得太泛 → 误触发；写得太窄 → 该触发时不触发

  4. 放置策略

    • skills/（仓库内）：精选的、经过审查的
    • ~/.claude/skills/（用户目录）：生成/导入的
    • ⚠️ 两者不自动同步

必读 skills/tdd-workflow/SKILL.md、skills/coding-standards/SKILL.md

练习 阅读 3 个不同领域的 Skill，提取它们的共性结构模板

第 9 课：Skills（下）— 编程 Skill 地图与编写实战

项目内容
前置条件第 8 课
本课收获了解 85 个编程 Skill 的分布地图，能编写一个 Skill

知识点

  1. 编程/架构 Skill 分布地图

    领域数量代表 Skill
    核心开发10coding-standards, tdd-workflow, api-design, hexagonal-architecture
    Python 生态2python-patterns, python-testing
    Go 生态2golang-patterns, golang-testing
    Java/Kotlin 生态8java-coding-standards, kotlin-patterns, springboot-patterns, jpa-patterns
    PHP/Laravel 生态4laravel-patterns, laravel-tdd, laravel-security, laravel-verification
    C++/Rust 生态4cpp-coding-standards, cpp-testing, rust-patterns, rust-testing
    Swift/Dart 移动端6swiftui-patterns, swift-concurrency-6-2, dart-flutter-patterns
    Django 生态4django-patterns, django-tdd, django-security, django-verification
    Spring Boot 生态4springboot-patterns, springboot-tdd, springboot-security, springboot-verification
    数据库4postgres-patterns, clickhouse-io, database-migrations, jpa-patterns
    前端4frontend-patterns, frontend-design, e2e-testing, nuxt4-patterns
    测试验证7eval-harness, verification-loop, benchmark, browser-qa
    DevOps4docker-patterns, deployment-patterns, devops-workflow, github-ops
    AI/Agent11agent-harness-construction, cost-aware-llm-pipeline, claude-api

  2. Skill 质量清单（CONTRIBUTING.md）

    • 聚焦单一领域
    • description 精确可触发
    • 有真实示例和反模式
    • 少于 500 行
    • 经过实际测试

必读 你的主力技术栈对应的 2-3 个 Skill

练习 为你团队的编码规范或常用架构模式编写一个 Skill 草稿（四段式结构）

第 10 课：Hooks — 事件驱动自动化

项目内容
前置条件第 8 课（理解 Skill 和 Agent 的协作，Hook 在此基础上介入）
本课收获掌握 7 种 Hook 事件，能配置自定义 Hook

知识点

  1. 7 种 Hook 事件

    事件时机能否拦截典型用途
    PreToolUse工具执行前能（exit 1）阻止危险操作
    PostToolUse工具执行后不能自动格式化
    StopClaude 响应结束—会话总结
    SessionStart会话开始—恢复上下文
    SessionEnd会话结束—保存状态
    PreCompact上下文压缩前—保存关键信息
    UserPromptSubmit用户提交消息—消息预处理

  2. ⚠️ 关键误区：只有 PreToolUse 能拦截

    • PreToolUse：exit 1 → 工具不会执行
    • PostToolUse：工具已执行完，exit 1 没有拦截效果
    • 很多人在 PostToolUse 中写拦截逻辑 → 无效

  3. 配置格式（hooks.json）

    {
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write",
      "hooks": [{"type": "command", "command": "node scripts/hooks/auto-format.js"}]
    }]
  }
}

  4. 设计原则

    • Hook 脚本必须 exit 0（不阻塞正常工作流）
    • PreToolUse 保持 < 200ms（不做网络调用）
    • 错误输出到 stderr，带 [HookName] 前缀
    • Profile 管理：ECC_HOOK_PROFILE=minimal|standard|strict

  5. ECC 内置 Hook 清单 Dev server blocker、Git push reminder、Pre-commit check、Prettier formatting、TypeScript checking、console.log warning、Session summary、Pattern extraction、Desktop notify

必读 hooks/hooks.json（全部配置）、hooks/README.md（食谱）

练习 编写一个 PostToolUse Hook：编辑 .py 文件后自动运行 black 格式化

第 11 课：Scripts — Hook 的底层实现

项目内容
前置条件第 10 课（Hook 配置已掌握，现在深入实现）
本课收获能编写符合规范的 Hook 脚本并编写测试

知识点

  1. 目录结构

    scripts/
├── lib/          # 共享库：utils.js, package-manager.js, git-utils.js
├── hooks/        # Hook 实现：run-with-flags.js, session-start.js, ...
├── ci/           # CI/CD 工具
└── ecc.js        # 主 CLI 入口

  2. 代码约定

    • CommonJS only（require/module.exports）
    • const 优先，禁止 var
    • Hook 脚本 < 200 行

  3. Hook 脚本标准模式

    module.exports.run = function(rawInput) {
  try {
    const data = JSON.parse(rawInput);
    // 处理逻辑
  } catch (e) {
    process.stderr.write(`[HookName] ${e.message}\n`);
  }
  process.exit(0);
};

  4. run-with-flags.js 的作用

    • 统一管理 Hook 启用/禁用
    • 支持 ECC_HOOK_PROFILE 和 ECC_DISABLED_HOOKS
    • 解析 stdin JSON → 调用具体脚本的 run() 函数

  5. 测试规范

    • tests/ 镜像 scripts/ 结构
    • 运行：node tests/run-all.js
    • 新脚本必须有对应测试

必读 scripts/hooks/run-with-flags.js、scripts/lib/utils.js、tests/run-all.js

练习 运行测试；为 utils.js 中的一个函数编写额外测试用例

第三阶段：工作流实战（第 12-16 课）

目标：将独立组件组合为完整工作流，在真实场景中应用。

第 12 课：调用链追踪 — 从 Command 到执行

项目内容
前置条件第 4-11 课（所有组件已掌握）
本课收获能追踪任意命令的完整调用链，理解组件如何串联

知识点

  1. Command 的定位

    • "legacy slash-entry shim" — 向后兼容的入口壳
    • 正在向 Skill 迁移，Skill 是未来主力

  2. 调用链追踪实例

    /tdd → commands/tdd.md → skills/tdd-workflow/ → agents/tdd-guide.md → rules/common/testing.md
/plan → commands/plan.md → skills/plan/ → agents/planner.md → rules/common/development-workflow.md
/code-review → commands/code-review.md → agents/code-reviewer.md → rules/common/code-review.md

  3. 命令分类速览（79 个）

    类别命令场景
    核心工作流/plan /tdd /code-review /verify日常开发
    构建修复/build-fix /go-build /cpp-build编译错误
    语言审查/python-review /go-review /rust-review代码审查
    多代理/multi-plan /multi-execute /orchestrate多模型协作
    会话管理/save-session /resume-session /checkpoint会话持久化
    学习/learn /evolve /skill-create模式提取

  4. "必记 5 命令" /plan、/tdd、/code-review、/verify、/learn

必读 COMMANDS-QUICK-REF.md、commands/tdd.md、commands/plan.md

练习 追踪 5 个不同类别的命令调用链，画出流程图

第 13 课：TDD 全流程 — RED-GREEN-IMPROVE

项目内容
前置条件第 12 课（理解调用链后才能理解组件如何协作）
本课收获完整体验一次 TDD 循环，理解 RED 阶段为什么必须先失败

知识点

  1. 四阶段开发流

    Plan（planner agent）→ TDD（tdd-guide agent）→ Review（code-reviewer agent）→ Commit

  2. TDD 严格循环

    • RED：写测试 → 运行 → 必须失败（不失败说明测试没写对）
    • GREEN：写最少代码让测试通过（不多不少）
    • IMPROVE：重构，保持测试通过
    • VERIFY：确认覆盖率 ≥ 80%

  3. 为什么 RED 阶段测试必须先失败？

    • 验证测试本身是有效的（如果没写实现就通过 → 测试没在测任何东西）
    • 确认测试和实现之间有因果关系

  4. 相关 Skill

    • skills/tdd-workflow/SKILL.md
    • 语言特定：skills/python-testing/、skills/golang-testing/、skills/rust-testing/ 等

必读 rules/common/development-workflow.md、skills/tdd-workflow/SKILL.md

练习 写一个字符串工具函数（如 slugify），严格按 RED → GREEN → IMPROVE 顺序操作

第 14 课：验证循环 — 从代码到可提交

项目内容
前置条件第 13 课（TDD 产出代码后需要验证）
本课收获一次完整通过验证循环的代码提交

知识点

  1. 验证循环四步

    测试通过 → Lint 通过 → 类型检查通过 → 安全检查通过 → 可以提交

    任何一步失败 → 修复 → 从头重跑

  2. 每步防范什么

    步骤防范工具
    测试逻辑错误jest/pytest/go test
    Lint风格问题eslint/pylint/golint
    类型检查类型安全tsc/mypy/go vet
    安全检查密钥泄露、注入security-reviewer

  3. Conventional Commits 格式

    <type>: <description>

    type: feat, fix, refactor, docs, test, chore, perf, ci

  4. 相关 Skill

    • skills/verification-loop/SKILL.md
    • skills/git-workflow/SKILL.md

必读 skills/verification-loop/SKILL.md、rules/common/git-workflow.md

练习 用第 13 课写的代码，完整跑一遍验证循环并提交

第 15 课：会话管理 — 上下文、模型与持久化

项目内容
前置条件第 10-11 课（Hook/Script，会话管理依赖它们）
本课收获能根据任务选模型，能在三种动态上下文间切换

知识点

  1. 上下文窗口管理

    • 安全区（0-80%）：正常工作
    • 危险区（80-100%）：只做单文件编辑
    • Strategic Compact：在逻辑断点手动压缩（优于自动压缩）

  2. 模型分层选择

    模型场景成本
    Haiku 4.5轻量 Agent、高频调用最低
    Sonnet 4.6主力开发中等
    Opus 4.5架构决策、深度推理最高

  3. ⚠️ MCP 陷阱

    • 启用超过 10 个 MCP 会将上下文从 200K 压缩到 70K
    • 优先用 CLI + Skills 替代 MCP

  4. 会话持久化三件套

    • SessionEnd Hook → 保存
    • SessionStart Hook → 恢复
    • PreCompact Hook → 压缩前保存

  5. 动态上下文三模式

    claude --system-prompt "$(cat contexts/dev.md)"       # 代码优先
claude --system-prompt "$(cat contexts/review.md)"    # 审查模式
claude --system-prompt "$(cat contexts/research.md)"  # 先理解再行动

必读 the-longform-guide.md（上下文章节）、rules/common/performance.md、contexts/ 三个文件

练习 用三种模式分别处理同一个代码问题，对比输出差异

第 16 课：多代理编排 — 并行、视角与隔离

项目内容
前置条件第 15 课（理解上下文隔离，这是并行 Agent 的基础）
本课收获能设计多 Agent 协作方案，理解子代理上下文问题

知识点

  1. 并行 vs 顺序

    • 并行：任务无依赖（安全分析 ‖ 性能审查 ‖ 类型检查）
    • 顺序：下游依赖上游（规划 → 实现 → 审查）

  2. 编排模式

    模式命令场景
    单 Agent/code-review简单任务
    并行 Agent/multi-execute独立任务
    多模型/multi-plan方案对比
    级联/orchestrate有依赖

  3. ⚠️ 子代理上下文丢失问题

    • 主代理有完整上下文，子代理没有
    • 必须用迭代检索模式（追问、最多 3 次循环）
    • 常见失败：子代理返回不完整结果，主代理盲目接受

  4. Git Worktree 隔离

    • 每个 Agent 在独立 worktree 中工作
    • 推荐最大 3-4 个并行任务

  5. 多视角分析 同一段代码交给：事实审查员、高级工程师、安全专家、一致性审查员、冗余检查员

必读 rules/common/agents.md、the-longform-guide.md（并行化章节）

练习 设计一个需要 3 个 Agent 并行的场景，画出编排图并说明为什么不能顺序执行

第四阶段：语言与框架（第 17-22 课）

目标：针对具体技术栈深度使用 ECC 的语言 Skill 和框架 Skill。 注：本阶段每节课覆盖一个技术领域，学员可根据自身技术栈选择重点。

第 17 课：后端语言 — Python / Go / Rust / Java

项目内容
前置条件第 9 课（Skill 编写）、第 13 课（TDD 流程）
本课收获为你的主力后端语言配置完整的 ECC 规则和 Skill

知识点

  1. 各语言 Skill 对照

    语言Patterns SkillTesting Skill语言审查 Agent构建修复 Agent
    Pythonpython-patternspython-testingpython-reviewerbuild-error-resolver
    Gogolang-patternsgolang-testinggo-reviewergo-build-resolver
    Rustrust-patternsrust-testingrust-reviewerrust-build-resolver
    Javajava-coding-standardsspringboot-tddjava-reviewerjava-build-resolver
    Kotlinkotlin-patternskotlin-testingkotlin-reviewerkotlin-build-resolver
    C++cpp-coding-standardscpp-testingcpp-reviewercpp-build-resolver
    Perlperl-patternsperl-testing——
    C#dotnet-patternscsharp-testing——

  2. 语言 Skill 的共性结构

    • 命名规范和惯用法
    • 错误处理模式
    • 并发/异步模式
    • 测试框架和覆盖率工具

  3. 语言特定的 TDD 命令 /go-test、/kotlin-test、/rust-test、/cpp-test

必读 你主力语言的 patterns Skill 和 testing Skill

练习 用你的主力语言执行一次 /tdd + 语言审查命令，观察语言 Skill 如何影响输出

第 18 课：前端框架 — React / Next.js / Vue / Nuxt

项目内容
前置条件第 17 课
本课收获为你的前端框架配置 ECC，理解前后端 Skill 的协作

知识点

  1. 前端相关 Skill

    Skill覆盖内容
    frontend-patternsReact, Next.js, 状态管理, 性能优化
    frontend-design高质量 UI 设计模式
    e2e-testingPlaywright, Page Object Model, CI/CD 集成
    nuxt4-patternsNuxt 4 SSR, 水合安全, 路由规则
    nextjs-turbopackNext.js 16+, Turbopack 增量打包
    browser-qa自动化视觉测试

  2. E2E 测试 Skill 深入

    • Playwright 配置和 Page Object Model
    • 截图/视频/trace 产物管理
    • Flaky test 隔离策略

  3. 前后端 Skill 协作场景

    • 前端用 frontend-patterns + e2e-testing
    • API 层用 api-design + backend-patterns
    • 数据层用 postgres-patterns + database-migrations

必读 skills/frontend-patterns/SKILL.md、skills/e2e-testing/SKILL.md

练习 为一个前后端分离项目规划 Skill 组合方案

第 19 课：移动端开发 — Swift / SwiftUI / Dart / Flutter

项目内容
前置条件第 17 课
本课收获了解移动端 Skill 体系，理解 Swift 并发和 Flutter 架构模式

知识点

  1. Swift 生态 Skill

    Skill重点
    swiftui-patterns@Observable 状态管理, 视图组合, 导航
    swift-concurrency-6-2Swift 6.2 单线程默认, @concurrent 后台调度
    swift-actor-persistenceActor 线程安全持久化
    swift-protocol-di-testing协议依赖注入, 可测试性
    foundation-models-on-device设备端 LLM, @Generable

  2. Flutter/Dart 生态 Skill

    Skill重点
    dart-flutter-patterns空安全, 状态管理, Widget 架构, GoRouter
    flutter-dart-code-reviewWidget 最佳实践, 性能检查
    compose-multiplatform-patterns跨平台共享 UI
    android-clean-architectureClean Architecture, KMP 模块

必读 你的移动端技术栈对应的 Skill（选 1-2 个深读）

练习 选一个移动端 Skill，分析它的 Anti-Patterns 部分，写出 3 个你之前可能犯过的错误

第 20 课：数据库模式 — 设计、迁移与优化

项目内容
前置条件第 17 课
本课收获理解 ECC 的数据库 Skill 体系，体验一次 Migration 辅助

知识点

  1. 数据库相关 Skill

    Skill覆盖
    postgres-patterns查询优化, Schema 设计, 索引, Row Level Security, 连接池
    clickhouse-io分析型查询, 表引擎, 数据摄取, 性能优化
    database-migrations零停机迁移, 回滚策略, 跨 ORM 最佳实践
    jpa-patternsJPA/Hibernate 实体设计, 关系, N+1 优化
    kotlin-exposed-patternsExposed DSL 查询, 事务, HikariCP

  2. Migration 最佳实践（database-migrations Skill）

    • 每次迁移只做一件事
    • 必须有回滚方案
    • 零停机：先加列 → 双写 → 迁移数据 → 切读 → 删旧列
    • 支持 Prisma, Drizzle, Django, TypeORM, golang-migrate

  3. database-reviewer Agent

    • PostgreSQL/Supabase 专用
    • 查询优化建议、索引推荐、安全审查

必读 skills/database-migrations/SKILL.md、skills/postgres-patterns/SKILL.md

练习 为一个表结构变更（如添加索引）设计零停机迁移方案，参考 database-migrations Skill

第 21 课：API 设计 — RESTful 模式与规范

项目内容
前置条件第 17 课（后端语言）、第 20 课（数据库）
本课收获一份符合 ECC api-design Skill 规范的 API 设计方案

知识点

  1. api-design Skill 核心内容

    • 资源命名（复数名词、嵌套路径）
    • HTTP 状态码选择
    • 分页和过滤模式
    • 错误响应格式
    • 版本控制策略
    • 速率限制

  2. 框架专用 API Skill

    框架Skill
    Djangodjango-patterns（DRF 部分）
    Spring Bootspringboot-patterns（REST 层）
    Laravellaravel-patterns（路由和控制器）
    NestJSnestjs-patterns（控制器和 DTO）
    Ktorkotlin-ktor-patterns（路由 DSL）

  3. 后端四层架构（backend-patterns Skill）

    Controller → Service → Repository → Database

必读 skills/api-design/SKILL.md、skills/backend-patterns/SKILL.md

练习 为一个简单的资源（如 Task）设计 RESTful API，覆盖 CRUD + 分页 + 错误处理

第 22 课：软件架构 — 六边形、微服务与决策记录

项目内容
前置条件第 21 课（API 设计是架构的外层接口）
本课收获理解 ECC 支持的架构模式，能写一个 ADR

知识点

  1. 架构相关 Skill

    Skill重点
    hexagonal-architecturePorts & Adapters, 领域边界, 依赖反转
    architecture-decision-recordsADR 格式, 决策追踪
    codebase-onboarding架构地图, 入口点, 依赖图

  2. 六边形架构（Ports & Adapters）

    外部世界 → Port（接口）→ Application（业务逻辑）→ Port → 外部世界
                                 ↑
                            Domain Model
    • Port：定义边界（如 Repository 接口）
    • Adapter：实现边界（如 PostgreSQL 实现）
    • 核心价值：业务逻辑不依赖基础设施

  3. ADR（Architecture Decision Record）

    # ADR-001: 选择 PostgreSQL 作为主数据库
## 状态：已采纳
## 上下文：需要一个支持 JSONB 和全文搜索的关系型数据库
## 决策：使用 PostgreSQL 14+
## 后果：需要团队学习 PL/pgSQL

  4. architect Agent

    • 系统设计、可扩展性、技术决策
    • 使用 opus 模型（需要深度推理）

必读 skills/hexagonal-architecture/SKILL.md、skills/architecture-decision-records/SKILL.md

练习 为你当前项目的一个技术决策写一个 ADR

第五阶段：进阶能力（第 23-27 课）

目标：处理安全、性能、学习和 AI 工程等高级主题。

第 23 课：安全（上）— AI 代理特有的威胁

项目内容
前置条件第 4 课（Rules 中的安全规则）、第 10 课（Hook 安全）
本课收获能列出 5 个 AI 代理特有的攻击向量

知识点

  1. 传统攻击面 vs AI 代理额外攻击面

    传统：SQL 注入、XSS、CSRF、认证绕过、密钥泄露
AI 额外：Prompt 注入、MCP 投毒、记忆污染、隐藏 Unicode、代码注释/PR 中的指令

  2. 已知 CVE

    • CVE-2025-59536：MCP 同意滥用
    • CVE-2026-21852：间接 Prompt 注入

  3. 攻击载体深度分析

    • 截图/附件中的隐藏指令
    • GitHub PR 描述中的 Prompt 注入
    • MCP 服务器返回的恶意内容
    • 观察文件（记忆）被篡改

必读 the-security-guide.md（完整安全指南）

练习 阅读安全指南，列出 5 个你之前不知道的攻击向量，思考你的项目是否受影响

第 24 课：安全（下）— 防御机制与实战

项目内容
前置条件第 23 课
本课收获完成一次 AgentShield 扫描，编写一个安全 Hook

知识点

  1. ECC 安全检查清单（8 项）

    • 无硬编码密钥
    • 所有用户输入已验证
    • SQL 查询参数化
    • HTML 输出已转义
    • CSRF 保护已启用
    • 认证/授权已验证
    • 所有端点有速率限制
    • 错误消息不泄露敏感信息

  2. AgentShield

    npx ecc-agentshield scan
# 检查：CLAUDE.md 注入、settings.json 风险、MCP 配置、Hook 安全

  3. 沙箱化策略

    • 身份隔离：AI 用独立账号
    • 环境隔离：Docker/devcontainer
    • 网络隔离：限制出站
    • 文件隔离：限制路径

  4. 安全响应协议 发现 → 停止 → security-reviewer → 修复 → 轮换密钥 → 全库排查

  5. 框架特定安全 Skill

    • django-security、springboot-security、laravel-security、perl-security

必读 rules/common/security.md、agents/security-reviewer.md

练习 运行 /security-scan；编写一个 PreToolUse Hook 拦截包含 rm -rf / 的 Bash 命令

第 25 课：持续学习 — Instinct 提取与演化

项目内容
前置条件第 9 课（Skill 编写）、第 10 课（Hook，学习系统依赖 Stop Hook）
本课收获从一次会话中提取出一个 Instinct

知识点

  1. Instinct 模型（持续学习 v2）

    会话观察 → 模式提取（Instinct）→ 置信度评分
    低 → 丢弃 | 中 → 继续观察 | 高 → 保存
        ↓
    聚合 → 演化为 Skill → 进一步演化为 Agent

  2. ⚠️ 记忆不会自动保存 三件套：Stop Hook（提取）+ PreCompact Hook（压缩前保存）+ 持续学习 Skill（结构化存储）

  3. 学习发生在 Stop Hook 中

    • 不用 UserPromptSubmit（避免延迟）
    • Stop 时不阻塞用户，适合做模式提取

  4. 相关命令 /learn → /instinct-status → /instinct-export → /instinct-import → /evolve

必读 skills/continuous-learning-v2/SKILL.md、skills/continuous-learning/SKILL.md

练习 执行 /learn 后查看 /instinct-status，分析提取了什么模式

第 26 课：Eval 驱动开发 — 衡量 AI 行为

项目内容
前置条件第 25 课（持续学习提供了需要被评估的模式）
本课收获设计并运行一次 Eval

知识点

  1. Eval 驱动开发（EDD）循环

    定义评估标准 → 运行 Eval → 分析 pass@k → 调整配置 → 重跑 → 达标 → 部署

  2. pass@k 指标

    • pass@1：单次通过率（衡量可靠性 — 生产环境更看重这个）
    • pass@5：5 次中至少 1 次通过（衡量极限能力）
    • pass^k：所有 k 次都通过（最严格）

  3. Eval 类型

    • Checkpoint-based：在关键节点检查
    • Continuous：持续监控
    • Agent-vs-agent：agent-eval Skill 的头对头比较

  4. 相关 Skill 和命令

    • skills/eval-harness/SKILL.md
    • skills/benchmark/SKILL.md
    • skills/agent-eval/SKILL.md
    • 命令：/eval

必读 skills/eval-harness/SKILL.md、the-longform-guide.md（Eval 章节）

练习 为一个 Agent 设计 3 个评估用例，定义 pass/fail 标准

第 27 课：Agent 工程与 LLM 成本优化

项目内容
前置条件第 7 课（Agent 设计）、第 15 课（模型选择）、第 26 课（Eval）
本课收获理解 Agent Harness 构建原理和 LLM 成本优化策略

知识点

  1. Agent Harness 构建（agent-harness-construction Skill）

    • Action space 设计（工具定义和边界）
    • Observation 格式化（AI 看到什么信息）
    • Reward signal 设计（如何判断 Agent 做得好不好）

  2. LLM 成本优化（cost-aware-llm-pipeline Skill）

    • 按任务复杂度路由模型（简单 → Haiku，复杂 → Opus）
    • Budget tracking（设置成本上限）
    • Retry logic（失败重试策略）
    • Prompt caching（缓存常用 prompt）

  3. AI 相关 Skill 全景

    Skill重点
    claude-apiAnthropic SDK, Messages API, streaming, tool use
    agentic-engineeringEval-first, 分解, 成本路由
    ai-first-engineeringAI Agent 生成实现的工程模型
    autonomous-loops自主循环架构和质量门
    agent-introspection-debuggingAgent 自我调试工作流

  4. 自主循环的质量门

    • 每轮循环必须有退出条件
    • 成本上限作为硬性限制
    • 输出需要验证（不盲目信任）

必读 skills/agent-harness-construction/SKILL.md、skills/cost-aware-llm-pipeline/SKILL.md

练习 为一个多 Agent 工作流设计成本预算方案：哪些 Agent 用 Haiku，哪些用 Sonnet

第六阶段：综合与创造（第 28-30 课）

目标：能独立设计完整的 ECC 配置方案并贡献社区。

第 28 课：跨平台适配与插件机制

项目内容
前置条件第 11 课（Scripts）、第 14-16 课（工作流）
本课收获理解 Plugin Manifest 格式，能选择合适的安装 Profile

知识点

  1. 支持的 Harness

    Harness配置支持程度
    Claude Code.claude-plugin/plugin.json完整
    Codex.codex-plugin/plugin.json完整
    CursorHook adapter适配
    OpenCodePlugin system插件
    GeminiGEMINI.md有限

  2. Plugin Manifest 格式

    • agents、skills、commands、hooks、rules 字段
    • 版本管理和依赖声明

  3. 安装 Profile core → developer → security → research → full ⚠️ full 在低配机器可能有性能问题

  4. JSON Schema 验证（schemas/ 目录）

    • hooks.schema.json、plugin.schema.json、install-profiles.schema.json 等

必读 .claude-plugin/plugin.json、manifests/、schemas/

练习 对比 .claude-plugin/ 和 .codex-plugin/，列出 3 个差异

第 29 课：ECC 2.0 — Rust 控制面板与未来方向

项目内容
前置条件第 28 课
本课收获体验 ECC 2.0 Dashboard，理解控制面板解决的问题

知识点

  1. ECC 2.0 架构

    ecc2/src/
├── main.rs          # CLI 入口
├── dashboard.rs     # Terminal UI 仪表盘
├── session.rs       # 会话管理
├── daemon.rs        # 后台守护进程
└── store.rs         # SQLite 持久化

  2. 核心命令

    命令说明
    ecc2 dashboardTerminal UI 仪表盘
    ecc2 start --task "..."启动会话
    ecc2 sessions列出会话
    ecc2 stop/resume <id>停止/恢复
    ecc2 daemon后台运行

  3. ECC 2.0 解决的问题

    • 多会话管理（Node.js 版本只能单会话）
    • 可视化仪表盘（不再是纯命令行）
    • 风险评分（量化操作风险）
    • 性能提升（Rust vs Node.js）

  4. 当前状态

    • Alpha 质量，可实验性使用
    • 可用 cargo build && cargo test 本地构建

必读 ecc2/ 目录结构、ecc2/Cargo.toml

练习 如果环境允许，构建并运行 ecc2 dashboard

第 30 课：综合实战 — 毕业项目

项目内容
前置条件全部 29 课
本课收获一个为真实项目设计的完整 ECC 配置方案

毕业项目：为真实项目设计完整 ECC 方案

分 8 个阶段，每阶段对应之前学过的知识：

阶段任务对应课次
A. 基础配置选 Profile、写 CLAUDE.md、配语言规则第 3-5 课
B. Agent/Skill 选型根据技术栈选择 Agent 和 Skill 组合第 6-9 课
C. Hook 配置配 hooks.json、选 Hook Profile第 10-11 课
D. 全流程验证/plan → /tdd → /code-review → /verify第 12-14 课
E. 上下文优化模型选择、MCP 策略、Dynamic Context第 15 课
F. 多代理编排设计并行/顺序 Agent 方案第 16 课
G. 安全加固AgentShield 扫描、安全 Hook第 23-24 课
H. 自定义组件创建 1 个 Agent + 1 个 Skill + 1 个 Hook第 7、9、10 课

参考模板（examples/ 目录）

模板技术栈
saas-nextjs-CLAUDE.mdNext.js SaaS
django-api-CLAUDE.mdDjango REST API
go-microservice-CLAUDE.mdGo 微服务
laravel-api-CLAUDE.mdLaravel API
rust-api-CLAUDE.mdRust API

交付物清单

  • 项目 CLAUDE.md 文件
  • hooks.json 配置
  • 1 个自定义 Agent
  • 1 个自定义 Skill
  • 1 个自定义 Hook
  • 一份配置方案说明文档（为什么做这些选择）

可选加分项

  • 向 ECC 仓库提交 PR 贡献组件（参考 CONTRIBUTING.md）
  • 运行 /harness-audit 并根据建议优化配置

附录

A. 课程总览表

课次阶段主题核心收获
1认知建立设计哲学五大原则的理解笔记
2认知建立架构全景手绘组件关系图
3认知建立上手体验安装完成 + 目录浏览
4组件精讲Rules 通用10 个通用规则要点总结
5组件精讲Rules 语言为新语言草拟的 Rule
6组件精讲Agent 格式理解四个 frontmatter 字段
7组件精讲Agent 设计一个自定义 Agent
8组件精讲Skill 结构Skill 与文档的区别
9组件精讲Skill 编写一个自定义 Skill
10组件精讲Hook 事件一个自定义 Hook 配置
11组件精讲Script 底层一个可运行的 Hook 脚本
12工作流实战调用链5 条命令调用链流程图
13工作流实战TDD 全流程一次 RED-GREEN-IMPROVE
14工作流实战验证循环一次通过验证循环的提交
15工作流实战会话管理三种动态上下文切换
16工作流实战多代理编排一个多 Agent 编排方案
17语言框架后端语言主力语言 ECC 配置
18语言框架前端框架前端 ECC 配置
19语言框架移动开发移动端 Skill 认知
20语言框架数据库一次 Migration 辅助
21语言框架API 设计一份 API 设计方案
22语言框架软件架构一个 ADR 文档
23进阶能力安全威胁5 个攻击向量清单
24进阶能力安全防御AgentShield 扫描 + 安全 Hook
25进阶能力持续学习一个 Instinct 提取
26进阶能力Eval 驱动一次 Eval 设计和运行
27进阶能力Agent 工程LLM 成本优化方案
28综合创造跨平台理解 Plugin Manifest
29综合创造ECC 2.0体验 Dashboard
30综合创造毕业项目完整 ECC 配置方案

B. 建议学习节奏

阶段课次建议用时学习方式
认知建立1-33 天以读为主，画图辅助
组件精讲4-118 天每课读 + 写一个组件
工作流实战12-165 天以实操为主
语言框架17-226 天按自身技术栈选重点
进阶能力23-275 天深度阅读 + 分析
综合创造28-303 天综合设计 + 毕业项目
合计30 课约 30 天

C. 编程 Skill 覆盖检查

领域覆盖课次涉及 Skill 数
核心开发第 4、8-9、13-14 课10
Python 生态第 17 课2
Go 生态第 17 课2
Java/Kotlin 生态第 17、21 课8
PHP/Laravel 生态第 17、21 课4
C++/Rust 生态第 17 课4
Swift/Dart 移动端第 19 课6
Django 生态第 17、21 课4
Spring Boot 生态第 17、21 课4
数据库第 20 课4
前端第 18 课4
测试验证第 13-14、26 课7
安全第 23-24 课2
DevOps第 14、28 课4
AI/Agent第 27 课11
架构第 22 课3
流程工具第 12、15、25 课8
合计85 个编程 Skill
avatar
文章
阅读
粉丝