CS146S《The Modern Software Developer》↗ 是斯坦福 2025 秋季的新课，讲师 Mihail Eric，每周一位重磅客座（Boris Cherny、Zach Lloyd、Isaac Evans、Tomas Reimers……）。我把官方作业仓库↗ 里 8 周的内容捋了一遍，沿途做了实操。这篇是把 8 周的笔记整理。

1. 课程的真正主题：开发者身份的位移

课程主页那句标语挺直白：

“Many AI coding courses only teach you how to write fast — this course draws the baseline for shipping: testable, auditable, defensible.”

如果只看周次表，会以为这是一门 “AI 工具使用大全”。但读完 8 周的材料和作业，更准确的描述是：

它在系统地训练你成为 Agent Manager。

不是 “学会用 ChatGPT 写代码”，是从写代码的人变成指导 Agent 写代码、并且对结果负责的人。Boris Cherny（Claude Code 创造者）那句话被反复引用：

“It’s not so much about deep work, it’s about how good I am at context switching and jumping across multiple different contexts very quickly.”

8 周内容可以归到三条主线：

1. Prompt → Context（Week 1 → 3）：从写一句好提示，到搭一整套信息环境
2. Coder → Agent Manager（Week 2 → 5）：从亲手写代码，到指导/编排多个 Agent
3. Speed → Defensible（Week 6 → 8）：从快速产出，到可审计、可防御、可上线

下面按这三条主线展开。

2. 主线一：Prompt → Context

Week 1：6 种基础提示技巧

第一周用 Ollama 跑本地模型，挨个练 6 种技巧：K-shot、Chain-of-Thought、Tool Calling、Self-consistency、RAG、Reflexion。每个技巧一份 Python 文件，调到 test 通过为止。

练完最大的体感不是 “我学了 6 种技巧”，而是：这些技巧不是平行选项，是一条进化链。

• K-shot 给的是模式
• CoT 给的是推理空间
• Tool Calling 让模型不再"猜"，而是"查"
• Self-consistency 用多次采样换稳定性
• RAG 把外部知识接进上下文
• Reflexion 让模型审视自己的输出再迭代

到 Reflexion 这一步，模型已经从 “回答机器” 变成了 “能自我修正的小循环”。这就是 Agent 的雏形。

Week 2：第一次让 AI 跑通需求闭环

作业是一个最小的 FastAPI + SQLite 的 Action Item Extractor：自然语言笔记 → 结构化 todo 列表。要求用 Cursor 的 Agentic Mode 完成 5 个 TODO：用 LLM 替换规则提取、加单元测试、重构、加新端点+前端按钮、生成 README。

我在自己的实践笔记里总结了一个 “本地需求执行 Agent” 的最小能力模型：

需求理解 → 代码上下文获取 → 方案规划 → 代码生成 → 验证执行 → 结果反馈
    ↑                                                      |
    └──────────── 失败时回溯修正 ←───────────────────────┘

每一步都对应 Week 1 学过的某个技巧。Agent 不是新发明，是把那些原子能力按这个 loop 串起来。

跑完一遍最大的感受：当前的 AI Agent 真正擅长的是 “边界清晰、可验证” 的任务。脚手架代码、单函数实现、happy path 测试、文档生成 —— 这些是优势。判断"什么不该改"、跨模块副作用推理、涉及取舍的深层重构 —— 这些还得人来。

Week 3：从 Prompt Engineering 到 Context Engineering

第三周是整门课信息密度最高的一周（另一个高密度周是 Week 6）。客座 Boris Cherny。核心命题是 Andrej Karpathy 的那句定义：

“Context engineering is the delicate art and science of filling the context window with just the right information for the next step.”

里面最让我重新审视自己工作方式的两条：

“Context is King” — 甚至是 intelligence 的前提。 课程里那句很狠：“Claude 已经足够聪明 — 智能不是瓶颈，上下文才是。当 AI Agent 失败时，本能反应是 blame the model，但几乎总是错的。表现不好的是围绕它构建的信息环境。”

Context Rot（上下文腐烂）。 模型性能会随输入长度显著下降，即使是简单任务。所以 /clear、/compact、分层记忆、CLAUDE.md 精简，这些不是洁癖，是性能策略。

Week 3 的作业是写一个自定义 MCP Server。我做的是 GitHub Issue 助手，3 个 Tools（search_issues / create_issue / get_issue_detail）+ 1 个 Resource（仓库元数据）+ 1 个 Prompt（bug report 模板），STDIO 接 Claude Desktop。

亲手实现完才真的理解：MCP 的三大原语（Tools / Resources / Prompts）不是抽象概念，对应的是 Agent 三种不同的"知道方式" —— 能做什么、能查什么、该怎么说。

Boris Cherny 还分享了一套日常工作流：每天发 20-30 个 PR，靠的是同时跑 5 个 Claude Code 实例 + 5-10 个 claude.ai/code，每个实例都从 Plan Mode 起步，CLAUDE.md 当团队共享记忆。最被反复强调的一句：

“给 Claude 一种验证自己工作的方式 —— 浏览器测试、测试套件、模拟器。验证能让最终结果质量提升 2-3 倍。其他一切（subagent、slash command、MCP 集成）都建立在这个基础之上。”

3. 主线二：Coder → Agent Manager

Week 4：作为 Agent Manager 的 Claude Code

Week 4 的核心句：

“The goal is to train you as an Agent Manager — not someone who writes code, but someone who directs Agents to write code.”

这周整理了 5 种 agentic 工作流模式：

• Sequential Flow：默认模式，70% 的日常工作
• Operator：层级式，中央编排者 + 专门 sub-agent
• Split-and-Merge：fan-out/fan-in，最多 ~10 路并行
• Agent Teams：协作式，可互相通信，跨独立会话协调
• Headless：CI/CD、Cron、Webhook 触发，无人值守

以及 12 个 “Agent Harness 模式”（持久指令、目录级指令、分层记忆、记忆卫生、上下文压缩、并行分支、检查点审查、选择性工具加载、定制工具、权限粒度、生命周期钩子、复合改进）。

最戳我的一句：

“问题不在于你的模型，而在于你的 harness（控制框架）。区分酷炫 demo 和生产级 AI 系统的不是智能，而是控制。”

作业是用 Slash Commands、CLAUDE.md、SubAgents 给一个 FastAPI starter app 加至少 2 个自动化。这周开始我的肌肉记忆变了：遇到任何重复的工作流，先想 “这能不能塞进 .claude/commands/"；遇到 Claude 反复犯的错，先想 “这条该不该写进 CLAUDE.md”。

复合工程（Compounding Engineering）这个词我喜欢：每次 AI 犯的错被记下来，都是永久的红利。

Week 5：终端不再是高级用户的玩具

Week 5 客座是 Warp CEO Zach Lloyd。Warp 的 2.0 把自己从 “更好的终端” 重新定义为 ADE（Agentic Development Environment）。

这周的对照表对我比较有用：

它们其实是叠加关系：Claude Code 可以跑在 Warp 里。多 Agent 并行的关键工具是 git worktree —— 每个 Agent 在独立的工作目录里干活，互不污染，结束再合分支。这个技巧后面我的实际工作里也用上了。

但 Warp 团队也很坦诚：并行不是免费的。每周省 6-7 小时是真的，但前提是你的认知带宽能管得住 5 个 tab —— 这才是真正的 bottleneck。

4. 主线三：Speed → Defensible

Week 6：Semgrep 与 AI 代码安全

第六周邀请了 Semgrep CEO Isaac Evans。这周的开场数据让我停下来想了一下：

Claude Code 在安全扫描实验中发现了 46 个真实漏洞（真阳性率 14%，误报率 86%）。

这不是说 Claude 不行，是说 AI 的安全直觉不可靠 —— 7 条告警里只有 1 条真正是漏洞。Semgrep 的价值在于把这个比例反过来：减少 80% 误报，同时提升 250% 真阳性。

Semgrep 三件套：

• Code (SAST)：第一方代码漏洞，跨文件分析
• Supply Chain (SCA)：依赖中的可达漏洞（reachability analysis 把不可达的 CVE 过滤掉，高/严重级别误报降 98%）
• Secrets：硬编码密钥，含语义分析 + 熵分析 + 验证

作业是用 semgrep ci --subdir week6 扫描一个故意藏漏洞的 FastAPI app，挑 3 个修。修法朴素但本质：参数化 SQL、限制 CORS、密钥转环境变量、依赖升级、加密算法换强的、DOM 写入消毒。

这周收的最朴素的一句话：“Secure Vibe Coding” 的目标是让快和安全统一，不是对立 —— 靠的是把扫描自动化进 CI，而不是事后人工补救。

Week 7：Graphite Diamond 与 AI 代码审查

第七周客座是 Graphite CPO Tomas Reimers。命题是：

“AI will never replace human code review. But every PR should be reviewed by AI + human together.”

AI 审查的优势：风格一致性、常见 Bug 模式、安全漏洞、代码重复、100% PR 覆盖、秒级响应。 人类审查的优势：架构判断、业务逻辑正确性、tradeoff 评估、创造性建议、团队上下文、UX 设计。

最佳模式是 “AI First, Human Second”：AI 第一层过滤掉机械问题，人类第二层聚焦高价值判断。Graphite 团队的另一个产品创新是 Stacked PRs —— 把一个大 PR 拆成多个小的、顺序的 PR，因为 AI 审查在小 PR 上表现明显更好。

作业很扎实：4 个独立任务，每个都按"创建分支 → 1-shot AI prompt 实现 → 手动逐行审 → 开 PR → 用 Graphite Diamond 跑 AI 审查 → 对比"的流程做一遍，最后写一份反思 —— 你的审查 vs Graphite 的审查，谁更好、什么时候更好。

这种 “对比反思” 的训练我觉得是这周最珍贵的部分。它不是教你信任 AI，是教你知道 AI 什么时候比你强、什么时候不如你。这种元认知，在 AI 时代比任何具体工具都重要。

Week 8：Bolt.new 与多栈快速构建

第八周转向 “原型到生产” 主题。客座是 Vercel AI Research 负责人。核心句：

“Rapid prototyping is just the starting point. Between demo and production lies a chasm.”

Bolt.new 用 StackBlitz 的 WebContainer 技术做到完全在浏览器里跑 Node.js，从提示词直出全栈应用。但它的能力曲线很陡：

作业要求用 3 种不同技术栈构建同一个应用，至少一个用 Bolt、至少一个用非 JS 语言。这设计很狡猾 —— 它在偷偷训练你两个能力：

1. 抽象思维：把业务从框架里抽出来，理解什么是本质、什么是实现细节
2. AI 工具评估：同一个需求，让 Bolt 在 Next.js / Django / Rails 上分别生成，质量差异巨大 —— 你必须培养出 “什么是生产就绪代码” 的直觉

5. 三条收回来能用的实操结论

读完 8 周的内容，做完几个作业，我自己往日常工作里搬的就是这三条：

5.1 Plan Mode 是免费的红利

Boris 那句 “在审查和批准书面计划之前，永远不要让 Claude 写代码” —— 这是 8 周里被引用最多的一条。我现在做任何超过 30 分钟的任务都先 shift+tab 进 Plan Mode，跟 Claude 来回讨论清楚再切到 auto-accept。返工率明显下降。

5.2 CLAUDE.md 是复合改进的载体

每次 Claude 犯错或者我发现一个不显然的项目约定，都往 CLAUDE.md 里加一条。这个习惯非常便宜、非常划算：每条加了之后就再也不用解释第二次。但要保持精简 —— 它每次会话都加载，吃上下文。

5.3 给 Agent 一种验证自己的方式

这是 Boris 的"最重要的洞见”。具体到我自己的实践：

• 写后端：让 Claude 跑测试，失败再改，不要"看起来对就提交"
• 写前端：起 dev server，让 Claude 用 Playwright 实际点一遍 golden path
• 写 API 集成：先有一个 curl 或 httpie 的最小复现脚本

这个习惯本身就是 Reflexion 模式（Week 1 学过的）的工程化版本 —— 把"自我审视"内置到工作流里。

6. 收尾：8 周完整弧线

Week 1:  如何与 AI 对话           → Prompt Engineering
Week 2:  AI 如何使用工具          → Coding Agents & MCP
Week 3:  如何为 AI 构建信息环境   → Context Engineering
Week 4:  如何管理 AI              → Agent Manager
Week 5:  AI 增强的终端            → AI Terminal
Week 6:  AI 代码安全              → Semgrep
Week 7:  AI 代码审查              → Graphite Diamond
Week 8:  AI 构建应用              → Bolt.new 多栈
(Week 9-10:  AI 运维 + 未来       → 课程后半段)

每一周都是下一周的基础。最后留下的不是一堆工具的使用说明，是一种新的工作姿态：

你不再是写代码的人，你是设计信息环境、指导 Agent、并且对最终交付物负责的人。

写代码的速度提升了 10 倍，但写错代码的速度也提升了 10 倍。课程划的那条 baseline —— 可测试、可审计、可防御 —— 不是束缚，是这个新姿态能站住脚的前提。

参考资源：

• 课程主页：themodernsoftware.dev↗
• 作业仓库：mihail911/modern-software-dev-assignments↗
• 中文版社区整理：ShouZhengAI/CS146S_CN↗
• Claude Code 最佳实践：anthropic.com/engineering/claude-code-best-practices↗
• 12 Agentic Harness Patterns：generativeprogrammer.com↗
• How Anthropic Teams Use Claude Code：claude.com/blog↗
• Andrej Karpathy on Context Engineering（X 原帖）
• Boris Cherny 工作流：howborisusesclaudecode.com↗

起因：在 GitHub 上看到一份 Windows 下给 Claude Code 加系统通知的 gist↗ ，PowerShell 写的，落地 Mac 用不了。索性重写一份 macOS 版，再顺手加一条 Bark↗ 推送 —— 长任务跑起来人离开屏幕，手机也能响。

1. 思路

Claude Code 的 hook 系统暴露一组生命周期事件，对"被通知"的需求，只需要两个：

• Stop —— 模型当前回合结束。任务跑完该响一声。
• Notification —— 模型需要确认/输入（permission prompt、问题等）。这种更紧急。

Hook 命令的 stdin 会拿到一份 JSON：cwd（项目路径）、transcript_path（JSONL 全量对话）、Notification 事件还会带 message。

设计取舍：

• 单文件 Python —— macOS 自带 python3，不再依赖 jq、curl 的 JSON 转义脏活。
• 本地通知优先 terminal-notifier —— 装了就用（可点击、有 group 去重），没装回落 osascript，零依赖。
• Bark 是可选项 —— 只有当 BARK_KEY 环境变量存在才推。失败静默，不影响 hook 退出码。
• 不 chmod —— 原因见末尾"坑"那节。脚本不可执行，靠 python3 path/to/notify.py 调用。

2. 脚本：~/.claude/hooks/notify.py

#!/usr/bin/env python3
"""Claude Code notification hook for macOS.

Local toast (osascript or terminal-notifier) + optional Bark push.

Usage: notify.py <Stop|Notification|...>

Reads JSON from stdin (Claude Code hook payload):
  cwd               -> current working directory
  transcript_path   -> path to JSONL transcript (Stop event)
  message           -> notification message (Notification event)

Environment variables (all optional):
  BARK_KEY            Bark device key. If unset, Bark push is skipped.
  BARK_SERVER         Bark server (default: https://api.day.app).
  BARK_GROUP          Notification group (default: ClaudeCode).
  BARK_SOUND          Notification sound (default: minuet).
  BARK_ICON           Custom icon URL.
  BARK_STOP_LEVEL     Level for Stop events (default: passive).
  BARK_NOTIFY_LEVEL   Level for Notification events (default: timeSensitive).
                      Valid: active | timeSensitive | passive | critical.
  CLAUDE_NOTIFY_OFF   If set to "1", suppress all notifications.
"""
from __future__ import annotations

import json
import os
import shutil
import subprocess
import sys
import urllib.request
from pathlib import Path

TITLE_PREFIX = "ClaudeCode"
MAX_BODY_LEN = 200


def read_stdin_json() -> dict:
    try:
        raw = sys.stdin.read()
    except Exception:
        return {}
    if not raw.strip():
        return {}
    try:
        return json.loads(raw)
    except Exception:
        return {}


def last_assistant_text(transcript_path: str) -> str:
    p = Path(transcript_path)
    if not p.is_file():
        return ""
    try:
        with p.open("r", encoding="utf-8", errors="replace") as f:
            lines = f.readlines()[-30:]
    except Exception:
        return ""
    for line in reversed(lines):
        try:
            entry = json.loads(line)
        except Exception:
            continue
        msg = entry.get("message") or {}
        if msg.get("role") != "assistant":
            continue
        content = msg.get("content")
        text = ""
        if isinstance(content, str):
            text = content
        elif isinstance(content, list):
            for block in content:
                if isinstance(block, dict) and block.get("type") == "text":
                    t = block.get("text", "")
                    if t.strip():
                        text = t
                        break
        if text.strip():
            return text
    return ""


def truncate(s: str, n: int) -> str:
    s = (s or "").strip()
    if len(s) <= n:
        return s
    return s[: n - 1] + "…"


def send_mac_notification(title: str, body: str) -> None:
    tn = shutil.which("terminal-notifier")
    if tn:
        try:
            subprocess.run(
                [tn, "-title", title, "-message", body,
                 "-sound", "Glass", "-group", "claude-code", "-ignoreDnD"],
                check=False, timeout=5,
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
            )
            return
        except Exception:
            pass

    def esc(s: str) -> str:
        return s.replace("\\", "\\\\").replace('"', '\\"')

    script = (
        f'display notification "{esc(body)}" '
        f'with title "{esc(title)}" sound name "Glass"'
    )
    try:
        subprocess.run(
            ["osascript", "-e", script],
            check=False, timeout=5,
            stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
        )
    except Exception:
        pass


def send_bark_push(title: str, body: str, event: str) -> None:
    key = os.environ.get("BARK_KEY", "").strip()
    if not key:
        return

    server = os.environ.get("BARK_SERVER", "https://api.day.app").rstrip("/")

    if event == "Notification":
        level = os.environ.get("BARK_NOTIFY_LEVEL", "timeSensitive")
    elif event == "Stop":
        level = os.environ.get("BARK_STOP_LEVEL", "passive")
    else:
        level = "active"

    payload = {
        "title": title,
        "body": body or " ",
        "group": os.environ.get("BARK_GROUP", "ClaudeCode"),
        "level": level,
        "sound": os.environ.get("BARK_SOUND", "minuet"),
    }
    if icon := os.environ.get("BARK_ICON", "").strip():
        payload["icon"] = icon

    try:
        req = urllib.request.Request(
            f"{server}/{key}",
            data=json.dumps(payload, ensure_ascii=False).encode("utf-8"),
            method="POST",
            headers={"Content-Type": "application/json; charset=utf-8"},
        )
        with urllib.request.urlopen(req, timeout=5) as r:
            r.read()
    except Exception:
        pass


def main() -> int:
    if os.environ.get("CLAUDE_NOTIFY_OFF") == "1":
        return 0

    event = sys.argv[1] if len(sys.argv) > 1 else "Stop"
    data = read_stdin_json()

    cwd = data.get("cwd") or ""
    project = os.path.basename(cwd) if cwd else ""

    if event == "Stop":
        title = f"{TITLE_PREFIX} - {project}" if project else TITLE_PREFIX
        body = ""
        transcript = data.get("transcript_path") or ""
        if transcript:
            body = last_assistant_text(transcript)
        if not body.strip():
            body = "Task completed, please review results."
    elif event == "Notification":
        title = f"{TITLE_PREFIX} - Needs Attention"
        if project:
            title = f"{title} - {project}"
        body = (data.get("message") or "").strip() \
            or "Claude is waiting for your input or approval."
    else:
        title = TITLE_PREFIX
        body = f"Event received: {event}"

    body = truncate(body, MAX_BODY_LEN)

    send_mac_notification(title, body)
    send_bark_push(title, body, event)
    return 0


if __name__ == "__main__":
    sys.exit(main())

几个细节值得一提：

• 抓 transcript 倒数往前找 —— 只读最后 30 行 JSONL，倒序遍历，第一条 role == "assistant" 且非空文本就用。content 字段在不同 SDK 版本下可能是 string 也可能是 array，两种都处理。
• truncate 用 … 单字符 —— 而不是 ... 三个 ASCII 句号，省 2 字节给正文。
• Bark level 分场景 —— Stop 默认 passive（不打扰，只入推送列表），Notification 默认 timeSensitive（穿透专注模式）。等长任务跑完手机不必尖叫，但要确认时必须能听见。
• 失败静默 —— Bark 推不上、osascript 报错、transcript 读不到，全部吃异常返回。Hook 不应该把模型卡死。

3. 接入 ~/.claude/settings.json

把下面这块合进 settings.json，保留你原有的 env / permissions / enabledPlugins 等字段：

{
  "hooks": {
    "Notification": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "python3 /Users/you/.claude/hooks/notify.py Notification",
            "timeout": 15
          }
        ]
      }
    ],
    "Stop": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "python3 /Users/you/.claude/hooks/notify.py Stop",
            "timeout": 15
          }
        ]
      }
    ]
  }
}

matcher: "" 是匹配所有 —— Stop / Notification 这两个事件本来也没有 sub-matcher 概念。timeout: 15 秒兜底，超时不影响主流程。

4. 启用 Bark

Bark 是 iOS 上一个挺老的推送工具，免费版 key 在 day.app↗ 拿。装好 app，主页能看到一段类似 https://api.day.app/abc123xyz/ 的链接 —— 中间那段就是设备 key。

把它加到 settings.json 的 env 块（hook 进程会继承）：

"env": {
  "BARK_KEY": "abc123xyz"
}

可选环境变量速查：

5. 验证

设好 BARK_KEY 后，手动跑一发 Notification 模拟：

BARK_KEY=你的key echo '{"cwd":"/tmp","message":"test"}' \
  | python3 ~/.claude/hooks/notify.py Notification

正常情况下：

1. 桌面右上角弹一条 macOS 通知
2. 手机 Bark 通知到达，分组是 ClaudeCode，级别是 timeSensitive

如果只想看本地通知不打扰手机，把 BARK_KEY 临时去掉就行。

6. 几个坑

hook 不生效？ Claude Code 的 settings watcher 只盯着会话启动时已经存在的目录。如果 .claude/ 是会话开始后才创建的，settings 修改可能不会被 reload。打开一次 /hooks 菜单（会强制 reload），或者重启 Claude Code session。

chmod 被 deny 怎么办？ 我的 settings 里 permissions.deny 包含 Bash(chmod:*)，所以脚本不能 chmod +x。解法是 hook command 直接用 python3 path/to/notify.py 调用，不依赖文件可执行位 —— 反而更显式，少一处隐式状态。

通知正文太长？ 脚本里 MAX_BODY_LEN = 200，截到 199 字符 + …。macOS 通知中心本身也会截断，但提前截能避免在 Bark 上看到一串 JSON 转义崩溃的字符。

想再省一点？ Stop 事件每回合都触发，会很吵。两个解法：

• 在 Bark 那条线把 BARK_STOP_LEVEL 已经设成 passive —— 只入推送列表，不响。
• 想本地也不响：在 send_mac_notification 里检查 event == "Stop" 时不发 osascript 就行（5 行改动）。

7. 可拓展方向

留给以后自己折腾：

• Telegram / Lark / Slack —— 把 send_bark_push 改名 send_remote_push，按 REMOTE_KIND 环境变量分发。Bark 只是其中一种。
• 细化 Notification 文案 —— 当前直接拿模型给的 message。可以判断 tool_name（如果将来 hook payload 加进来）做更精准的标题。
• 聚合连发 —— 短时间内多次 Stop 合并成一条（debounce 5s）。当前每次都响。
• 统计 —— 把每次 hook 触发记一行到 ~/.claude/hooks/notify.log，看一周下来跑了多少回合、几次需要确认。这些数据其实挺有意思。

整套配置改一次就一直在了。每次模型响完 / 卡住等输入，桌面右上角"叮"一声，手机口袋里也跟着震一下 —— 长任务跑起来终于可以放心去倒杯水。