Full Course: Spec-Driven Development with Coding Agents (DeepLearningAI)

A ~1-hour DeepLearningAI short course, built with JetBrains, introduced by Andrew Ng and taught by Paul Everitt (JetBrains developer advocate). It walks a full Spec-Driven Development (SDD) workflow end-to-end using Claude Code inside the WebStorm IDE, building a parody app ("Agent Clinic" — a clinic where AI agents get treated for hallucination and context rot). Unlike the vault's earlier SDD sources (a framework survey and a critique), this one is a hands-on operating procedure — and it is explicitly agent-agnostic.

Ng's framing line: "If your coding agent is going to go off and write code for 20 or 30 minutes, which may correspond to several hours of traditional developer work, you're often better off sitting down for three or four minutes and writing it really clear instructions." Everitt's: "The agent is the muscle, but the spec is the brain."

The workflow

Project Constitution — three files in specs/: mission.md (why, audience, scope), tech-stack.md (shared engineering constraints), roadmap.md (a living, phased plan in small steps). Drafted in an interview with the agent (Claude Code's AskUserQuestion tool), not written solo. Described as the agreement "between the human and the agent, but also between the humans."
Feature loop — each roadmap item gets its own git branch and three spec files: plan, requirements, validation (a scorecard the agent can check itself against). Then implement (after /clear — fresh context loaded from the constitution, not memory), then validate as the Human in the Loop.
Replanning between features — its own branch when the constitution changes, so you can trace which constitution version produced which code. Revise the tech stack (e.g. add the missing testing framework), absorb stakeholder changes ("40% of our users are on mobile"), merge roadmap items, and improve the process itself (write skills).

Three claimed benefits (Ng + Everitt): (a) leverage — one spec sentence ("use SQLite with Prisma") steers hundreds of lines of code; (b) no context decay — agents are stateless, specs persist across sessions and across agents; (c) intent fidelity — problem, success criteria and constraints are fixed before generation.

Key claims

Right level of detail is the core skill. Treat the agent as a highly capable pair programmer: lots of context on goals, mission, audience and constraints; little on low-level decisions (don't specify variable names). Architect analogy — give builders drawings, don't tell them how to lay bricks.
Change artifacts through the agent, not by hand. Even a trivial IDE file-move should be requested via the agent, or specs/READMEs drift out of sync with code. "The specs capture decisions, not just the code."
Review at the level of the spec, but do review. Focus diffs on whether features match intent, not CSS classes — "just make sure it creates code that you can commit under your name." Omissions found in review (e.g. extracted prop types) aren't failures; they're spec evolution.
Cognitive Debt and AI fatigue are the named human bottleneck. Agents generate so much code that human validation becomes exhausting. Remedies: small steps, frequent commits, a clean break between features ("run slow to run fast"), reading tests under the debugger as comprehension, and spawning several subagents for a deep second-look review ("sometimes you need to validate that you weren't lied to") — which also keeps the main agent's context clean.
The MVP as a stress test of the constitution. Letting the agent implement the whole remaining roadmap in one shot is only safe when constitution + specs are high-quality — and if the result diverges, that's a signal to replan, not to patch. The agent was then asked to validate the specs, surfacing holes in the planning to share with stakeholders.
SDD works on brownfield/legacy code. Start on main with no specs folder; the agent reverse-engineers the constitution from the codebase, commits, README and existing to-do/issue artifacts; roadmap phases map to the existing backlog. From there the loop is identical. "The spec is now the memory of the project." — directly counters the belief that SDD and AI are only for greenfield.
Automate the workflow with agent skills. A changelog skill for non-technical stakeholders; a feature-spec skill replacing the repeated kickoff prompt; a candidate validation skill (README, lint, format, tests). Skills can be project or global; name a skill explicitly when you want it used, because model-invoked selection via progressive disclosure "isn't always perfect, especially as the context window gets larger." Many agents are moving custom slash commands over to skills.
MCP → CLI + skills. Context7 (up-to-date package docs) now offers a CLI + skill install alongside its MCP server; the course picks the CLI path. "People are rethinking MCP because CLI tools can take action with less setup and less context usage." See CLI vs API vs MCP.
Plugins are a trust surface. Claude Code plugins bundle extensions for sharing, but "like apps or dependencies, plugins can execute code, so make sure you trust them on install and update" — and they're not yet a cross-agent standard.
Frameworks exist, customize them. GitHub's Spec Kit (constitution → plan → tasks → implement slash commands) and OpenSpec (propose → explore → apply → archive, mapping to plan / implement / replan). Adopt one, then tailor with skills.
Stay agent-portable via standards. MCP (external tools), AGENTS.md (rules), Agent Skills (repeatable workflows), and Agent Client Protocol (ACP) (agent ↔ editor). The course's feature-spec skill runs unchanged in Codex once copied to its path; OpenCode installs into JetBrains via the ACP registry. Benchmarks and leaderboards churn — don't tie your workflow to one agent.
Research backlog. Mid-feature tangents (e.g. a database alternative) get written by the agent to a well-known backlog file rather than lost or pushed onto the roadmap prematurely.

Enterprise reading (angle chosen for this vault)

Governance artifact, not just a prompt. The constitution is framed as a human-to-human contract as much as a human-to-agent one — the thing that stops multiple developers' agents "building quickly but in contradictory ways" (Ng's war story). For an IT org this is the natural attachment point for architecture standards, approved stacks and security constraints.
Legacy estates are in scope. Reverse-engineering a constitution from an existing codebase + backlog is the most directly useful move for enterprise IT, where most work is brownfield.
Traceability. Branch-per-feature, constitution changes on their own branch, spec + code committed together — "which specs created which code changes" is flagged as an open community problem, which is the audit question enterprises will ask.
Vendor neutrality. The portability lesson (skills + AGENTS.md + ACP) is a hedge against locking a whole engineering workforce into one coding agent.

Relation to the vault's SDD debate

This is the vault's third SDD source and sits on the disciplined side of the split on Spec-Driven Development (SDD): it uses Dwarampudi's constitution-first shape (Spec-Driven AI — BMAD SpecKit GSD Superpowers (Vimal Dwarampudi)) but with humans reading every diff — which is Pocock's condition in Software Fundamentals Matter More Than Ever (Matt Pocock, AI Engineer).

warning Tension with Specs-to-Code: Everitt explicitly uses the compiler analogy ("think of compilers… SDD guides the agent converting specs into source code") — the exact framing Pocock attacks as "vibe coding by another name." But the course's practice contradicts naive specs-to-code at every step (read diffs, run tests under the debugger, subagent deep review, fix code and spec together). The analogy overstates; the procedure is disciplined.

Where it adds to the existing picture: the interview-driven spec creation matches Pocock's Grill Me instinct (agent asks the human questions before writing), and the replanning branch is a concrete remedy for the constitution decay failure mode the SDD page lists.

Pages touched

DeepLearningAI · Andrew Ng · Paul Everitt · Project Constitution · Cognitive Debt · Agent Client Protocol (ACP) · Spec-Driven Development (SDD) · Specs-to-Code · Skills (Claude Code) · CLI vs API vs MCP · Human in the Loop · Verification Tax · Vibe Coding · Claude Code · Context Engineering

Source

Raw: source
Video: https://www.youtube.com/watch?v=hy8UstR2NEg