CS146S — The Modern Software Developer↗ is a new Stanford course from Fall 2025, taught by Mihail Eric, with a heavyweight guest each week (Boris Cherny, Zach Lloyd, Isaac Evans, Tomas Reimers…). I worked through all eight weeks in the official assignments repo↗ and did the exercises along the way. This post is the consolidated note.

1. The Course’s Real Theme: A Shift in Developer Identity

The tagline on the course site is unusually direct:

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

If you only skim the weekly schedule, you’d think it’s “An AI Tools Survey.” But after reading the materials and doing the assignments, a more honest description is:

It is systematically training you to become an Agent Manager.

Not “learn to code with ChatGPT,” but: stop being the person who writes the code and become the person who directs Agents to write it — and who owns the result. Boris Cherny (creator of Claude Code) gets quoted again and again:

“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.”

The eight weeks fall into three storylines:

1. Prompt → Context (Weeks 1 → 3): from writing one good prompt to architecting a whole information environment
2. Coder → Agent Manager (Weeks 2 → 5): from writing code yourself to directing and orchestrating multiple Agents
3. Speed → Defensible (Weeks 6 → 8): from rapid output to auditable, defensible, ship-ready

The rest of the post follows those three lines.

2. Storyline One: Prompt → Context

Week 1: Six Foundational Prompting Techniques

Week 1 runs local models through Ollama and drills six techniques in turn: K-shot, Chain-of-Thought, Tool Calling, Self-consistency, RAG, Reflexion. One Python file per technique, iterate the prompt until tests pass.

The takeaway isn’t “I learned six tricks.” It’s: these aren’t parallel options, they form an evolutionary chain.

• K-shot gives the model a pattern
• CoT gives it room to reason
• Tool Calling lets it stop guessing and actually look things up
• Self-consistency trades sampling cost for stability
• RAG plugs external knowledge into the context
• Reflexion lets the model critique its own output and try again

By Reflexion, the model has gone from “answer machine” to “small self-correcting loop.” That is the seed of an Agent.

Week 2: First Time Closing the Loop on a Real Task

The assignment is a minimal FastAPI + SQLite Action Item Extractor: free-form notes → structured todo list. Use Cursor’s Agentic Mode to land five TODOs: replace rule-based extraction with an LLM, add unit tests, refactor, add a new endpoint + frontend button, generate a README.

In my own practice notes I distilled a minimum capability model for “a local Agent that executes simple requirements”:

understand intent → fetch code context → plan → generate code → verify → feedback
        ↑                                                                  |
        └────────────── on failure, backtrack & correct ←─────────────────┘

Each step maps onto a Week 1 technique. Agents are not a new invention; they are those atomic capabilities wired up around this loop.

After running it end-to-end the strongest impression: today’s Agents shine on tasks with clear boundaries that you can verify. Scaffolding, single-function implementations, happy-path tests, doc generation — these are strengths. Deciding “what not to change,” reasoning about cross-module side effects, refactors that involve real tradeoffs — those still need a human.

Week 3: From Prompt Engineering to Context Engineering

Week 3 is the densest week of the course (the other one being Week 6). Boris Cherny is the guest. The thesis traces back to Andrej Karpathy’s definition:

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

Two things in this week made me re-examine how I work:

“Context is King” — and a precondition for intelligence. A line that hits hard: “Claude is already smart enough — intelligence isn’t the bottleneck, context is. When the Agent fails, the instinct is to blame the model, but it’s almost always wrong. What’s actually underperforming is the information environment around it.”

Context Rot. Model performance degrades with input length, even on simple tasks. So /clear, /compact, tiered memory, keeping CLAUDE.md lean — these aren’t aesthetic choices, they’re performance strategies.

The Week 3 assignment is to build a custom MCP Server. I built a GitHub Issue assistant: 3 Tools (search_issues / create_issue / get_issue_detail) + 1 Resource (repo metadata) + 1 Prompt (bug report template), STDIO transport into Claude Desktop.

Building it by hand is the only way I really understood: the three MCP primitives (Tools / Resources / Prompts) aren’t abstract concepts — they map to three different ways an Agent “knows” something — what it can do, what it can look up, how it should phrase things.

Boris also shared his daily workflow: 20–30 PRs a day, sustained by running 5 Claude Code instances in terminals plus 5–10 sessions on claude.ai/code, every instance starting in Plan Mode, with CLAUDE.md as shared team memory. The line that gets hammered home:

“Give Claude a way to verify its own work — browser tests, test suites, simulators. Verification is what gives you a 2-3x quality improvement on the final output. Everything else (subagents, slash commands, MCP integrations) is built on top of that.”

3. Storyline Two: Coder → Agent Manager

Week 4: Claude Code as Agent Manager

Week 4’s central line:

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

This week catalogs 5 agentic workflow patterns:

• Sequential Flow — the default. About 70% of daily work.
• Operator — hierarchical: a central planner + specialized sub-agents
• Split-and-Merge — fan-out / fan-in, up to ~10 parallel branches
• Agent Teams — collaborative; agents can talk to each other across independent sessions
• Headless — triggered by CI/CD, Cron, webhooks; no human in the loop

Plus 12 “Agent Harness Patterns” (persistent instructions, directory-scoped instructions, tiered memory, memory hygiene, context compaction, parallel branching, checkpoint review, selective tool loading, purpose-built tools, permission granularity, lifecycle hooks, compounding corrections).

The line that stuck:

“The problem isn’t your model — it’s your harness. What separates a flashy demo from a production-grade AI system isn’t intelligence, it’s control.”

The assignment: build at least 2 automations (Slash Commands, CLAUDE.md, SubAgents) on a FastAPI starter app. After this week my muscle memory shifted: every time I see a repeated workflow I now ask “could this become a .claude/commands/ entry?”; every time Claude makes the same mistake twice I ask “should this go into CLAUDE.md?”

The phrase Compounding Engineering is one I like a lot: every recorded mistake becomes permanent leverage.

Week 5: The Terminal Is Not a Power User’s Toy

Week 5’s guest is Warp CEO Zach Lloyd. Warp 2.0 reframes itself from “a better terminal” to ADE — Agentic Development Environment.

The comparison table I found most useful:

These stack rather than compete: Claude Code can run inside Warp. The key tool for parallel Agents is git worktree — each Agent works in an isolated working tree, no clobbering, merge branches at the end. I started using this in real work after reading this week.

But the Warp team is honest about the cost: parallelism isn’t free. Saving 6–7 hours a week is real, but only if your cognitive bandwidth can actually steer 5 tabs at once — that turns out to be the real bottleneck.

4. Storyline Three: Speed → Defensible

Week 6: Semgrep and AI Code Security

Week 6 brings Semgrep CEO Isaac Evans. The opening number made me pause:

Claude Code, run as a security scanner, surfaced 46 real vulnerabilities — at a 14% true positive rate and 86% false positive rate.

This isn’t “Claude is bad.” It’s that AI’s security intuition isn’t reliable — out of 7 alerts only 1 is a real issue. Semgrep flips that ratio: 80% fewer false positives, 250% more true positives.

Semgrep’s three products:

• Code (SAST) — first-party code vulns, with cross-file analysis
• Supply Chain (SCA) — reachable CVEs in dependencies (reachability analysis filters out unreachable ones, cutting high/critical-severity false positives by 98%)
• Secrets — hardcoded credentials, with semantic + entropy analysis + live validation

The assignment: run semgrep ci --subdir week6 on a deliberately vulnerable FastAPI app and fix at least 3 findings. The fixes are unglamorous but fundamental: parameterized SQL, restricted CORS, secrets to env vars, dependency upgrades, stronger crypto, sanitized DOM writes.

The blunt takeaway: “Secure Vibe Coding” wants speed and safety unified, not opposed — the way you get there is automating scans into CI rather than retrofitting safety after the fact.

Week 7: Graphite Diamond and AI Code Review

Week 7’s guest is Graphite CPO Tomas Reimers. The thesis:

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

AI’s strengths in review: style consistency, common bug patterns, security vulnerabilities, code duplication, 100% PR coverage, second-level latency. Human strengths: architectural judgment, business logic correctness, tradeoff analysis, creative alternatives, team context, UX design.

The recommended pattern is “AI First, Human Second”: AI filters the mechanical stuff, humans focus on the high-leverage judgment calls. Graphite’s other product innovation is Stacked PRs — break a big PR into a chain of small sequential ones, because AI review performs noticeably better on small PRs.

The assignment is dense: 4 independent tasks, each going through “create branch → 1-shot AI implementation → manual line-by-line review → open PR → run Graphite Diamond → compare.” Then a written reflection: my review vs Graphite’s, which one was better, when, and why.

That comparative reflection is the most valuable part of the week, in my view. It isn’t teaching you to trust AI. It’s teaching you to know when AI is better than you, and when it isn’t. That meta-cognition is more durable than any specific tool.

Week 8: Bolt.new and Multi-Stack Rapid Builds

Week 8 pivots to “prototype to production.” The guest is Vercel’s Head of AI Research. The framing:

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

Bolt.new uses StackBlitz’s WebContainer technology to run Node.js entirely in the browser, generating full-stack apps from prompts. But its capability curve is steep:

The assignment asks you to build the same app in 3 different stacks, at least one via Bolt and at least one in a non-JS language. The design is sneakily clever — it trains two things at once:

1. Abstraction — you have to pull the business logic out of the framework and figure out what’s essence vs implementation
2. AI-tool literacy — the same prompt produces wildly different quality across Next.js / Django / Rails, so you have to develop a feel for “what does production-ready code actually look like”

5. Three Lessons I Actually Use Daily

After eight weeks of material and a stack of assignments, these are the three I’ve actually absorbed into my workflow:

5.1 Plan Mode Is Free Leverage

Boris’s “never let Claude write code before you have reviewed and approved a written plan” is the most-quoted line of the course. For any task longer than 30 minutes I now hit shift+tab into Plan Mode, iterate with Claude until the plan is right, then switch to auto-accept. Rework rate dropped noticeably.

5.2 CLAUDE.md Is Where Compounding Lives

Every time Claude makes a mistake or I notice a non-obvious project convention, it goes into CLAUDE.md. The habit is incredibly cheap and incredibly profitable — once it’s in there I never explain it again. Just keep it lean: it loads every session and eats context.

5.3 Always Give the Agent a Way to Verify Itself

Boris’s “most important insight.” Concretely:

• Backend work: have Claude run the tests, fail-then-fix, never “looks fine, ship it”
• Frontend work: spin up the dev server and have Claude actually click through the golden path with Playwright
• API integrations: get a minimal curl/httpie reproduction script first

This is just the engineering version of Reflexion (Week 1) — bake “self-review” directly into the workflow.

6. Closing: The Eight-Week Arc

Week 1:  How to talk to AI                  → Prompt Engineering
Week 2:  How AI uses tools                  → Coding Agents & MCP
Week 3:  How to build AI's information env  → Context Engineering
Week 4:  How to manage AI                   → Agent Manager
Week 5:  AI-native terminal                 → AI Terminal
Week 6:  AI code security                   → Semgrep
Week 7:  AI code review                     → Graphite Diamond
Week 8:  AI-built applications              → Bolt.new multi-stack
(Weeks 9-10: AI ops + the future            → second half of the course)

Each week is the foundation for the next. What you walk away with isn’t a tool manual — it’s a new posture:

You aren’t the person writing code anymore. You’re the person designing the information environment, directing the Agents, and answering for the final output.

Coding speed is up 10x. So is the speed at which you can ship the wrong thing. The baseline this course draws — testable, auditable, defensible — isn’t a constraint. It’s the floor that makes the new posture viable.

References:

• Course homepage: themodernsoftware.dev↗
• Assignments repo: mihail911/modern-software-dev-assignments↗
• Community Chinese edition: ShouZhengAI/CS146S_CN↗
• Claude Code best practices: 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 (original X post)
• Boris Cherny’s workflow: howborisusesclaudecode.com↗

Origin story: spotted a Windows gist that wires Claude Code into system notifications↗ , written in PowerShell, useless on a Mac. Rewrote it for macOS, then added a Bark↗ channel — when a long job finishes and you’ve wandered off, the phone in your pocket should be the one that pings.

1. The shape of it

Claude Code’s hook system exposes a set of lifecycle events. For “notify me”, you only need two:

• Stop — the model finished its turn. Time to ring the bell.
• Notification — the model wants confirmation or input (permission prompts, questions). More urgent.

The hook command receives JSON on stdin: cwd (project path), transcript_path (full JSONL conversation), and Notification events also carry a message.

Design choices:

• Single Python file — macOS ships python3 by default, so no jq / curl JSON-escaping ceremony.
• Local toast prefers terminal-notifier — use it if installed (clickable, supports group dedup); fall back to osascript otherwise. Zero install required.
• Bark is opt-in — only fires when BARK_KEY is set. Failures are silent; the hook’s exit code stays clean.
• No chmod — see the “gotchas” section below. The script isn’t executable; we invoke it as python3 path/to/notify.py.

2. The script: ~/.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())

A few details worth flagging:

• Walking the transcript backwards — read the last 30 JSONL lines, iterate in reverse, take the first entry where role == "assistant" with non-empty text. The content field can be either a string or an array depending on SDK version; both shapes are handled.
• Truncation uses … — a single ellipsis character, not three ASCII dots. Saves two bytes for actual prose.
• Bark level differs by event — Stop defaults to passive (silent, just lands in the push list), Notification defaults to timeSensitive (pierces Focus mode). Long jobs finishing shouldn’t shriek; mid-task confirmations must.
• Silent failure — Bark unreachable, osascript erroring, transcript missing — all caught and swallowed. A hook should never wedge the model.

3. Wiring it into ~/.claude/settings.json

Merge this block into settings.json, preserving your existing env / permissions / enabledPlugins etc.:

{
  "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: "" is “match anything” — Stop and Notification don’t have sub-matchers anyway. The timeout: 15 seconds is a backstop; timing out doesn’t break the main flow.

4. Enabling Bark

Bark is a long-running iOS push tool. The free key comes from day.app↗ . Install the app and the home screen shows a URL like https://api.day.app/abc123xyz/ — the middle slug is your device key.

Drop it into the env block of settings.json (hooks inherit env from there):

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

Quick reference for the optional knobs:

5. Verification

With BARK_KEY set, fire a manual Notification simulation:

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

Expected:

1. A macOS toast pops in the top-right corner.
2. A Bark notification arrives on your phone, grouped under ClaudeCode, level timeSensitive.

To preview local-only behavior, just unset BARK_KEY for the call.

6. Gotchas

Hook not firing? The Claude Code settings watcher only watches directories that already had a settings file at session start. If .claude/ was created mid-session, edits may not reload. Open the /hooks menu once (forces a reload), or restart the Claude Code session.

chmod denied in your permissions? My settings include Bash(chmod:*) in permissions.deny, so the script can’t be chmod +x’d. Fix: invoke via python3 path/to/notify.py so the executable bit is irrelevant. Bonus — it’s more explicit and removes a hidden piece of state.

Body too long? The script caps at MAX_BODY_LEN = 200 (199 chars + …). macOS Notification Center will truncate too, but capping early avoids ugly mid-JSON breakage on the Bark side.

Want to dial it back? Stop fires every turn — easy to find noisy. Two ways out:

• The Bark side already uses BARK_STOP_LEVEL = passive — silent push, lands in the list only.
• For local silence on Stop too: add if event == "Stop": return to the top of send_mac_notification. Five-line change.

7. Where to take it next

Saving these for future me:

• Telegram / Lark / Slack — rename send_bark_push to send_remote_push, dispatch on a REMOTE_KIND env var. Bark is just one of many.
• Sharper Notification copy — currently I just pass through whatever message the model sent. Could branch on tool_name (if hook payload starts including it) for sharper titles.
• Debounce a burst — multiple Stop events within 5s collapsed into one. Right now every turn rings.
• Stats — append a line to ~/.claude/hooks/notify.log per fire. A week’s worth of “how many turns ran, how often the model got blocked on input” tells you something interesting.

You set this up once and forget about it. When the model finishes a turn or stalls waiting for input, a soft chime in the top-right and a buzz in your pocket — long jobs can finally run while you make a coffee.