/
Feature Development Workshop

Feature Development Workshop

 

This workshop teaches you how to use GitHub Copilot and Spec Kit to design, plan, and implement a real feature in an existing codebase using Spec Driven Development (SDD).

By the end of this workshop, you will:

  • Apply Spec Driven Development to design and deliver features with AI

  • Use Spec Kit to turn a plain-English feature idea into requirements, a technical plan, and executable tasks

  • Integrate MCP servers (Jira, GitHub, Figma) to enrich specs with real product and design context

  • Implement a complete feature using GitHub Copilot Agent mode

Pre-requisites: GitHub Copilot with Agent mode (or equivalent AI coding assistant), an existing codebase, a feature idea to implement, and optionally a Jira or GitHub issue (ideally with Figma design links); otherwise, a detailed written description of the feature.

Introduction to Spec Driven Development

Spec Driven Development (SDD) is an approach to building software where you start by clearly defining what you want to build before deciding how to build it. Instead of immediately writing code, you first create a plain-English specification that describes the feature’s purpose, behavior, constraints, and how it fits into the existing system.

This spec then becomes the foundation for everything that follows. It is progressively refined into explicit requirements, a technical design and implementation plan, and finally a set of concrete tasks. Each step adds precision while preserving the original intent, creating a clear line from product idea to shipped code.

SDD is especially powerful when working with AI coding assistants. AI performs best when given clear context, goals, and constraints. A well-written spec provides that context, dramatically improving the quality, consistency, and correctness of the code the AI produces. Instead of prompting the AI to “write some code,” you guide it through a structured reasoning process.

By separating design from implementation, SDD also reduces common AI pitfalls:

  • Hallucinated requirements or architecture

  • Misalignment with existing codebases

  • Rework caused by unclear intent or missing constraints

 

In practice, SDD trades a small amount of upfront design time for significantly better AI output and smoother feature delivery—especially in real-world, non-trivial codebases.

 

In this workshop, you’ll use Spec Driven Development as a collaboration model with AI — letting the AI help design the solution, validate assumptions, generate tests, and implement code — while you stay focused on intent, correctness, and decision-making.

Traditional AI Coding

Spec Driven Development

Traditional AI Coding

Spec Driven Development

Starts with code

Starts with intent

Implicit requirements

Explicit requirements

AI guesses context

AI is given structured context

Frequent rework

Fewer surprises, better alignment

Harder to scale to large features

Scales well to complex systems

Introduction to Spec Kit

In this section, you’ll learn about a popular framework for implementing Spec Driven Development, Spec Kit. You’ll then augment the process to integrate it with MCP servers so you can read feature descriptions from Jira/GitHub issues.

Start here to get learn the basics about Spec Kit and get it set up in your codebase

MCP Integration

Once you have Spec Kit set up in your codebase and you’ve created a constitution. The next step is to run through the full SDD workflow, where you’ll generate an actual feature.

One thing that’s good to do before you begin is to connect Spec Kit with a project management platform like Jira or GitHub. This will allow you to source feature descriptions directly from the source.

Spec Kit has a /speckit.specify command that allows you to define the feature you want to implement, and then creates a spec.md file along with detailed requirements.

Ex.

/speckit.specify generate a new feature in the codebase which allows users to change their profile picture.

This is the simplest way to kick off the spec creation process. However often times, you’ll have a detailed ticket in Jira or GitHub which describes the feature you want to implement, and you’ll want to pass /speckit.specify more context than can fit into a few sentences in a prompt.

This is where MCP comes in. MCP allows your Coding agent to connect to external services like Jira or GitHub and read tickets and inspect linked assets like Figma designs.

✏️ MCP Setup in VS Code

  1. Create a .vscode/mcp.json file.

  1. This should be created in the .vscode folder at the root directory of your project.

  1. Populate it with the following JSON initially

{ "servers": { }, }

 

  1. Add MCP servers for your project management service (GitHub, Jira, etc).

  1. Open mcp.json and select “Add Server”

  2. In the dropdown menu select “Browser MCP Servers…” (or manually enter your own)

  3. Search for the MCP you want, popular options include Atlassian (Jira), GitHub, and Figma. Be sure to select “Install in Workspace”.

  4. Start the MCP servers once they’re installed (depending on the server you may need to login or provide an auth token at this stage)

 

  1. Test the MCP servers

    1. Ask Copilot to grab info about a Jira/GitHub issue or inspect a Figma design.

  2. Modify your Spec Kit /speckit.specify prompt to automatically look out for Jira/GitHub/Figma links and use the corresponding MCP servers

    1.  

✏️ Implementing a Feature

Now that Spec Kit is setup and you can integrate with MCP servers to source information about the features you want to implement, it’s time to start the SDD process. Follow along with each step below to work through the full SpecKit workflow:

  1. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1844969633 - generate a set of standards and rules for the spec driven development process

  2. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1847263243 - create a high level spec for the feature you want to implement along with a requirements document

  3. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1847689218 - answer targeted questions about the spec to help clear up any inconsistencies

  4. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1847066635 - generate a detailed technical implementation plan

  5. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1845264564 - create a list of implementation tasks that need to be completed to generate the feature

  6. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1847656463 - have the Agent analyze all of the files generate so far for consistency and completeness

  7. https://wiki.at.bitovi.com/wiki/spaces/AIEnabledDevelopment/pages/1847099402 - build the feature

8. Manually test the new feature

  • Test the new feature yourself to confirm it’s what you’re looking for.

  • If there are any minor problems with the implementation, ask the /specify.implement agent to fix them.

  • If the feature is completely different from what you expected, it can sometimes help to completely re-start the process with updated requirements. Ideally you should be checking all the documents the Agents generate as you go through the SDD process to make sure there are no major inconsistencies at the implementation phase.

Conclusion

In this workshop, you learned how to use Spec Driven Development with GitHub Spec Kit to work with AI in a more deliberate and reliable way—starting from intent, refining clarity, planning before coding, and then executing with confidence. This structured approach helps eliminate guesswork, reduces rework, and produces higher-quality AI-generated code.

By integrating real product and design context through MCP servers and running the full Spec Kit workflow end to end, you now have a repeatable process you can apply to future features and larger systems. Treat the spec as the source of truth, and use Spec Kit as both a development tool and a thinking framework for building with AI.