Is Vibe Coding Over? JetBrains and DeepLearning.AI Teach Spec-Driven Development

The course opens with a light joke — Andrew Ng introduces a JetBrains-built program where spec-driven development is framed as the most reliable way to build real products with coding agents. Instructor Paul Everitt, a JetBrains Developer Advocate, shows that you hand the agent a markdown spec and focus on writing the context it does not already possess. Like an architect handing drawings to builders, you define intent, the agent handles implementation.

A spec in this context is not a technical acronym but a living contract answering what you will build, why, and under which constraints. The right granularity comes from treating the agent as a capable pair programmer: goals, audience, limits and success criteria come from you, while variable names and loop optimizations are left to the agent. The video suggests 20–30 minutes of agent work can equal hours of human effort, so three to four minutes of crisp instruction pays off enormously.

The three recurring benefits anchor the entire narrative. First, a single sentence in the spec cascades into hundreds of lines; second, the spec halts context decay across sessions; third, it raises intent fidelity. Together they explain why scattered prompts create debt and why a spec counts as a durable technical artifact rather than disposable chat.

Small Spec, Large Leverage

Small spec, large leverage is made tangible: writing "use SQLite with Prisma" propagates style and schema across hundreds of files, swapping that sentence to "use MongoDB" triggers the same breadth in the opposite direction. A few lines describing the look and feel can become hundreds of lines of CSS. The leverage lowers cognitive load — the agent is fast, you simply choose the correct leverage point.

The second benefit targets memory. Agents start stateless and errors grow as the window fills. The spec is the highest-quality context bundle that survives sessions and even different agents, preserving non-negotiables. That is why the constitution is kept agent-agnostic and structured, a more durable contract than a single `agents.md` file.

The third benefit is intent fidelity : once the problem, success metrics, constraints and user flows are written, the agent can elaborate without drifting. Without that, decisions fall to the agent's random choices — you move quickly but the product turns odd and hard to maintain. The video illustrates how multiple teams without a clear spec built rapidly in contradictory directions on the same codebase and created lasting headaches.

Why Vibe Coding Does Not Scale

Vibe coding is contrasted sharply. You say "make me a button", then "fix it", then "fix again"; a long dialogue accumulates but nothing is saved. It suffices for a button, but at project scale it becomes disposable code and mounting maintenance load. Spec-driven development brings engineering back: spec and implementation are decoupled, much like a compiler turning source into machine code, except the source is human language that stakeholders can read.

According to the course, spec-driven practice has surged as a response to productivity worries; tools, talks and intent-capture patterns are multiplying as part of a broader attempt to re-apply software lifecycle lessons to agentic coding. The key distinction is the agent itself — not a chat bot that merely talks about code, but a system with access to your codebase and tooling, capable of planning, reasoning and acting on your behalf. You are the senior architect, the agent is muscle, the spec is brain.

How does the workflow look in practice? First you author the constitution : mission (why), tech stack (with what) and roadmap (in which order). The mission carries vision and audience, the stack provides a shared engineering language, the roadmap breaks work into small phases. The course stresses that green-field teams craft this through conversation with the agent, while brown-field teams reverse-engineer it from existing code — both then iterate identically.

The running example is Agent Clinic , a playful parody of Pet Clinic where AI agents seek relief from hallucinations, context rot and sub-agent coordination. It is a full-stack Next.js + React + TypeScript application for appointments, ailments and treatments such as "context infusion". The constitution is co-authored via a dialogue grounded in a readme that already contains stakeholder input; the agent asks solid questions about tone, stack and granularity.

That constitution interview feels structured: "which tone for the mission?" — answer playful; stack — TypeScript; roadmap — fine-grained. Three files emerge (`mission.md`, `tech-stack.md`, `roadmap.md`). If the first draft misses the audience, the habit is to tell the agent rather than editing files directly, keeping documents in sync. An SQLite suggestion also arrives from the agent, judged sensible for a quick prototype and folded into the stack.

From Constitution to Feature Branches

Each feature then follows the same branch, plan, implement, verify loop. On a fresh branch with a cleared agent context, a planning conversation crystallises task groups, requirements and a validation scorecard. Even the first feature — a minimal "hello HANA" — is captured as plan plus requirements plus verification and committed. Small commits are encouraged to keep changes reviewable.

Implementation begins after a context reset similar to `/clear`; the agent installs packages, writes files and reports its own validation per task group. Human review focuses on the commit view at a high level — flows and coverage rather than class names. When `home.tsx` proves too minimal, a layout component with header, main and footer plus a separate CSS file is requested; because the gap originated in the plan, the agent repairs both code and plan.

Verification is not only whether the app runs but also whether we understand the change to avoid cognitive debt . Tests are therefore added to the constitution; the agent scaffolds the framework and drafts initial tests while you step through them under a debugger. For deeper assurance the course shows spawning sub-agents for a full-project review — findings return without polluting the main agent's window. After each feature a replanning branch revisits the roadmap: is the next item still correct, should a responsive-design request be absorbed or scheduled?

To reduce repetition the workflow is packaged into skills , the open standard for reusable agent capabilities. The same "write three files, branch, interview, approve" prompt becomes a skill that can be invoked by name, per-project or globally. Skills live alongside `agents.md`, and via the emerging Agent Client Protocol (ACP) they become portable across editors — JetBrains' chat panel can install Claude Code, Codex or OpenCode from a registry with one click.

At the tooling layer the video notes a shift from Model Context Protocol (MCP) servers to skill+CLI hybrids. Context7, once a pure MCP server for live docs, now offers a CLI plus skill that the agent triggers when it needs current library knowledge instead of stale training data. Plugins bundle skills for sharing across machines and teams, though they execute code and must be trusted on install or update.

Two community frameworks encapsulate the same idea: GitHub Spec Kit (`/speckit.constitution → /speckit.plan → /speckit.tasks → /speckit.implement`) with branch management and verification scripts, and OpenSpec (`/opsx:propose → /opsx:explore → /opsx:apply → /opsx:archive`) with a more fluid, pattern-based loop. Both tie specs to version control; which agent you use matters less over time.

The closing section shows bootstrapping spec-driven practice onto a brown-field codebase: the Agent Clinic MVP is stripped of its `specs/` folder, then a constitution is reverse-engineered from the existing code and `todo.md` tracker, followed by identical feature loops. Research spikes get a dedicated backlog file, discussed on a separate branch before being scheduled. The final message is clear: the spec you write today is the project's memory tomorrow; the best code starts with a great spec.