Full Course: Spec-Driven Development with Coding Agents

Summary

The course presents specification-driven development (SDD) as an engineering workflow for directing coding agents. Instead of relying on short, informal “vibe coding” prompts and repeated corrections, developers create durable Markdown specifications that explain what to build and why. The agent uses them to plan and implement how to build it.

Why Use SDD?

• Small specification edits can guide large code changes, making it efficient to adjust an application’s architecture or behavior.
• Written specifications preserve project context between sessions and across different agents.
• Explicit goals, constraints, user needs, and success criteria improve accuracy and reduce decisions left to an agent’s guesswork.
• Specifications become a shared contract and project memory, helping teams avoid conflicting implementations and technical debt.

The course advises giving agents rich context about the project’s mission, audience, and constraints, without over-prescribing low-level implementation details they can determine themselves.

The SDD Workflow

1. Create a project constitution or charter that records the mission, technology stack, and roadmap. It can be developed with an agent through discussion, but should be reviewed and maintained by people.
2. Plan each feature in its own development cycle, usually on a separate Git branch. Discuss scope and decisions with the agent, then create and review feature specifications, requirements, plans, and validation criteria.
3. Implement from the specification. Clear the agent’s prior context when useful, and break large tasks into smaller groups when that makes changes easier to manage and review.
4. Validate and review. Inspect diffs, run the application and tests, use debugging tools, and check that the result meets the specification. Correct both the code and the specification when review reveals a misunderstanding.
5. Commit, merge, and re-plan. Keep changes small and frequent. Between features, revisit the roadmap and update the project’s standards, specifications, or workflow as needed.

Human review remains essential: agents can generate code quickly, but developers are responsible for its quality and for avoiding cognitive debt—the burden of losing track of what the code does. The course also cautions against taking on large implementations before the project’s specifications are reliable and the team can verify the result.

Demonstration Project

The examples use Agent Clinic, a playful full-stack application for helping AI agents with problems such as hallucinations, context loss, and memory issues. The course builds its project charter and features with an agent, then demonstrates reviewing and correcting generated plans and code. It also shows how testing expectations and responsive-design requirements can be added to the project standards and reflected in existing specifications and implementation.

Guides and Tutorials Covered

• Workspace setup: A WebStorm, Claude Code, TypeScript, and Git workflow is demonstrated, while noting that SDD is not tied to a particular IDE or agent.
• Writing the charter: Develop the mission, stack, and roadmap with an agent; review omissions and recommendations; keep the charter as a living document.
• Planning and implementing a feature: Create a feature branch, discuss requirements and validation, review the specification files, implement the work, inspect the result, and commit changes.
• Review and validation: Add testing guidance, write and run tests, use an IDE debugger, and optionally ask subagents to analyze a change for issues.
• Managing changes and fatigue: Keep work divided into clear stages, clear stale agent context, use manageable changes, and take time to re-plan between features.
• Trying an MVP: Use the project constitution and existing feature specifications to guide a larger implementation, then ask the agent to identify gaps in the plan.
• Applying SDD to a legacy codebase: Have an agent inspect existing code and documents, derive an initial charter and roadmap, and use the same feature-by-feature workflow.
• Automating repeated work with agent skills: Create reusable skills for tasks such as feature specification, validation, and changelog updates. Skills can be project-specific or global.
• Extending and switching tools: The course discusses MCP, CLI-based skills, plugins, GitHub Spec Kit, OpenSpec, and standards including AGENTS.md and the Agent Client Protocol (ACP). It demonstrates carrying a workflow to Codex and connecting agents to IDEs through ACP.

Main Speaker and Sources

The instructor is introduced in the subtitles as Paul (“Paul Ehrlich,” likely an auto-captioning error); the course metadata identifies him as Paul Everitt of JetBrains. Andrew introduces the course. JetBrains and DeepLearning.AI are credited as collaborators.