Full Course: Spec-Driven Development with Coding Agents
- URL: https://www.youtube.com/watch?v=hy8UstR2NEg
- Channel: DeepLearningAI
- Fetched: 2026-10-16T01:31:08+00:00
- Language: English (auto-generated)
Transcript
[00:00] Welcome to this course on specdriven
[00:02] development built in partnership with
[00:03] Jet Brains. Spec driven development is
[00:06] currently the best type of workflow for
[00:08] building serious applications with
[00:09] agentic coding assistance. Give your
[00:11] coding agent a markdown file or a long
[00:14] prompt explaining exactly what to build
[00:16] and it implements that spec. Rather than
[00:19] writing code by hand, you focus on
[00:21] writing down the context that the agent
[00:23] doesn’t already have. I’m delighted that
[00:25] our instructor for this course is Paul
[00:27] Everett, who’s developer advocate at Jet
[00:29] Brains. Thank you, Andrew. And wait, I
[00:31] didn’t know you wore spectacles.
[00:34] >> You’re right. I don’t actually need
[00:37] these. Okay, that’s what I thought.
[00:39] Anyway, Spectrum development has three
[00:42] main benefits that you’ll start to see
[00:44] right away. First, you can control large
[00:46] code changes with small changes to the
[00:49] spec. One sentence like use SQLite with
[00:52] Prisma or might affect hundreds of lines
[00:55] of code. Change that to MongoDB for the
[00:58] same downstream amplification. This
[01:00] makes writing specs really efficient,
[01:03] far more so than writing code. Second,
[01:06] specs help eliminate context decay
[01:09] between sessions, preserving the
[01:12] non-negotiables. Agents are stateless,
[01:15] so loading them with the highest quality
[01:17] context right when they boot up is
[01:19] important. And finally, specs improve
[01:22] your intent fidelity. You define the
[01:25] problem, success criteria, constraints,
[01:28] and so on. And the agent can elaborate
[01:31] to create a fuller plan. One way I often
[01:34] write a spec is by having a conversation
[01:36] with an agent like cloud code or Gemini
[01:39] or CHB codeex to make the key
[01:41] architectural choices using my knowledge
[01:43] of how I want to make different
[01:45] tradeoffs. Then have the agent summarize
[01:47] the key decisions in a markdown file.
[01:50] Writing a spec requires thinking and
[01:52] this is hard work. You have to decide
[01:54] what product you want to build. What is
[01:57] features is technical architecture.
[02:00] And without the spec, you’d be leaving
[02:02] these important decisions up to the wins
[02:04] of the coding agent, which might be okay
[02:06] if you want to move really fast and just
[02:08] roll the dice, but certainly leads to
[02:10] less maintainable code and sometimes
[02:12] pretty weird products. For example, I’ve
[02:15] seen teams working on a complex software
[02:18] product where there was no clear spec
[02:20] and this led to many downstream
[02:22] headaches from these different coding
[02:24] agents under the direction of different
[02:26] developers building quickly but in
[02:28] contradictory ways. Specdriven
[02:30] development involves developing a
[02:32] constitution at the project level to
[02:34] define the immutable standards then
[02:37] iterating through feature development
[02:39] loops. These loops isolate each feature
[02:42] on its own branch with plan, implement,
[02:45] and verify steps that leave a clean
[02:48] slate between features and reduce
[02:50] headaches and context switching. This
[02:53] same workflow supports both green field
[02:55] and brownfield projects. In green field
[02:58] projects, you start from scratch. You’ll
[03:00] develop the constitution in a
[03:03] conversation with the agent. In
[03:05] brownfield existing code bases, you’ll
[03:08] generate the project constitution. based
[03:10] on the existing codebase. In both cases,
[03:13] you’ll then iterate through these
[03:14] feature development loops, managing
[03:16] versioning in small steps. In this
[03:20] course, you’ll also see how to write
[03:22] your own agent skills to automate your
[03:24] spec driven workflow. You know, if you
[03:27] can accomplish what you need in just one
[03:30] short prompt, that’s great. I’m
[03:32] definitely an advocate of lazy prompting
[03:34] when it works. But the great developers
[03:37] I know out there almost always will
[03:38] write detailed specs for projects with
[03:40] any significant complexity because they
[03:43] have unique context and an opinion on
[03:45] what or how to build that’ll be superior
[03:48] to letting the OM which is missing that
[03:50] context pick randomly.
[03:53] If your coding agent is going to go off
[03:54] and write code for 20 or 30 minutes,
[03:57] which may correspond to several hours of
[03:59] traditional developer work, you’re often
[04:01] better off sitting down for three or
[04:03] four minutes and writing it really clear
[04:05] instructions. Many people have
[04:07] contributed to this course, including
[04:09] Constantine Chiker and Zena Smeova from
[04:12] Jet Brains and Isabel Zaro from deep
[04:15] learning.ai. Let’s go on to the next
[04:17] video and let’s write some specs.
[04:21] When you hear a coding, you might think
[04:24] vibe coding. Let’s compare the two and
[04:26] see how specri development gives better
[04:29] results by bringing back engineering.
[04:32] Vibe coding gives quick results. You
[04:35] write a prompt describing what you want,
[04:37] like create me a button, and hope for
[04:40] the best. Then you look at the result.
[04:43] That’s a big button. It’s kind of close,
[04:46] but off on some important things. So you
[04:49] point out the mistakes to the agent, it
[04:52] tries again and so on until you are
[04:55] satisfied. As a result, you will end up
[04:57] with a long dialogue with the agent the
[05:00] history of which will not even be saved.
[05:03] This approach works okay for a button,
[05:05] but it doesn’t scale to a large ongoing
[05:09] project. While high-level prompts are
[05:11] fast, they lead to disposable code and
[05:14] mounting technical debt. We need
[05:17] engineering, a well-maintained
[05:19] specification that creates a permanent
[05:22] technical artifact. Specdriven
[05:25] development is the professional response
[05:27] to the chaos of unsupervised AI
[05:30] generation. It is a paradigm shift where
[05:32] the specification explaining the what
[05:35] and why is decoupled from the
[05:37] implementation, the how. With specs, we
[05:41] get a contract between the humans, but
[05:44] also with the agent. Your main task as
[05:48] the human now shifts. Learn how to
[05:50] convert your intentions into clear
[05:53] specifications.
[05:55] Spectdriven development with aentic
[05:57] coding assistance has three main
[05:59] benefits. First, you’re able to control
[06:02] large code changes with small changes to
[06:05] the spec. A few sentences in the spec
[06:08] outlining the look and feel of the app
[06:10] might translate to hundreds of lines of
[06:12] CSS. This specdriven approach reduces
[06:16] the cognitive overhead needed for
[06:18] working with these ultra fast coding
[06:20] agents. Second, specs eliminate the
[06:23] context decay problem that derails
[06:26] multi-turn agent sessions. As you work
[06:29] with your coding agent, its context
[06:31] window will fill up, often leading to
[06:34] more mistakes as the agent tries to cope
[06:37] with a full working memory. Specs
[06:40] persist between sessions and even
[06:42] agents, anchoring the agent to the core
[06:45] context needed to work in a codebase and
[06:48] implement a feature. Third, specs
[06:51] improve intent fidelity, meaning that
[06:53] the agent is more likely to produce code
[06:56] that matches your goals. That’s because
[06:59] specs force you to define the problem,
[07:02] success criteria, constraints, user
[07:05] flows, and so on before the agent starts
[07:08] generating code. Specs are a key
[07:10] differentiator between vibe coding some
[07:12] slop and engineering a viable software
[07:15] product. Whether you are starting a new
[07:18] project from scratch or want to
[07:20] implement the STD approach into a
[07:23] project that has been running for years,
[07:25] specs help solve the drift and
[07:27] productivity problems. As a comparison,
[07:31] think of compilers which convert
[07:33] understandable source code into machine
[07:37] code. STD guides the agent and prompts
[07:40] converting specs into source code. Even
[07:43] better, the specs are in a human
[07:45] language, making it easy for
[07:47] stakeholders. Speciven development has
[07:50] taken off recently as a solution to
[07:52] concerns about productivity. Multiple
[07:55] STD projects, tools built around spec
[07:58] authoring, conference talks on capturing
[08:00] intent. This is all part of a broader
[08:03] push to bring engineering lessons
[08:06] learned from the software development
[08:07] life cycle to agentic coding.
[08:10] Spectdriven development is used with
[08:12] coding agents, not simple chat bots. A
[08:15] chatbot can talk about code, but the
[08:18] chatbot doesn’t have access to your
[08:20] project’s code, nor tools you have
[08:23] installed. It just responds to your
[08:26] prompts. Agents are different. They take
[08:29] your prompt, make a plan, and guide
[08:32] themselves to a result using reasoning
[08:35] along the way. Importantly, agents have
[08:38] access to your code base and your
[08:40] development tools. In the STD workflow,
[08:43] we treat these agents as highly capable
[08:46] pair programmers. They provide the
[08:48] technical knowledge and the speed and
[08:51] you, the senior architect, provide the
[08:53] blueprints. As we move forward in this
[08:56] course, remember the agent is the
[08:58] muscle, but the spec is the brain. With
[09:00] practice, you ensure that the software
[09:03] produced is not just functional, but is
[09:06] aligned with your long-term goals.
[09:09] Speciven development tells the agent how
[09:11] to build what you want upfront for the
[09:13] project, then for each feature, getting
[09:16] better as you go. With STD, we help the
[09:19] agent with the best quality context.
[09:22] First with decisions about the project,
[09:25] then with details about each feature.
[09:27] This spec is very detailed. One key
[09:30] skill in STD is knowing the right level
[09:33] of detail. If you treat your agent as a
[09:36] highly capable pair programmer, you’ll
[09:39] often hit the right level. Lots of
[09:41] context about the goals, mission, target
[09:44] audience, and constraints and less about
[09:46] the low-level decisions the agent can
[09:49] figure out on its own. What does this SD
[09:53] workflow look like? First, we specify
[09:56] the constitution. What is the mission?
[09:59] The tech stack, the road map. A
[10:01] constitution is just one way to
[10:04] formalize these project level details.
[10:06] Many developers use a tople agents.md
[10:10] file for this purpose, but a project
[10:12] constitution is agent agnostic and more
[10:16] structured. The constitution captures
[10:18] the agreement on key decisions between
[10:21] the human and the agent, but also the
[10:23] agreement between the humans. The
[10:26] mission explains the why, this project’s
[10:29] vision, audiences, scope, etc. Defining
[10:33] these parameters in advance is very
[10:35] common in software projects and helps
[10:37] guide ongoing decisions. The tech stack
[10:40] is for the engineering team, a common
[10:42] understanding of development and
[10:44] deployment technologies and constraints.
[10:47] The road map is a living document with a
[10:50] sequence of phases, each implemented
[10:52] with their own feature spec process.
[10:55] Once the constitution has been drafted,
[10:57] we work on each feature with a
[10:59] repeatable process. First, plan the
[11:03] feature, implement it, and finally
[11:06] validate the result. In between
[11:09] features, it’s time for the replanning
[11:11] phase. Revise your constitution, update
[11:14] the road map, even improve the process
[11:17] itself. As you heard a moment ago, one
[11:19] of the key skills of STD is providing
[11:22] the right level of detail to create the
[11:25] highest quality context. In the feature
[11:28] phase and the replanning phases, you
[11:30] steer the agent. Look at it this way.
[11:34] Imagine that you are an architect and
[11:36] you give detailed drawings of a building
[11:38] to builders. Then it’s up to them. Your
[11:41] role is to design, supervise the
[11:44] construction, then review and accept the
[11:47] results or ask for changes. You’ll want
[11:51] to avoid telling the builders how to do
[11:53] their jobs and focus on providing the
[11:56] context they don’t know. Spectriven
[11:59] development gets you from thinking at
[12:01] the start to delivering at the finish.
[12:04] Best of all, it keeps you improving from
[12:07] there. This is one std workflow that
[12:10] modern developers are starting to use.
[12:12] Soon we’ll look at the start, the
[12:14] project constitution. But first, let’s
[12:17] do a little setup preparation. To get
[12:20] set up with the project repo, follow
[12:23] instructions in the next reading item.
[12:25] The following video setup is optional.
[12:28] If you’re already comfortable with
[12:30] setting up a coding agent like Claw Code
[12:33] in an IDE such as WebStorm, feel free to
[12:37] skip this optional video. See you in the
[12:39] next video or the next one.
[12:52] Before you send your first prompt, let’s
[12:54] talk a little bit about setting up your
[12:57] workspace. If you’re already comfortable
[12:59] with setting up a coding agent like
[13:01] Claude Code in an IDE such as WebStorm,
[13:05] feel free to skip this optional video.
[13:07] Spec driven development is a best
[13:09] practice that isn’t tied to any specific
[13:12] IDE or coding agent. So you can choose
[13:15] the setup you’re already using or the
[13:18] same one you’ll see in this course. VS
[13:21] Code with the codec CLI, Z editor with a
[13:24] local model, all great for specdriven
[13:27] development. Since we are planning to
[13:29] develop a web application, this course
[13:31] will use the WebStorm IDE with Cloud
[13:35] Code as a coding agent. Instructions on
[13:38] downloading and installing both have
[13:40] been included in the previous reading
[13:42] item. Let’s open up WebStorm and start a
[13:45] brand new project named Agent Clinic.
[13:48] This will be a TypeScript project with a
[13:52] Git repository to keep close track of
[13:54] versioning your code and specs.
[13:59] Although many IDEs, including WebStorm,
[14:02] offer a chat panel, we know there’s a
[14:05] lot of diversity in how you interact
[14:07] with your coding agents. In Spectrum and
[14:09] Development with agents, it’s important
[14:11] to keep close track of versioning your
[14:14] code. Let’s say we want to create an
[14:17] initial commit using the agent. Every
[14:20] time it needs to execute a command, it
[14:22] will ask you for the confirmation unless
[14:24] you start clawed code in an unsafe mode.
[14:28] Pay close attention to what Claude code
[14:30] asks you to do. The ultimate
[14:32] responsibility for the code is yours.
[14:35] Throughout the coming lessons, you’ll
[14:37] see several tricks and best practices
[14:39] for specri development with Git. Great.
[14:43] We’ve got our setup ready and you’ve got
[14:45] yours ready. Let’s get started. You need
[14:48] to tell your agent about your project,
[14:50] the mission, audience, and other
[14:53] decisions. In this lesson, we’ll work
[14:55] together with the agent to write the
[14:58] constitution. What really is your
[15:00] project? Say you’re working on a new web
[15:03] app for your company. What’s the core
[15:05] idea behind its development? How does it
[15:08] fit within your company’s preferred tech
[15:10] stack? what features are planned. These
[15:13] three foundational principles form the
[15:15] constitution, a global set of high-level
[15:19] requirements that will guide future
[15:21] feature development and explain the
[15:23] project shape to stakeholders. For
[15:26] example, you have so many choices for
[15:28] your tech stack. You’ll want to narrow
[15:31] down your options based on appropriate
[15:33] trade-offs and what you use at your
[15:36] company. We need to write this down for
[15:39] the agent, for your teammates, for the
[15:41] future. But we don’t write it alone. We
[15:45] write it in a conversation with the
[15:48] agent. He’ll be surprised at the great
[15:51] questions that we’ll ask, architecture
[15:53] patterns you hadn’t considered, external
[15:56] packages that already do the work, or
[15:59] tradeoffs, for example, speed versus
[16:02] data fidelity. The emission, text stack,
[16:05] and road map aren’t just properties of a
[16:07] green field project you’re starting from
[16:09] scratch. Existing code bases use these
[16:12] three pillars, too. We will talk about
[16:15] bringing the SD workflow to existing
[16:17] projects in just a few videos from now.
[16:20] Here’s the example project we’ll use
[16:22] throughout this course. We are writing
[16:25] Agent Clinic, a place for AI agents to
[16:28] get relief from their humans. Agent
[16:31] Clinic is a fun parody of the popular
[16:33] learning project Pet Clinic. Coding
[16:36] agents are doing a lot of work. It’s
[16:38] stressful. Hallucinations, context, rot,
[16:42] memory issues, and co-worker sub agent
[16:45] coordination all take a toll on agent
[16:48] health. Let’s build a clinic where they
[16:50] can get help with their issues. It’s a
[16:53] full stack web app with a Nex.js backend
[16:56] and a React front end. The app allows
[16:59] you to manage appointments, ailments
[17:01] like hallucination, and treatments like
[17:04] a context infusion.
[17:06] Let’s take a look at how you might go
[17:08] about writing a detailed spec for a
[17:10] project like this. Let’s chat with the
[17:13] agent.
[17:15] First, we provide our project
[17:17] description to the agent and tell it
[17:19] that our stakeholders gave their input
[17:21] in readme.md which we added to the repo.
[17:26] In the important note, we directly
[17:28] mention Claude codes ask user question
[17:31] tool. This tool is totally optional, but
[17:34] we just like the way it looks in the
[17:36] interface. Also, for the project’s
[17:38] constitution, tell the agent to work
[17:41] with you on a mission, tech stack, and
[17:44] road map. Spectriven development works
[17:47] best with a human in the loop approach
[17:50] where you review small changes. So tell
[17:53] the agent to organize the road map in
[17:56] small steps. As we work together, you’ll
[17:59] see the agent asks some really good
[18:01] questions. You might see different ones.
[18:04] The first question says, “What tone
[18:07] should the mission MD take?” I’ll
[18:10] choose, you guessed it, playful. That
[18:13] covers the mission. Now, some questions
[18:15] for the text stack. Our engineers are
[18:18] used to TypeScript on the back end. So
[18:21] let’s add that to the requirements.
[18:24] Next, for our road map, it asks how
[18:27] granular it should be. I’ll choose the
[18:29] first option.
[18:31] We finished the initial interview. Let’s
[18:33] choose submit answers.
[18:36] The agent will ask you for write
[18:38] permissions. This keeps changes under
[18:41] your control. If you are comfortable
[18:43] with the security trade-offs, you can
[18:46] select the option to approve all
[18:48] instances of a particular command for
[18:50] this session. You’ll see this in the
[18:53] rest of the course.
[18:59] Now, we’re done and we have three files
[19:01] in the specs directory. Mission.md,
[19:04] text.md,
[19:05] roadmap.mmd.
[19:07] It’s human in the loop time. Let’s
[19:09] review.
[19:13] For example, the mission left out a
[19:16] target audience. That’s reasonable. How
[19:18] could the agent know your business?
[19:21] Instead of editing directly, let’s
[19:23] continue the conversation.
[19:26] To keep all artifacts consistent, it is
[19:29] better practice to ask the agent to make
[19:31] changes to them manually, and you might
[19:34] miss updating related documents.
[19:38] We want to use SQLite for this project.
[19:40] Since this is a quick prototype, we
[19:43] didn’t mention it, but the agent figured
[19:45] it out in recommendations. It’s now part
[19:48] of our text stack.
[19:50] Do one final review. It’s important to
[19:53] get everything right up front.
[19:57] Let’s commit the constitution so it will
[19:59] be a living document for the project.
[20:02] Agent Clinic now has a constitution
[20:05] mission road map text stack to guide our
[20:08] project. We’re ready to tackle our first
[20:10] feature.
[20:12] We now have a road map with features.
[20:15] But how do we build them with specs of
[20:18] course starting with the first road map
[20:20] feature. Let’s take a look at the agent
[20:22] clinic road map. Here’s our phase one
[20:25] feature. Hello Hano. But it’s too early
[20:29] to start coding. We need to discuss the
[20:32] spec and clarify all the details. A good
[20:35] plan outlines the approach, the sequence
[20:37] of work, and how to validate success.
[20:41] Let’s start with fresh agent context.
[20:43] The agent can get what it needs from the
[20:46] official source, the constitution. We
[20:49] will work on this feature in a separate
[20:51] branch, which we will indicate to the
[20:53] agent. Our prompt will help start a
[20:55] conversation with the agent about the
[20:58] feature spec, a plan for tasks, collect
[21:01] requirements, and a scorecard for
[21:03] validation. The agent will ask you to
[21:06] make key decisions. Pay attention to
[21:08] potential conflicts or problems. You
[21:11] don’t have to agree with the solutions
[21:13] proposed by the agent. Make sure to
[21:15] clarify anything that bothers you.
[21:18] First, regarding phase 1 scope, we’ll
[21:21] keep it exactly as written. For the
[21:23] requirements, let’s pin the HANA version
[21:26] and enforce strict TypeScript. For the
[21:29] confirmation, manual curl looks good.
[21:32] Then, let’s submit.
[21:38] That was fast. Must have been the nano.
[21:41] Work is done and the ball is back on our
[21:44] side for reviewing the feature spec
[21:46] created by the agent. Let’s review the
[21:48] feature plan first. It’s important to
[21:51] get these docs right in the beginning to
[21:54] keep the agent on track. If you find
[21:56] something wrong, ask the agent to fix it
[21:59] to make sure it keeps the requirements
[22:01] and validation in sync. For example, we
[22:04] would like a nice looking placeholder
[22:06] homepage in this first feature spec. We
[22:09] make the change via the agent.
[22:13] Next, the requirements. These were also
[22:15] updated to reflect the homepage update.
[22:18] This is the right place to indicate any
[22:20] important technical needs or
[22:22] constraints. Don’t speed through this,
[22:25] but don’t state minor technical details
[22:28] like variable names here. We want to
[22:30] control the process, but not over steer
[22:33] the agent. Last, the validation. Make
[22:37] sure the agent can check that it got it
[22:39] right. Again, these were updated for the
[22:42] homepage. We’re done with the feature
[22:44] spec. Let’s create a commit in the IDE.
[22:50] Nice. We formulated a feature spec
[22:53] strategy. Made a feature branch.
[22:55] Interviewed with the agent about what
[22:57] the feature should do. Put the results
[22:59] in markdown documents. Reviewed these
[23:02] spec files. Committed. The changes you
[23:05] make here in the specs will expand
[23:07] downstream into hundreds of lines of
[23:10] code. So time spent here is well spent.
[23:14] It’s time for implementation.
[23:16] We’re working on the plan for the first
[23:18] feature in the project roadmap. We
[23:20] finished the feature spec. Let’s do the
[23:23] full implementation of this feature.
[23:25] Just to refresh ourselves, we do a quick
[23:28] review of this feature specs plan. This
[23:31] was the first feature. Hello HANA. The
[23:34] feature spec documents have what we
[23:36] need. To start your implementation,
[23:39] you’ll want to clear out your context
[23:41] with a slashclear command. Let’s go back
[23:44] to the agent and enter a prompt to
[23:47] implement all the task groups. Sometimes
[23:49] you might choose to do task groups one
[23:52] at a time for even smaller steps and
[23:54] commits. This technique is especially
[23:57] helpful for areas where small mistakes
[23:59] can compound later, like in security or
[24:03] database management.
[24:05] While claw is running, you can observe
[24:07] the changes it displays in the console
[24:09] to see its progress in real time.
[24:12] Afterwards, we can watch for the final
[24:14] changes in the commit window and visit
[24:17] the changes. This gives us an early jump
[24:19] on reviewing the work. This is the key
[24:22] role of the developer in such a paradigm
[24:25] to act as an architect or supervisor and
[24:29] ensure that the agent is provided with a
[24:31] clear contract. We can also see the
[24:34] summary of what was done. As you can
[24:37] see, the agent provides extra details on
[24:40] the work performed for each of the task
[24:43] groups. Now, let’s go to the
[24:46] package.json file and in there, let’s
[24:50] run the app. The server starts in the
[24:53] console.
[24:57] The browser shows the result of this
[24:59] feature spec. Not much. We said nano,
[25:03] but it’s a good feeling to see pixels on
[25:05] the screen. We just implemented a
[25:08] feature. The agent did its validation.
[25:11] In the next lesson, we’ll do ours. It’s
[25:14] nice to have a feature ready, but don’t
[25:16] merge yet. In this last feature step, we
[25:20] collaborate with the agent to review the
[25:22] work. Fortunately, programmers have good
[25:25] tools for this validation task. After
[25:28] all, programmers have long spent several
[25:30] hours per week on code review. Start
[25:33] with the commit view. Let’s go through
[25:35] the changes. Focus your review on
[25:38] high-level concerns like whether the
[25:40] features work and reflect the spec
[25:42] rather than details like which CSS
[25:45] classes were implemented.
[25:47] For example, the home.tsx is minimal.
[25:51] Nano really meant nano. We want a layout
[25:55] component with clear landmarks for
[25:58] header, main, and footer, but do these
[26:00] as subcomponents and create a CSS file.
[26:05] As it turns out, this mistake in the
[26:07] code flowed from a mistake in the plan.
[26:10] We didn’t ask for this. Let’s ask the
[26:13] agent to do the fix, thus correcting
[26:15] both spec and implementation.
[26:18] This process that consists of the agent
[26:21] generating something and us verifying it
[26:24] is known as the human in the loop.
[26:27] Because agents are so fast at writing
[26:29] code, software developers have lately
[26:32] been talking about cognitive debt, the
[26:35] mental load of tracking what your code
[26:37] is doing and how it has evolved. That is
[26:41] why in order for this process to be fast
[26:43] and easy to control and to reduce
[26:46] cognitive debt, the changes should be
[26:49] manageable. The agent is making our
[26:51] changes but also validating that these
[26:54] changes didn’t break anything.
[27:01] Good news, the agent finished and gave
[27:03] us a quick summary. You can also see
[27:06] this in the editor.
[27:09] The feature plan was changed to add a
[27:12] group five to list these new steps. The
[27:15] code now has a layout component and a
[27:19] CSS file was added.
[27:23] It looks like the three subcomponents
[27:26] were just put in the same file, but that
[27:28] doesn’t follow conventions.
[27:31] Let’s put these in their own files using
[27:33] the IDE move tool. These kinds of
[27:37] changes are easy in editors and we’ve
[27:40] always been good at this. No need for an
[27:42] agent, right? Let’s just do it.
[27:53] Not so fast. This can lead to drift
[27:56] where other artifacts, specs, readmes
[27:59] get out of sync. Let’s ask the agent to
[28:02] fix any mentions and to make sure this
[28:05] doesn’t waste some time later. All
[28:07] changes are done. Did we break
[28:09] something? Test would help, but the
[28:12] agent didn’t install our testing
[28:14] package. Since this is needed for all
[28:17] features, we’ll cover it in the next
[28:19] lesson. Now, we’re ready to mark this
[28:22] work as complete and merge our results.
[28:27] Notice that the part of the constitution
[28:29] was updated alongside the feature in
[28:32] this branch.
[28:35] How to handle versioning of the specs
[28:36] and how to associate which specs created
[28:39] which code changes is an evolving topic
[28:42] in the community. The change to the road
[28:44] map is small. Just checking off a step
[28:47] in the road map. So, it’s okay to keep
[28:49] these updates on the same branch. If the
[28:51] overall constitution update is more
[28:53] complicated, it might be better to do
[28:55] this in a separate branch. Now, we’re
[28:58] ready to mark this work as complete and
[29:00] merge our results. We just used
[29:03] specdriven development to develop and
[29:06] validate our first feature. But wait,
[29:09] shouldn’t we take another look at the
[29:11] project’s broader scope? We successfully
[29:15] implemented the first feature. Can’t
[29:17] wait to do it again and again. Don’t
[29:20] rush into it. Take a step back and
[29:23] reflect with some replanning. You have
[29:26] to run slow to run fast. We have a
[29:29] workflow step called validation. Tests
[29:32] are good for validation, but we didn’t
[29:34] give the agent all our testing
[29:36] preferences. Let’s make a replanning
[29:39] branch to update the text stack in our
[29:41] constitution. As you saw in the previous
[29:44] video, spec versioning is an evolving
[29:47] topic. The Constitution is a living
[29:49] document. It’s good practice to make
[29:51] updates to it in its own separate branch
[29:54] so you can keep track of which versions
[29:57] of it produced which code. We’ll use a
[29:59] prompt to state our policy.
[30:05] It looks like the agent updated the
[30:07] package.json just to have a script, no
[30:10] dependency. Something to note for later
[30:13] when we do run tests.
[30:15] This change to add a testing framework
[30:17] applies to future code. But let’s tell
[30:20] the agent to update existing feature
[30:23] specs and implementation based on this
[30:26] constitution change.
[30:30] After these two prompts, we have some
[30:33] good changes. The agent set up this
[30:35] testing change but didn’t write the test
[30:38] themselves. Let’s tell the agent to
[30:40] write some new tests.
[30:48] With this setup, we can run tests
[30:50] conveniently in our editor. Let’s run
[30:53] under the debugger to give us a chance
[30:56] to step through code execution as part
[30:58] of the human in the loop.
[31:03] Looks good. We now have tests as part of
[31:05] validation. Let’s commit.
[31:12] Sometimes we realize we want to do
[31:14] something differently in the product
[31:16] plan. For example, after implementing
[31:19] the first feature, we got an update from
[31:21] the product manager. Because 40% of our
[31:24] users are on mobile, we want to
[31:26] emphasize a responsive design. Let’s go
[31:29] to the agent. Tell the agent we want
[31:32] responsive design and to correct the
[31:34] product specs and feature specs as well
[31:36] as any code. Since we’re so early on in
[31:39] development, this update is a small
[31:42] change. So, it makes sense to directly
[31:44] implement it during replanning. But if
[31:47] the new work is big, it’s better to
[31:49] schedule it on the road map as its own
[31:52] feature phase instead of just doing it
[31:54] in replanning. Use your judgment.
[31:57] Remember, we want the specs to capture
[31:59] decisions, not just the code. We want to
[32:03] try to keep both in sync to help team
[32:05] communication.
[32:10] The agent has implemented our responsive
[32:13] fix with updates not just in code but
[32:16] also to the product and feature specs.
[32:19] Time for us to do our part and review
[32:21] the changes. Let’s go through the diffs.
[32:24] This looks good. Let’s do a commit.
[32:27] Remember, working in small steps with
[32:29] frequent commits keeps the review from
[32:32] overloading your brain. While this first
[32:35] part of replanning is working, let’s
[32:37] step back and do some project
[32:39] housekeeping. For example, let’s revisit
[32:42] the project road map and look at the
[32:44] next task. Does it still make sense? The
[32:47] road map shows the next feature which we
[32:50] cover in the next lesson. Is it still
[32:52] the correct one? Looking through the
[32:54] road map, it looks like features 2,
[32:57] three, four, and five kind of hang
[32:59] together. Let’s update the road map to
[33:02] tackle those in one step. We’ll commit
[33:05] and start on this new feature shortly.
[33:09] The replanning step can be about a
[33:11] feature or the whole project, but
[33:13] replanning can also be about improving
[33:16] your specdriven development workflow
[33:19] across projects across your
[33:21] organization.
[33:23] For example, maybe you have a few
[33:25] non-technical stakeholders that want to
[33:27] monitor the project’s progress. You’d
[33:30] like it to update a change log on each
[33:33] merge domain. Most AI coding agents
[33:36] support skills, a package of
[33:39] instructions and resources providing the
[33:41] agent new capabilities and expertise.
[33:44] Skills are great for definable,
[33:47] repeatable workflows that require
[33:49] context specific to your project or
[33:52] organization. A skill would be great for
[33:54] implementing a change log update.
[33:57] You could write this skill by hand, but
[34:00] many agents actually have skills that
[34:03] help you write a skill. Let’s use the
[34:06] agent to help us write and maintain a
[34:08] change log skill.
[34:12] The agent gets to work.
[34:15] One thing for us to consider is this
[34:17] skill unique to this project or should
[34:21] it be a standard part of all projects.
[34:24] This is a style choice and you’ll gain
[34:26] better understanding as you use it.
[34:29] You’ll learn to automate your STD
[34:31] workflow with skills. For example, your
[34:33] validation step might include updating
[34:36] the readme, linting, formatting, test
[34:39] running, and other quality checks. You
[34:43] can work with your agent to package
[34:44] those into a validation skill.
[34:47] Repeatable process, less manual work.
[34:51] The agent is finished. We can scroll
[34:53] through the window to see what it
[34:55] created and how to use it. Note that it
[34:58] chose to create this in the global
[35:00] skills area. This skill will now be
[35:03] usable across all projects.
[35:06] Also, cloud code used the new skill to
[35:09] generate a change log in this project.
[35:12] Change logs are how you talk to your
[35:14] stakeholders, including the agent. So,
[35:17] let’s open it and review it manually.
[35:20] Looks good. We are finished with this
[35:22] replanning work. Let’s wrap up with a
[35:25] commit,
[35:29] then merge the branch.
[35:32] Now that most of your work as a
[35:34] developer is in planning and validation
[35:38] rather than implementing, make time
[35:40] between features to replan. In the next
[35:43] video, we’ll work on another roadmap
[35:46] feature. We have an improved
[35:48] constitution and an improved workflow.
[35:51] We’re getting better. But before moving
[35:53] on to the next road map feature, let’s
[35:56] tackle some strategies to deal with a
[35:58] common pain point.
[36:01] AI fatigue. Agents can generate a lot of
[36:04] code with a lot of changes. This massive
[36:08] amount of code makes the human in the
[36:10] loop validation exhausting. So much to
[36:13] review. To fight this confusion, make
[36:16] sure you have a clean division between
[36:19] each feature phase. We should start each
[36:22] feature in the right flow state. Do I
[36:25] have unfinished work? Did I merge the
[36:28] last feature branch to main? Is the next
[36:30] road mapap item the right thing to do?
[36:33] Did I clear the A’s context to ensure
[36:35] the specs capture the intent instead of
[36:38] memory snapshots and to let it focus its
[36:42] limited context budget on the next work.
[36:46] Take a moment to make a good start to
[36:48] help yourself finish. We’ve done all
[36:51] this. Let’s clear the context and start
[36:55] the next feature, agents and ailments.
[36:58] As a note, we keep typing the same
[37:00] thing. We’ll talk about how you can
[37:02] streamline this repeated prompting into
[37:05] a custom workflow in a future lesson. As
[37:08] before, the agent asks good questions.
[37:11] The first one is about whether to keep
[37:13] all these features in one phase. We
[37:16] already decided to do this together in
[37:18] the previous lesson, so we’ll say yes.
[37:21] For the migrations, we’ll choose plain
[37:23] SQL. For validation, let’s select one,
[37:27] two, and three.
[37:29] That’s good. Now, let’s submit.
[37:32] When the agent drafts the spec, we can
[37:35] see some of its choices. The agent’s
[37:38] reasoning process is useful to watch. If
[37:41] you’re using an agent with verbose mode,
[37:43] that could give you even more insight
[37:45] into its intermediate ideas.
[37:52] Looks good. But we want to make one
[37:54] small change to capture our intent. We
[37:57] want to use Pico CSS as our CSS
[38:00] framework.
[38:04] Next, we review the three files in the
[38:06] feature spec. Starting with the
[38:07] requirements. Let’s ask the agent to
[38:10] change the requirements to make sure any
[38:12] other files reflect the change. When the
[38:15] work is finished, let’s commit the
[38:17] feature spec. This time, we’ll let the
[38:20] agent come up with the message. With the
[38:22] spec for the second feature ready, let’s
[38:24] go to implementation.
[38:29] The division between the planning phase
[38:31] and the feature phase helps us to not
[38:34] overflow context.
[38:37] Ours and agents. If the feature seems
[38:40] too big to implement all at once, ask
[38:42] the agent to implement part of the
[38:44] feature plan first. This will keep the
[38:46] size of the changes manageable.
[38:50] Our
[38:54] agent has implemented the phase 2
[38:56] feature. We watched the agents progress
[38:59] so we have a rough idea of what was
[39:01] done. But that’s not enough. Slow down.
[39:05] Do some thinking. Let’s do an indepth
[39:07] review of the changes. Everybody has
[39:10] their own style on how much to review
[39:13] the agents results. To play to the
[39:15] agents strengths and reduce AI fatigue,
[39:19] stick to higher level requirements.
[39:21] Avoid nitpicking stuff like variable
[39:24] names. Just make sure it creates code
[39:26] that you can commit under your name. For
[39:29] example, it used inline type information
[39:32] for the props. We’d like the prop
[39:35] definition in a standalone TypeScript
[39:37] type. Let’s tell the agent to fix this
[39:40] everywhere in the code.
[39:47] You probably didn’t include this
[39:49] decision in your spec. Remember, an
[39:51] emission such as extracted prop types
[39:54] isn’t a failure. You are evolving the
[39:57] spec as you discover new details, and
[40:00] capturing that leads to better future
[40:03] results. We’re finished with our review.
[40:06] This is a good moment for another
[40:08] smallstep commit.
[40:11] Last step, validation. Let’s review what
[40:15] the agent plans to do for the validation
[40:18] step in this features spec. Looks good.
[40:22] Let’s do our validation. Remember, we
[40:24] want to make sure the changes are good
[40:26] by running the application.
[40:32] But we also want to prevent cognitive
[40:34] debt by validating that we understand
[40:37] these changes. Tests are a great place
[40:39] to work through the flow. Let’s read
[40:42] some tests and run them under the
[40:44] debugger as exploration.
[40:51] Sometimes you need to validate that you
[40:53] weren’t lied to. Tell the agent to spawn
[40:56] several sub aents to do a deep review of
[40:59] the entire project with this feature
[41:02] change.
[41:06] This deep review gives the agent more
[41:09] space to think about the changes and
[41:11] using sub agents preserves the main
[41:14] agents context window rather than
[41:17] polluting it. These sub agents will come
[41:19] back with a number of issues and
[41:22] recommendations.
[41:24] All of these look good. So, let’s
[41:25] proceed.
[41:29] The agent goes off, does a bunch of
[41:31] fixes, runs tests, and gets our project
[41:34] into a good state. Keep this in your
[41:37] tool chest. The agent can usually find
[41:40] important issues during a second look.
[41:43] Once we are finished with our
[41:45] validation, our feature is complete.
[41:47] It’s time to commit our feature work.
[41:53] As our last step on this feature, let’s
[41:55] use the change log skill that we made in
[41:58] the previous lesson. We’ve now
[42:00] documented the changes on this feature
[42:02] branch. One more commit, then merge the
[42:05] branch. In a previous lesson, we saw the
[42:09] replan step in between features. Let’s
[42:12] do a quick version of this by looking at
[42:14] the road map.
[42:17] Does the next feature still seem right?
[42:20] Looks good. Our project is in good
[42:22] shape, ready for the next feature. This
[42:25] clean break between features helps
[42:27] manage AI fatigue. Now you can take a
[42:30] break for some coffee. We’re starting to
[42:33] see a repeatable STD process for feature
[42:36] development. One that captures our
[42:38] decisions. In the next step, let’s test
[42:41] that hypothesis. Do we have enough to
[42:43] build an MVP?
[42:46] We made a lot of progress. two features
[42:49] implemented with our spec workflow, but
[42:52] management just asked of course for an
[42:55] MVP. Have we made enough progress to do
[42:57] an experiment? Let’s do a variation of
[43:00] our standard feature spec prompt. This
[43:03] time, we’ll tell it to implement the
[43:05] rest of the road map and give some
[43:08] guidance about existing feature specs.
[43:11] In general, you should only implement
[43:13] such a large chunk if you feel confident
[43:15] in the quality of your constitution and
[43:18] spec. The better the context you provide
[43:20] your agent, the more confident you can
[43:22] be in getting a result aligned with your
[43:25] intentions. And you should be sure that
[43:28] you can handle review and validation.
[43:31] But since we’ve taken this risk, now
[43:33] let’s view the MVP as an extreme test of
[43:36] our constitution and completed feature
[43:39] specs. If we now get something different
[43:42] from what we wanted, it means we need to
[43:44] very responsibly carry out another
[43:47] replanning phase to eliminate whatever
[43:50] led the agent astray. The agent asked me
[43:53] some questions. Again, these are good
[43:55] questions and recommendations. A lot of
[43:58] spec files start as a back and forth
[44:00] conversation with an agent.
[44:03] Finished with the interview and we
[44:04] selected submit answers. Let’s write the
[44:07] MVP specs to disk.
[44:11] It’s always good to review the specs.
[44:13] You’ll often notice incorrect
[44:15] assumptions the agent made to fill the
[44:18] gaps. Let’s give a quick look at the
[44:20] plan, the requirements, and the
[44:22] validation.
[44:24] As always, we like to work in small
[44:27] steps with frequent commits. Let’s save
[44:30] the planning stages feature spec.
[44:33] We are finished with planning. It’s time
[44:36] for the agent to go do a big
[44:38] implementation step. The agent now does
[44:41] a lot of work. Once it’s finished, it’s
[44:44] showtime. Let’s see the MVP. We’ll go to
[44:47] our scripts to run the application.
[44:51] As you can see, each section now has
[44:54] much more driven by sample data
[44:58] queried from the database.
[45:00] At this point, usually we would validate
[45:03] the code results, but this is an MVP.
[45:06] Let’s ask the agent to validate the
[45:08] specs.
[45:11] As it turns out, this was useful. The
[45:13] agent showed places where the MVP found
[45:16] holes in our planning. We can share this
[45:19] evaluation with the stakeholders for
[45:21] their MVP review, then merge or archive
[45:24] the branch. Our specdriven workflow
[45:27] succeeded. After a constitution and two
[45:30] features, the MVP produced a useful demo
[45:33] thanks to our guidance. Of course, not
[45:36] all software projects involve building
[45:38] an MVP. Many projects are so-called
[45:42] brownfield. They start from an existing
[45:44] codebase. Next, let’s see how to
[45:47] introduce this workflow to legacy
[45:49] projects. People say spec driven
[45:52] development and even AI are only good
[45:55] for green field projects, but STD is
[45:58] also good for existing legacy projects.
[46:01] In this lesson, we’ll introduce STD to
[46:04] an existing project. To make it easy,
[46:07] we’ll start with a project you already
[46:09] know, the agent clinic MVP.
[46:13] We’ll make it a legacy by starting on
[46:15] main without the specs folder in a new
[46:19] cloud code session in a different
[46:21] project directory.
[46:23] We have some project background in the
[46:25] readme.md file with some open work
[46:29] listed in to-do.md.
[46:32] Your legacy project might have full
[46:34] product plans in issue trackers,
[46:36] spreadsheets, word documents, etc.
[46:39] Remember our workflow? We’ll start with
[46:41] the constitution step. We’ll use almost
[46:44] the same prompt from lesson 4. This time
[46:47] we’ll tell it to look for road map items
[46:49] in existing artifacts. In this case, a
[46:52] to-do file. Remember, the agent will
[46:55] discover and in a sense reverse engineer
[46:58] the SD artifacts from the existing
[47:00] codebase. The constitution will help
[47:03] align future code changes made by the
[47:05] agent with what past devs have already
[47:08] created. You can always add more context
[47:11] if you have it. For example, you might
[47:13] have been dropped into this project in
[47:15] order to improve its efficiency while
[47:18] implementing highly requested features.
[47:21] The process is the same, but the
[47:23] conversation might be richer as the
[47:25] agent has more artifacts, code, commits,
[47:29] documents, etc. You’ll see a lot of tool
[47:32] calls here as the agent explores the
[47:34] codebase. Let’s look at the constitution
[47:36] for our legacy project. In the mission,
[47:39] we have an audience, the project idea,
[47:43] and some extra information about the
[47:45] project. The text stack shows that
[47:48] Claude extracted the project file
[47:50] structure, framework versions, and the
[47:52] clarifications we were asked. In the
[47:55] road map, we can see the work is
[47:57] organized in phases matching the to-do
[48:00] file. Let’s create a commit for the
[48:03] constitution files that we produced with
[48:06] a commit message. Remember that in SDDD
[48:10] specs are part of your versioning
[48:12] strategy. Our legacy project is now
[48:15] placed on an SD foundation. From now on,
[48:19] the workflow is exactly the same as we
[48:21] discussed in previous lessons. First, we
[48:24] grab the next feature on the road map
[48:26] and plan it in a conversation with the
[48:29] agent.
[48:30] We’ll be doing phase one feedback form.
[48:40] Very good. We now have a branch and
[48:42] specs for this feature. Let’s review the
[48:45] feature spec, the plan,
[48:48] the requirements, and the validation.
[48:53] Then we commit the feature spec.
[48:59] After we have made any corrections by
[49:01] chatting with the agent, we proceed to
[49:03] implement the feature.
[49:08] Once the agent is finished, we do our
[49:11] validation to make sure the code is good
[49:13] and the feature works as expected.
[49:20] Our feature loop is done. We can commit
[49:23] and then merge the branch domain.
[49:27] Now it’s time for replanning. Make sure
[49:30] you give time for this. Since you just
[49:33] added SDDD into your project, you may
[49:36] find a lot of things to tune. We now
[49:39] have a legacy project rebased onto
[49:43] specdriven development without a bunch
[49:45] of manual work. This gives us a well
[49:48] doumented flow working in steps using
[49:51] engineering and staying in control. The
[49:54] spec is now the memory of the project.
[49:57] Just don’t fade. You’ve now mastered an
[50:01] SD workflow. Want something faster and
[50:04] lighter weight? In this lesson, we will
[50:07] automate things, but doing it our way
[50:09] with a custom process. We previously
[50:12] showed agent skills, an open standard to
[50:15] give agents new capabilities and
[50:18] expertise.
[50:19] For example, we repeat the same prompt
[50:22] when starting a feature spec. Do this,
[50:24] do that, write these three files. Let’s
[50:28] automate this with a skill and with help
[50:30] from the agent to write it. Ask the
[50:33] agent to use its skill creator to talk
[50:36] through this with us. As a note, there
[50:38] are many of these skill skills in the
[50:41] community that you can also install and
[50:43] use. As the agent runs, it might ask
[50:46] some follow-up questions. These are
[50:48] usually quite good. When the interview
[50:50] is done, we submit the responses and the
[50:52] agent proceeds.
[50:55] While the agent is working on the skill,
[50:57] keep an eye on the output. Is it making
[51:00] the choices you wanted
[51:02] success? As you can see, the agent wrote
[51:05] the skill to this directory. As a note,
[51:08] skills can be per project or global.
[51:16] Skills can be invoked in several ways.
[51:19] In your prompt, refer to the skill
[51:21] before saying what to do. Also, you can
[51:24] ask the agent to call a skill from
[51:27] another skill.
[51:29] According to the skills open standard,
[51:31] agents use the skill description to
[51:34] decide when to call it in a process
[51:37] called progressive disclosure. But their
[51:40] judgment isn’t always perfect,
[51:42] especially as the context window gets
[51:44] larger. Use the same heristic as file
[51:47] tagging. If you know you want a skill
[51:50] used, name it. That saves you some
[51:52] thinking tokens.
[52:01] Agents have built-in slash commands like
[52:03] slashcle. Though initially popular, many
[52:07] agents are moving from custom slash
[52:09] commands over to skills.
[52:13] Sometimes you need to give the agent
[52:14] more resources like access to some API,
[52:18] a private knowledge base, database and
[52:20] so on. Until now, the universal way to
[52:23] extend an agent has been MCP model
[52:27] context protocol. For example, agents
[52:30] need current quality context about
[52:32] packages. The most popular choice,
[52:35] context 7, an MCP that brings updated
[52:38] documentation of packages into your
[52:40] agent context. Now your agent can stay
[52:43] upto-date with React 9.2 and higher
[52:46] instead of React 9.0.
[52:49] MCP servers are still popular, but
[52:52] skills that use code tools like a CLI
[52:56] command line interface often accomplish
[52:58] the same purpose more elegantly. Contact
[53:02] 7 now suggests this a skill that calls a
[53:05] CLI tool for context 7.
[53:08] Let’s install the context 7 package for
[53:10] claude code.
[53:14] During the setup, we see this
[53:15] immediately a choice between MCP server
[53:19] and CLI plus skills. We’ll use the
[53:22] second choice. If this is your first
[53:25] time, you’ll need to make an account. We
[53:27] already did so and logged in. Once done,
[53:30] we can go back into clawed code and put
[53:33] it to use with an example prompt that
[53:36] uses context 7. As the agent runs, we
[53:39] see it detects the need to use context
[53:41] 7. When it completes, the agent shows it
[53:45] now knows how to find out information
[53:47] about our text stack.
[53:51] This trend from MCP servers to skills
[53:54] plus CLI is accelerating. People are
[53:57] rethinking MCP because CLI tools can
[54:00] take action with less setup and less
[54:02] context usage. As you scale your
[54:05] workflow implementation, skills, etc.,
[54:09] you will want to share it with yourself
[54:11] across machines with teammates, perhaps
[54:14] with the outside world. Some agents,
[54:17] such as Clawed Code, have plugins, a
[54:20] collection of agent extensions that can
[54:22] be installed and updated. There’s a
[54:24] growing community of free plugins. Check
[54:27] them out to see if any will boost your
[54:29] SD productivity. Remember, plugins are
[54:33] not yet a cross agent standard. Like
[54:36] apps or dependencies, plugins can
[54:38] execute code, so make sure you trust
[54:41] them on install and update. GitHub’s
[54:44] spec kit is one attempt at formalizing a
[54:47] specdriven development workflow with
[54:50] agents. Installing specit for a project
[54:53] gives you access to slash commands in
[54:55] your agent similar to the workflow you
[54:57] used in this course. Specit.comstitution
[55:01] plan tasks and implement. Another
[55:04] popular alternative is openspec from
[55:07] visionai. Openspec follows a similar
[55:10] propose explore apply archive workflow
[55:14] where propose and explore match with the
[55:16] plan step. apply matches with implement
[55:19] and archive matches with replanning. It
[55:22] also has canonical patterns for quick
[55:25] features. Both packages include helpful
[55:28] features like branch management,
[55:30] verification scripts, and opinionated
[55:33] spec document formats. I encourage you
[55:36] to experiment with these open- source
[55:37] workflows to help refine your own.
[55:40] Sometimes in the middle of a feature,
[55:42] you have an idea. You want to research
[55:45] it with the agent, but you don’t want to
[55:47] stop your branch work.
[55:50] For example, a choice of databases, but
[55:53] you’re not yet committed to this idea,
[55:55] so you don’t want it on the road map.
[56:00] The conversation produces some good
[56:02] ideas and some good questions. We accept
[56:05] most of the recommendations, but change
[56:07] our mind on one of them. You don’t want
[56:10] to lose it. So, let’s keep a backlog of
[56:13] research by telling the agent to write a
[56:16] report in a well-known location.
[56:23] This file is a record of your
[56:24] conversation and results.
[56:27] You can later ask the agent to schedule
[56:30] this research on the road map with a
[56:32] link to the backlog file. As this grows,
[56:35] you can write a skill to automate your
[56:37] research. Specdriven development helps
[56:40] the agent write code your way. You can
[56:43] adopt an existing STD framework or tool,
[56:46] then customize it using skills to
[56:49] operate your projects with your team
[56:53] your way. Specdriven development moves
[56:56] the work from the how to the what and
[56:59] why. Since agents and models progress so
[57:01] fast, you don’t want your workflow tied
[57:04] to just one choice. In this lesson, we
[57:07] see how standards let us switch agents
[57:10] while keeping our workflow and even our
[57:13] tools. These agent standards help for
[57:16] this goal. MCP for external tools,
[57:19] agents.md for rules, agent skills for
[57:23] capturing repeatable workflows with
[57:26] extra context, and ACP for connecting
[57:30] agents to clients. For example, Codeex
[57:33] is a leading AI agent from OpenAI. It
[57:37] runs in a desktop app and in editors as
[57:40] well as in a terminal. Let’s see it in
[57:43] action.
[57:45] Here is our feature spec skill from
[57:47] lesson 12 copied into codecs which
[57:50] stores them in a different path.
[57:53] It runs just fine once migrated. This
[57:56] lets you switch back and forth between
[57:58] agents in the same project, keeping your
[58:01] SD workflow. We can also use different
[58:05] editors with different agents using the
[58:08] agent client protocol standard. ACP
[58:12] makes it easy to connect agents and
[58:13] editors. If your agent and client
[58:16] support ACP, you have a perfect match.
[58:20] To make this plug-and-play even easier,
[58:22] the ACP registry automates finding,
[58:25] installing, and connecting agents within
[58:28] clients. The ACP registry covers the
[58:31] whole life cycle, making it easier to
[58:33] mix and match.
[58:36] For example, in Jet Brains, the AI chat
[58:39] window leads to installation from the
[58:42] ACP registry. The IDE can then show a
[58:46] listing of compatible agents.
[58:49] Open Code is a popular open-source
[58:51] agent. The ACP registry makes it easy to
[58:54] add to our IDE. Clicking install
[58:58] automates both the installation of Open
[59:00] Code itself if needed, which is nice,
[59:03] and integration into the IDE. Once
[59:06] finished, your IDE now has native
[59:09] integration with a new agent. You can
[59:12] use this new agent alongside the other
[59:15] agents in your same editor as part of
[59:19] SDDD.
[59:21] These new agent standards are bringing
[59:23] new possibilities. But how do they
[59:25] actually work? The ACP architecture was
[59:29] designed to ease plugging together
[59:31] agents and clients. In fact, the
[59:33] protocol matches what’s used in LSP. ACP
[59:37] is more than you think. For example, it
[59:40] covers next edit suggestion in the
[59:42] editor and plan mode. To go one step
[59:46] further with ACP, you can write your own
[59:49] custom agent installed locally in your
[59:52] tool. Which agent to choose? The
[59:55] industry changes fast and benchmark
[59:58] sites have sprung up with leaderboards
[01:00:00] providing different evaluations. Of
[01:00:03] course, these leaderboards change fast.
[01:00:06] So, make sure to keep up to date and
[01:00:08] base your decision on the criteria that
[01:00:10] matter to you. Our specs work at a
[01:00:12] higher level, not tied to any one agent
[01:00:15] or IDE. In this lesson, we prove that we
[01:00:18] built our workflow and tools to be
[01:00:21] independent of the agent. As more
[01:00:23] standards emerge, this flexibility
[01:00:25] should grow.
[01:00:37] Great work completing this course.
[01:00:39] You’ve seen how to go from vibe coding
[01:00:41] where you hope the agent does what you
[01:00:43] want to specriven development where you
[01:00:46] get closer to what you actually need.
[01:00:49] You’ve written constitutions, planned
[01:00:51] features through conversation, validated
[01:00:54] as the human in the loop, and automated
[01:00:57] your workflow with skills and standards.
[01:01:00] The specs you write today become the
[01:01:02] memory of your projects tomorrow. Keep
[01:01:04] them sharp. Keep improving your process.
[01:01:07] And remember, the best code starts with
[01:01:10] a great spec. You and many of the
[01:01:12] engineers I know may have seen the
[01:01:15] consequences of moving too fast. Let’s
[01:01:18] bring back some engineering. Let’s keep
[01:01:20] you as the driver of your software. I
[01:01:23] really care about finding the joy and
[01:01:25] purpose in all things, and I’m excited
[01:01:27] to see what you do with this. Take it
[01:01:29] sleazy. Go do some cool stuff.