Become an AI Native Engineer with Spec-Kit, SDD, and Claude

AI can already write the code, so what's actually left for you to do? Discover the paradigm shift redefining the software engineer's role, from hands-on coder to the nutritionist directing a powerful but literal minded robot chef, and why your next skill matters more than your last ten years of syntax.

Everyone is chasing vibe coding until the technical debt bill comes due. Meet Specification Driven Development, a decades old principle now supercharged for the AI era, and learn why the clarity of your spec, not the speed of your prompt, decides whether AI becomes your best teammate or your biggest liability.

You've bought into the philosophy, so how do you actually put it into practice? Meet Spec-Kit, the open toolkit that turns Specification Driven Development from an abstract principle into a concrete, repeatable pipeline, built on four pillars of clarity, lifecycle, ecosystem, and standardization that work whether you're starting a project from scratch or bolting precision onto a codebase you already have.

Two roads lie ahead: a quick path that gets you comfortable with the tool fast, and a deep path that teaches you what actually separates a great specification from a shallow one. Find out which one fits how you want to learn, and why skipping the theory quietly turns Spec-Kit into just another way to vibe code.

Before you can direct a robot chef, you need a kitchen. Walk through setting up Spec-Kit alongside Visual Studio Code and your AI engine of choice, so the tooling gets out of your way and you can focus entirely on what matters, defining a great specification.

Five Spec-Kit commands, run in strict order, stand between a vague idea and working code, plus two optional checkpoints that catch what would otherwise slip through. Walk through the entire Spec-Kit pipeline end to end, from constitution to implement, and see it mapped onto a cooking analogy that makes the whole workflow click.

Why does the same command look different depending on which AI engine you're using? A quick note clears up the dot versus dash confusion in Spec-Kit's slash commands, so you're never thrown off when your terminal doesn't match the slides.

One small habit keeps your entire Spec-Kit workflow clean: running each command in its own chat session. Learn why this matters and how Spec-Kit quietly persists context across sessions so you never lose track of where you left off.

Run one command and Spec-Kit hands you back a whole folder structure, so what is actually inside it? Take a quick tour of the constitution file, the AI engine integration folder, and the per-feature spec, plan, and task files that become your day-to-day working ground.

Time to stop reading about Spec-Kit and actually build something with it. Meet the project we'll ship in this section, a loan submission API secured by a car as collateral, and see what it means to move fast through the workflow while accepting the AI's assumptions along the way.

Experience Spec-Kit in your browser, without install anything.

IMPORTANT: You must have an active Claude subscription.

Every Spec-Kit project starts with a single command that scaffolds your entire workspace. Watch the very first step in action, from creating the project folder to seeing the AI-engine integration land inside Visual Studio Code, ready for the real work to begin.

Before the AI writes a single line of code, it needs to know the kitchen rules. Watch the constitution command turn a handful of technical and business preferences into a living project-wide rulebook that every future feature will have to respect.

A single prompt turns into a full functional specification, complete with user stories, edge cases, and success criteria you never explicitly asked for. See the specify command in action on a real loan submission feature, and why reading what the AI just wrote matters more than accepting it.

The AI just wrote your specification, but what did it quietly assume along the way? Run the clarify command and watch gaps surface on their own, then push back with your own answers to sharpen a spec that's still missing pieces like a customer's spouse.

Your functional spec just became a technical blueprint, data model, API contract, and all, without you writing a line of architecture yourself. See the plan command turn requirements into engineering decisions, and why validating what comes out matters just as much as generating it.

A technical plan is still too big to just start coding against, so watch it get broken down into a concrete, ordered checklist with the tasks command. Then see the optional analyze step catch mismatches across the specification, plan, and tasks before a single line of code gets written.

This is the moment everything else was building toward: the AI finally writes the code. Watch the implement command turn a validated plan and task list into a running API, and see firsthand why healthy skepticism doesn't stop just because the code compiles.

The happy path works, so why not just ship it? Uncover the business and technical gaps a fast, minimal-input Spec-Kit run leaves behind, from silently missing address types to an API with no authentication, and see exactly why the quick path is a prototype, not a finish line.

Claude isn't the only robot chef in the kitchen. See how the exact same Spec-Kit workflow running on GitHub Copilot and Antigravity, so you can pick whichever AI engine fits your team without losing a single step of the process.

The quick path got you familiar with the tool, but a tool is only as good as the process and people behind it. Step into a full lending company scenario built from the ground up, and see why this path trades speed for the theory and structure that make Spec-Kit deliver its real value.

"Build a loan submission API" sounds like a requirement, but it's actually a solution wearing a disguise. Learn how to interrogate a request down to its real business driver using the five whys and the SMART framework, and see how a lending company almost shipped the wrong product before asking a single question.

Objectives tell you why you're building something, but they never tell you where it stops. Learn how to turn business objectives into a hard line between what's in scope and what isn't, so a simple loan submission feature doesn't quietly balloon into an entire lending platform before day one.

All that analysis of problems, objectives, and boundaries has to land somewhere, so where does it go? Watch business context turn into an actual Spec-Kit constitution file, and pick up the trick of keeping input documents separate so your prompts never turn into an unmanageable wall of text.

A constitution full of business rules still leaves the AI guessing about folder structure, libraries, and coding conventions. Discover the two fixes, live documentation through MCP and a real technical template, that close the gap between an AI model's training cutoff and the standards your team actually follows.

Theory becomes practice as a Go REST API technical template gets wired into the constitution through GitHub MCP, turning an abstract standard into something Spec-Kit can actually reference during implementation. Watch what happens when a conflicting rule sneaks in, and see the AI catch it before it becomes a codebase full of inconsistencies.

Your AI agent isn't limited to what it already knows, it can call in specialists. See how MCP turns Claude into something closer to a project manager who delegates to Figma, Jira, GitHub, and Notion on demand, and learn why installing every available MCP server does more harm than good.

Miss one stakeholder and you get a requirements gap that surfaces late, right when it's most expensive to fix. Learn how to map everyone with a stake in your system, from direct users to the regulator you forgot existed, and why treating "the client" as your only stakeholder is a trap waiting to spring on a real lending platform.

A feature list sounds productive, but it quietly builds things nobody asked for. Discover why starting from what stakeholders actually do their jobs, captured as use cases or user stories with real acceptance criteria, produces requirements engineers and testers can both build and verify against with confidence.

A system that does everything right can still fail everyone who depends on it, if it's slow, insecure, or falls over under load. Learn how to interrogate performance, security, availability, and scalability with the same precision as functional requirements, and why telling an AI agent to "be performant and secure" is really telling it nothing at all.

Every requirement you've written down is quietly pointing at data, so what shape does that data actually take? Learn how to pull entities and fields out of your own specification, model relationships with an entity-relationship diagram, and see why a text-based diagram serves an AI agent far better than a picture ever could.

Spec-Kit wants your specification living in a Git repository, but your business team lives in Google Drive or Confluence, so which one wins? Confront the inevitable gap between collaborative workspaces and Spec-Kit's git-based world, and weigh a few practical ways to decide which side becomes the real source of truth.

Theory is one thing, but where do the files actually go? See the exact folder structure and naming conventions used throughout this course, from Google Drive requirement documents to the Spec-Kit repository, plus the MCP connection that lets Claude read straight from your collaborative workspace.

Reading about stakeholder interviews is one thing, actually conducting one is another. Step into an AI-powered role-play as a business analyst interviewing business and risk stakeholders under a time limit, and practice the exact skill of asking focused questions that real requirements gathering demands.

Even the most skilled robot chef is useless without knowing the occasion, the guest list, and the dietary restrictions, and your AI agent starts every session in exactly that same blind spot. Discover the difference between project-level context and reusable skills, and why conflating the two quietly produces inconsistent, unpredictable results.

Writing a CLAUDE.md file feels simple until you realize most of them are either too vague to matter or so bloated they create their own contradictions. Walk through the core principles of building a focused AI persona and a genuinely reusable skill, illustrated with a real loan-report skill built step by step from scratch.

Build a business analyst that lives inside Claude, complete with a persona, operating boundaries, and a set of reusable skills for use cases, user stories, and diagrams. See exactly how CLAUDE.md and SKILL.md divide the work, one always loaded, one pulled in only when needed, and why that separation is what keeps the agent predictable.

Two messy meeting notes go in, structured use cases and user stories come out, complete with flowcharts and a business-analyst AI that catches a contradiction between stakeholders before you ever would. Watch the whole pipeline run end to end in Claude, then see why the AI's first draft is a starting point for human review, not the finish line.

Watch a data-definition skill turn approved user stories into entities and an entity-relationship diagram, strictly refusing to invent anything not already grounded in your scenarios. Then confront a sharper problem: AI is a smart team member with amnesia between sessions, and see what it takes to keep multiple data definitions from silently drifting apart.

Can you run Spec-Kit directly inside your collaborative workspace folder and keep your custom AI persona too? Technically yes, but see exactly how competing CLAUDE.md files stack up and silently conflict, and why keeping the two workspaces in separate folders saves you a debugging headache down the road.

Before running a single Spec-Kit command, make sure the foundation is actually solid. Verify that business objectives and the technical baseline are both properly wired into the constitution, and pick up the recurring rule that carries through the rest of the deep path: never trust AI-generated output without reviewing it yourself.

This time the specify command doesn't run on a vague prompt, it runs on a fully reviewed user story pulled straight from the collaborative workspace. Watch it happen, then see why asking the AI to grade its own comparison against the source document is exactly the shortcut healthy skepticism warns you about.

Clarify a Spec-Kit specification and you've just created a second document that can drift from the source of truth in your collaborative workspace, so how do you keep them in sync? Confront the AI paradox head-on: generation gets faster, but review time never disappears, and every AI-to-AI handoff is one more chance for something to quietly go sideways.

Run the plan command and watch Context7 quietly reach out for live documentation, exactly as the constitution instructed, then feed your own data definitions back in to sharpen the generated data model. It's the moment theory and tooling finally click together into one coherent technical plan.

What happens when your company demands a technical design document in its own format, one Spec-Kit doesn't natively produce? Instead of hacking Spec-Kit's internal templates, build a custom skill that converts its plan output into exactly the document your organization already expects, without touching the core workflow at all.

The plan is locked, so now it gets broken into concrete tasks, and the optional analyze command gets one last shot at catching contradictions across the spec, plan, and tasks before code gets written. Just remember, this is AI reviewing AI, useful as a starting point, but never a substitute for your own final pass.

Every theory lesson, every reviewed document, every clarified specification has been building toward this single command. Watch the deep path finally produce working code, and see why "it compiles" is still nowhere near the same thing as "it's ready to ship."

Implementation's done, but how do you know the code actually matches what you spec'd? The optional converge command closes that loop, auditing the result against spec, plan, and tasks and auto-queuing any gaps for another implement pass, looping until nothing's missing.

The AI followed the requirement exactly as written, never questioning whether it made business sense. Trace one unusual requirement back through the chain and see how skipping human review lets a quiet mismatch harden into costly rework.

A test scenario tells you what to verify, but someone still has to write the code that actually runs it. Watch an AI skill turn test cases straight into executable K6 scripts, tracing every assertion back to the OpenAPI contract, and flagging with a precise TODO the moment it hits a gap it can't fill on its own.

A document that takes AI ten minutes to produce can look more polished than one you'd spend two hours writing yourself, and that's exactly the trap. Hear a real, opinionated account of using Spec-Kit in rewl life.

Not every feature belongs in one Spec-Kit run, and knowing when to split, when a five-minute manual fix beats a full specification cycle, and when Spec-Kit is simply the wrong tool for the job separates engineers who ship reliable software from those fighting the tool. Close out the deep path with the hard-won judgment calls that turn Spec-Kit from a neat demo into something you'd actually trust in production.