DEV Community: Microsoft Azure

Getting started with GitHub Copilot part 2, streamable responses

Chris Noring — Mon, 16 Mar 2026 20:14:28 +0000

I'm sure you've seen many AI apps where you sit tight for 30s or and you wonder if things are stuck? Not a great experience right? Yes, you're right, you deserve better, so how do we fix it?

Type your prompt> Tell me a joke
.
.
.
.
.
.
.
.
Why could I never find the atoms, cause they split..

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app
Part 2 - streamable response, you're here

Addressing the problem

By streaming the response, the response now arrives in chunks, pieces that you can show as soon as they arrive. How can we do that though and how can GitHub Copilot SDK help out?

Well, there's two things you need to do:

Enable streaming. You need to set streaming to True when you call create_session.
Listen for events that contains a chunk. Specifically, you need to listen to ASSISTANT_MESSAGE_DELTA and print out the chunk.

# 1. Enable streaming
session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

print("Starting streamed response:")

# Listen for response chunks
def handle_event(event):
    if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
        // 2. Chunk arrived, print it
        sys.stdout.write(event.data.delta_content)
        sys.stdout.flush()
    if event.type == SessionEventType.SESSION_IDLE:
        print()  # New line when done

Here's what the full application looks like:

import asyncio
import sys
from copilot import CopilotClient, PermissionHandler
from copilot.generated.session_events import SessionEventType

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({
        "model": "gpt-4.1",
        "on_permission_request": PermissionHandler.approve_all,
        "streaming": True,
    })

    print("Starting streamed response:")

    # Listen for response chunks
    def handle_event(event):
        if event.type == SessionEventType.ASSISTANT_MESSAGE_DELTA:
            sys.stdout.write(event.data.delta_content)
            sys.stdout.flush()
        if event.type == SessionEventType.SESSION_IDLE:
            print()  # New line when done

    session.on(handle_event)

    print("Sending prompt...")
    await session.send_and_wait({"prompt": "Tell me a short joke"})

    await client.stop()

if __name__ == "__main__":
    asyncio.run(main())

That's it folks, now go out and build better experiences for your users.

Get started with GitHub Copilot CLI: A free, hands-on course

Renee Noble — Thu, 05 Mar 2026 04:44:08 +0000

GitHub Copilot has grown well beyond code completions in your editor. It now lives in your terminal, too. GitHub Copilot CLI lets you review code, generate tests, debug issues, and ask questions about your projects without ever leaving the command line.

To help developers get up to speed, we put together a free, open source course: GitHub Copilot CLI for Beginners. It’s 8 chapters, hands-on from the start, and designed so you can go from installation to building real workflows in a few hours. Already have a GitHub account? GitHub Copilot CLI works with GitHub Copilot Free, which is available to all personal GitHub accounts.

In this post, I’ll walk through what the course covers and how to get started.

What GitHub Copilot CLI can do

If you haven’t tried it yet, GitHub Copilot CLI is a conversational AI assistant that runs in your terminal. You point it at files using @ references, and it reads your code and responds with analysis, suggestions, or generated code.

You can use it to:

Review a file and get feedback on code quality
Generate tests based on existing code
Debug issues by pointing it at a file and asking what’s wrong
Explain unfamiliar code or confusing logic
Generate commit messages, refactor functions, and more
Write new app features (front-end, APIs, database interactions, and more)

It remembers context within a conversation, so follow-up questions build on what came before.

What the course covers

The course is structured as 8 progressive chapters. Each one builds on the last, and you work with the same project throughout: a book collection management app. Instead of jumping between isolated snippets, you keep improving one codebase as you go.

Here’s what using GitHub Copilot CLI looks like in practice. Say you want to review a Python file for potential issues. Start up Copilot CLI and ask what you’d like done:

$ copilot
> Review @samples/book-app-project/books.py for potential improvements. Focus on error handling and code quality.

Copilot reads the file, analyzes the code, and gives you specific feedback right in your terminal.

Here are the chapters covered in the course:

Quick Start — Installation and authentication
First Steps — Learn the three interaction modes: interactive, plan, and one-shot (programmatic)
Context and Conversations — Using @ references to point Copilot at files and directories, plus session management with --continue and --resume
Development Workflows — Code review, refactoring, debugging, test generation, and Git integration
Custom Agents — Building specialized AI assistants with .agent.md files (for example, a Python reviewer that always checks for type hints)
Skills — Creating task-specific instructions that auto-trigger based on your prompt
MCP Servers — Connecting Copilot to external services like GitHub repos, file systems, and documentation APIs via the Model Context Protocol
Putting It All Together — Combining agents, skills, and MCP servers into complete development workflows
learning path image

Every command in the course can be copied and run directly. No AI or machine learning background is required.

Who this is for

The course is built for:

Developers using terminal workflows: If you’re already running builds, checking git status, and SSHing into servers from the command line, Copilot CLI fits right into that flow.
Teams looking to standardise AI-assisted practices: Custom agents and skills can be shared across a team through a project’s .github/agents and .github/skills directories.
Students and early-career developers: The course explains AI terminology as it comes up, and every chapter includes assignments with clear success criteria.

You don’t need prior experience with AI tools. If you can run commands in a terminal, you learn and apply the concepts in this course.

How the course teaches

Each chapter follows a consistent pattern: a real-world analogy to ground the concept, then the core technical material, then hands-on exercises. For instance, the three interaction modes are compared to ordering food at a restaurant. Plan mode is more like mapping your route to the restaurant before you start driving. Interactive mode is a back-and-forth conversation with a waiter. And one-shot mode (programmatic mode) is like going through the drive-through.

Later chapters use different comparisons: agents are like hiring specialists, skills work like attachments for a power drill, and MCP servers are compared to browser extensions. The goal is to provide you with a visual and mental model before the technical details land.

The course also focuses on a question that’s harder than it looks: when should I use which tool? Knowing the difference between reaching for an agent, a skill, or an MCP server takes practice, and the final chapter walks through that decision-making in a realistic workflow.

Get started

The course is free and open source. You can clone the repo, or open it in GitHub Codespaces for a fully configured environment. Jump right in, get Copilot CLI running, and see if it fits your workflow.

GitHub Copilot CLI for Beginners

For a quick reference, see the CLI command reference.

Subscribe to GitHub Insider for more developer tips and guides.

Get started with GitHub Copilot SDK, part 1

Chris Noring — Wed, 04 Mar 2026 20:48:00 +0000

Did you know GitHub Copilot now has an SDK and that you can leverage your existing license to build AI integrations into your app? No, well I hope I have you attention now.

Series on Copilot SDK

This series is about Copilot SDK and how you can leverage your existing GitHub Copilot license to integrate AI into your apps

Part 1 - install and your first app, you're here
Part 2 - streamable responses

Install

You need two pieces here to get started:

GitHub Copilot CLI
A supported runtime, which at present means either Node.js, .NET, Python or Go

Then you need to install the SDK for your chosen runtime like so:

pip install github-copilot-sdk

The parts

So what do you need to know to get started? There are three concepts:

Client, you need to create and instance of it. Additionally you need to start and stop it when you're done with it.
Session. The session takes an object where you can set things like model, system prompt and more. Also, the session is what you talk when you want to carry out a request.
Response. The response contains your LLM response.

Below is an example program using these three concepts. As you can see we choose "gpt-4.1" as model but this can be changed. See also how we pass the prompt to the function send_and_wait.

import asyncio
from copilot import CopilotClient

async def main():
    client = CopilotClient()
    await client.start()

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": "What is 2 + 2?"})

    print(response.data.content)

    await client.stop()

asyncio.run(main())

Ok, now that we know what a simple program looks like, let's make something interesting, an FAQ responder.

Your first app

An FAQ for a web page, is often a pretty boring read. A way to make that more interesting for the end user is if they can instead chat with the FAQ, let's make that happen.

Here's the plan:

Define a static FAQ
Add the FAQ as part of the prompt.
Make a request to to the LLM and print out the response.

Let's build out the code little by little. First, let's define the FAQ information.

-1- FAQ information

# faq.py

faq = {
  "warranty": "Our products come with a 1-year warranty covering manufacturing defects. Please contact our support team for assistance.",
  "return_policy": "We offer a 30-day return policy for unused products in their original packaging. To initiate a return, please visit our returns page and follow the instructions.",     
  "shipping": "We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.",
}

Next, let's add the call to the Copilot SDK

-2 Adding the LLM call


import asyncio
from copilot import CopilotClient

def faq_to_string(faq: dict) -> str:
    return "\n".join([f"{key}: {value}" for key, value in faq.items()])

async def main(user_prompt: str = "Tell me about shipping"):
    client = CopilotClient()
    await client.start()

    prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"   

    session = await client.create_session({"model": "gpt-4.1"})
    response = await session.send_and_wait({"prompt": prompt})

    print(response.data.content)

    await client.stop()

if __name__ == "__main__":
    print("My first app using the GitHub Copilot SDK!")
    print(f"[LOG] Asking the model about shipping information...")
    asyncio.run(main("Tell me about shipping"))

Note how we concatenate the FAQ data with the user's prompt:

 prompt = f"Here's the FAQ, {faq_to_string(faq)}\n\nUser question: {user_prompt}\nAnswer:"

-3- Let's run it

Now run it:

uv run faq.py

You should see output like so:

My first app using the GitHub Copilot SDK!
[LOG] Asking the model about shipping information...
We offer free standard shipping on all orders over $50. Expedited shipping options are available at checkout for an additional fee.

What's next

Check out the official docs

The JavaScript AI Build-a-thon Season 2 starts March 2!

Julia Muiruri — Wed, 25 Feb 2026 04:09:06 +0000

Most applications used by millions of people every single day are powered by JavaScript/TypeScript. But when it comes to AI, most learning resources and code samples assume you're working in Python and will leave you trying to stitch scattered tutorials together to build AI into your stack.

The JavaScript AI Build-a-thon is a free, hands-on program designed to close that gap. Over the course of four weeks (March 2 - March 31, 2026), you'll move from running AI 100% on-device (Local AI), to designing multi-service, multi-agentic systems, all in JavaScript/ TypeScript and using tools you are already familiar with.
The series will culminate in a hackathon, where you will create, compete and turn what you'll have learnt into working projects you can point to, talk about and extend.

How the program works!

The program is organized around 2 phases: -

Phase I: Learn & Skill Up Schedule (Mar 2 - 13)

Self-paced quests that teach core AI patterns,
Interactive Expert-led sessions on Microsoft Reactor (Livestreams) and Discord (Office hours & QnA)

Day/Time (PT)	Topic	Links to join
Mon 3/2, 8:00 AM PST	Local AI Development with Foundry Local	Livestream Discord Office Hour
Wed 3/4, 8:00 AM PST	End-to-End Model Development on Microsoft Foundry	Livestream Discord Office Hour
Fri 3/6, 9:00 AM PST	Advanced RAG Deep Dive + Guided Project	Livestream Discord Office Hour
Mon 3/9, 8:00 AM PST	Design & Build an Agent E2E with Agent Builder (AITK)	Livestream Discord Office Hour
Wed 3/11, 8:00 AM PST	Build, Scale & Govern AI Agents + Guided project	Livestream Discord Office Hour

The Build-a-thon prioritizes practical learning, so you'll complete 2 guided projects by the end of this phase:-

1. A Local Serverless AI chat with RAG
Concepts covered include: -

RAG Architecture
RAG Ingestion pipeline
Query & Retrieval
Response Generation (LLM Chains)

2. A Burger Ordering AI Agent
Concepts covered include: -

Designing AI Agents
Building MCP Tools (Backend API Design)

Phase II: Global Hack! (Mar 13 - 31)

Product demo series to showcase the latest product features that will accelerate your builder experience
A Global hackathon to apply what you learn into real, working AI solutions

This is where you'll build something that matters using everything learnt in the quests, and beyond, to create an AI-powered project that solves a real problem, delights users, or pushes what's possible.

The hackathon launches on March 13, 2026. Full details on registration, submission, judging criteria, award categories, prizes, and the hack phase schedule will be published when the hack goes live. Stay tuned!

But, here's what we can tell you now:

🏆 6 award categories
💻 Product demo showcases throughout the hack phase to keep you building with the latest tools
👥 Teams of up to 4 or solo. Your call

Start Now (Join the Community)

Join our community to connect with other participants and experts from Microsoft &. GitHub to support your builder journey.

Foundry Discord (#js-ai-build-a-thon channel): Our platform for office hours, live QnA, quick questions, community & expert support
GitHub Discussions: This is where you'll share ideas, ask questions, find teammates
Social: Share your progress online using #JSAIBuildathon

See you soon!

Build a Responsive UI through Prompt Driven Development

Cynthia Zanoni — Tue, 27 Jan 2026 07:00:00 +0000

This article is part of the Prompt Driven Development series from the VS Code YouTube channel. It is based on the video Build a Responsive UI through Prompt Driven Development and explains the concepts, tools, and workflows demonstrated when using GitHub Copilot to improve usability, responsiveness, and functionality in a web application.

🎥 Video Reference

Building a responsive user interface involves more than adjusting CSS breakpoints. It requires thinking about layout, navigation, accessibility, and interaction patterns across different screen sizes.

🏗️ Understanding the Application and Its Limitations

The application used in the video is a notes board web app that allows users to:

Create notes with checklists
Organize notes by categories
Filter notes using a sidebar

While functional on desktop, the app presents several issues:

The layout does not adapt well to smaller screens
Navigation becomes difficult on mobile
Search functionality is missing
Developer tools are hard to use due to layout constraints

These limitations define the scope of improvements to be addressed using Prompt Driven Development.

📌 Five Key Learnings from the Video

1️⃣ Prompts Should Be Specific and Context Aware

One of the strongest lessons in this video is that effective prompts are short, specific, and contextual.

Rather than describing every possible change, the prompt focuses on:

Improving mobile usability
Adjusting layout for small screens
Making buttons, forms, and text easier to interact with on touch devices

This clarity allows Copilot to generate relevant changes without unnecessary modifications.

2️⃣ Custom Chat Modes Enable Persistent Problem Solving

The workflow uses a custom chat mode called Beast Mode, designed to keep working until all tasks are completed.

In this mode, Copilot:

Analyzes the application
Creates a task list
Executes changes incrementally
Verifies results by running the local server

This demonstrates how custom chat modes can encode behavior, not just instructions, making complex UI changes more manageable.

3️⃣ Responsive Design Requires Coordinated Changes

Making the UI responsive is not limited to a single layer.

The video shows Copilot updating:

HTML templates by adding or validating the viewport meta tag
CSS with media queries and grid adjustments
JavaScript to support layout and interaction changes

Prompt Driven Development helps coordinate these changes across files while preserving consistency.

4️⃣ Progressive Enhancement Improves Usability Across Devices

After improving the base responsive layout, the workflow introduces device specific navigation.

On mobile:

The sidebar is replaced with a category dropdown

On desktop:

The original sidebar remains available

Copilot applies conditional logic and styling so the interface adapts naturally based on screen size, improving usability without duplicating functionality.

5️⃣ Prompt Driven Development Goes Beyond UI Changes

The video demonstrates that Prompt Driven Development is not limited to layout improvements.

Additional enhancements include:

Implementing real time search for filtering notes by title or content
Displaying user friendly messages when no results match
Generating a README file using a reusable custom prompt

This shows how prompts can drive not only UI changes, but also features, documentation, and developer experience.

🛠️ Tools and Features Demonstrated

The workflow combines multiple GitHub Copilot and VS Code capabilities:

Custom Chat Modes for persistent execution
Custom Instructions with accessibility guidance
Agent Mode for multi step changes
Auto approve commands to run the local server
Custom Prompts to generate documentation
Source Control integration for commits and pushes

Together, these tools enable a cohesive and efficient development loop.

Conclusion

This example demonstrates how Prompt Driven Development can be applied to user interface design and frontend evolution, not just backend logic or refactoring.

By combining specific prompts, reusable instructions, and custom chat modes, developers can iteratively improve responsiveness, usability, and functionality while maintaining control over changes.

Prompt Driven Development turns UI improvements into a structured, repeatable process, helping teams deliver better experiences across devices with less friction.

🐛 Fix a Chat App with Copilot Chat using Prompt Driven Development

Cynthia Zanoni — Tue, 20 Jan 2026 07:00:00 +0000

This article is part of the Prompt Driven Development series from the VS Code YouTube channel. It is based on the video Fix a Chat App with Copilot Chat and explains the concepts, tools, and workflows demonstrated when using GitHub Copilot to diagnose and fix issues in an existing application.

🎥 Video Reference

Fixing bugs in an existing application often requires context switching between documentation, code, logs, tests, and tooling. As applications grow more complex, even small issues can require navigating a large surface area of code.

🏗️ Understanding the Application Context

The application demonstrated in the video is a chat application built using Retrieval Augmented Generation.

At a high level, the app:

Answers questions based on a knowledge base
Includes citations in responses
Acts as an internal HR style chatbot for a fictional company

Both the frontend and backend are running locally and the project contains multiple directories and integrations. Rather than manually inspecting every folder, the workflow begins by asking Copilot to explain the architecture.

Using Ask mode, Copilot provides a concise overview of:

The RAG architecture
Frontend technologies such as React and TypeScript
Backend services written in Python
Search, ingestion, deployment, and testing components

This step demonstrates how prompts can quickly establish situational awareness before any changes are made.

🎯 Identifying and Fixing an Accessibility Issue

The first issue addressed in the video is an accessibility problem reported by users.

An accessibility scanning tool is used to analyze the UI, immediately identifying multiple issues. A screenshot of the results is taken and passed directly to GitHub Copilot Chat running in agent mode.

Key aspects of this workflow include:

Uploading visual context through a screenshot
Allowing the agent to read and reason about the image
Letting the agent inspect relevant files before making changes

Copilot proposes fixes and presents them as diffs, allowing the developer to review changes before accepting them. Once applied, the application is rebuilt and rescanned, resulting in zero remaining accessibility issues.

This demonstrates how multimodal prompting can significantly reduce time spent diagnosing UI related problems.

📌 Five Key Learnings from the Video

1️⃣ Start by Asking Questions, Not Making Changes

The workflow begins with Ask mode, not agent mode.

Before editing anything, Copilot is used to explain the architecture at a high level. This reinforces an important principle: Prompt Driven Development values understanding before execution.

2️⃣ Visual Context Improves Debugging Accuracy

By uploading a screenshot of accessibility issues, the agent can directly reference what the user sees.

This approach reduces ambiguity and enables Copilot to propose targeted fixes rather than generic suggestions.

3️⃣ Custom Chat Modes Enable Specialized Workflows

The video introduces a custom chat mode called Fixer.

This mode defines:

A preferred model
Allowed tools, including MCP servers
Instructions focused on minimal fixes and verification

By encoding these expectations once, future bug fixes become more consistent and require less repeated instruction.

4️⃣ External Context Can Be Integrated Seamlessly

For more complex issues, the workflow pulls data from GitHub issues using an MCP server.

Copilot:

Fetches the issue description
Locates the relevant code
Updates both implementation and tests
Verifies changes by running the test suite

This shows how Prompt Driven Development can span code, issues, and tests in a single flow.

5️⃣ Validation Is a First Class Step

Fixes are not considered complete until:

Tests are executed
Results are reviewed
Behavior is verified

Only after successful validation are changes committed, a branch created, and a pull request opened. The workflow mirrors standard engineering practices, with AI accelerating execution rather than bypassing safeguards.

🛠️ Tools and Features Demonstrated

The video showcases how several GitHub Copilot and VS Code features work together:

Ask Mode for exploration and understanding
Agent Mode for editing, testing, and iteration
Custom Chat Modes for repeatable fixing strategies
MCP Servers for GitHub and tool integration
Test Runner Integration for automated verification
GitHub CLI for branch creation and pull requests

Together, these features support a cohesive and end to end debugging workflow.

Conclusion

This example demonstrates how Prompt Driven Development can be applied effectively to debugging and maintenance tasks, not just feature development.

By combining structured prompts, rich context, and continuous validation, developers can fix issues faster while maintaining confidence in the results.

Rather than replacing developer judgment, GitHub Copilot acts as a powerful collaborator, helping navigate complexity and reduce repetitive work while keeping engineering standards intact.

Refactor an Existing Codebase using Prompt Driven Development

Cynthia Zanoni — Tue, 13 Jan 2026 07:00:00 +0000

This article is part of the Prompt Driven Development series from the VS Code YouTube channel. It is based on the video Refactor an Existing Codebase using Prompt Driven Development and explains the concepts, decisions, and workflows demonstrated during a real refactoring scenario using Visual Studio Code and GitHub Copilot.

🎥 Video Reference

Refactoring an existing codebase is often more challenging than building something new. It requires understanding current behavior, preserving functionality, and improving structure without introducing regressions.

🏗️ Understanding the Refactoring Context

Before any prompting begins, the video emphasizes the importance of understanding the system as it exists today.

The demonstrated project is an inventory API built with:

Azure Functions using a flexible consumption plan
FastAPI with Python
Cosmos DB using the NoSQL API

The API exposes endpoints for managing products and categories, including batch operations. Before refactoring, the API is executed locally and exercised through its endpoints to confirm current behavior and establish a baseline.

This step ensures that refactoring goals are grounded in a clear understanding of functionality rather than assumptions.

🎯 Defining the Refactoring Goal

The refactoring goal is explicit and narrowly scoped.

The existing codebase contains a CRUD layer responsible for database interaction. However, this layer also includes:

Business logic
Data normalization
Validation
Exception handling

The objective is to separate responsibilities by introducing a service layer. After refactoring:

The CRUD layer should only handle direct database access
Business logic and helper functionality should live in dedicated service files

This clear separation of concerns becomes the foundation for all subsequent prompts.

📌 Five Key Learnings from the Video

1️⃣ Clear Intent Improves Prompt Quality

One of the strongest takeaways is that effective prompts start with clear intent.

Rather than issuing a vague instruction, the prompt file explicitly defines:

Which directories must be analyzed
Which files contain mixed responsibilities
What logic should remain in the CRUD layer
What logic should move to the service layer

This level of specificity enables the AI to reason about architectural changes rather than making superficial edits.

2️⃣ Prompt Files Enable Structured Refactoring

The video demonstrates the use of a prompt file to manage the refactoring task.

The prompt file:

Aggregates all relevant context
Defines goals and constraints
Acts as a reusable refactoring recipe

By running this prompt in agent mode, the AI can perform multi step operations such as reading files, creating new directories, moving logic, and updating references across the codebase.

3️⃣ Observability Is Essential During AI Assisted Refactoring

Refactoring is not treated as a passive operation.

Throughout the process, the developer actively monitors:

Task lists generated by the agent
Checkpoints indicating progress
Modified files and newly created directories
The Problems panel for errors and warnings

This reinforces an important principle: Prompt Driven Development assumes human oversight. AI accelerates the work, but the developer remains responsible for correctness.

4️⃣ Problems and Errors Are Part of the Workflow

As the refactor progresses, issues such as formatting errors, unused imports, and type warnings appear in the Problems panel.

Rather than fixing these manually, the AI is prompted to resolve them, using the Problems context as additional input. This iterative loop continues until blocking issues are resolved and the codebase reaches a stable state.

This demonstrates how tooling feedback can be incorporated directly into prompts.

5️⃣ Validation Completes the Refactoring Loop

Once structural changes are complete, validation begins.

The video shows:

Reviewing updated routes to confirm they now depend on services instead of CRUD logic
Running the API locally
Executing create, update, and delete operations
Verifying expected responses

This reinforces that AI assisted refactoring must meet the same quality bar as any other change. Testing and verification remain mandatory.

🛠️ Supporting Techniques Demonstrated

Several VS Code and Copilot features support this workflow:

Copilot Instructions to provide consistent context across prompts
Prompt Files to manage complex refactoring tasks
Agent Mode for multi step execution
Problems Context to guide iterative fixes
Model selection to evaluate different LLM behaviors

Together, these techniques enable a refactor that is structured, transparent, and repeatable.

Conclusion

This refactoring example shows that Prompt Driven Development can be effectively applied to existing codebases, not just greenfield projects.

By treating prompts as structured artifacts and maintaining continuous validation, developers can use AI to accelerate refactoring while preserving control, clarity, and code quality.

Prompt Driven Development does not replace engineering discipline. It reinforces it.

Introduction to Prompt-Driven Development

Cynthia Zanoni — Mon, 05 Jan 2026 07:00:00 +0000

This article is part of the Prompt Driven Development series from the VS Code YouTube channel. It is based on the video Introduction to Prompt Driven Development and explains the concepts and workflows demonstrated, with a focus on how prompt driven development can be applied in practice using Visual Studio Code and GitHub Copilot.

🎥 Video Reference

As AI tools become increasingly capable, developers are not only writing code differently but also rethinking how software is designed and built.

Terms such as vibe coding, prompt engineering, and prompt driven development are often used interchangeably. However, they represent distinct levels of structure, intent, and repeatability. Understanding these differences is essential to choosing the right approach for exploration, learning, or production ready systems.

This article explains these approaches and then highlights the key technical learnings demonstrated in the video.

🧠 Coding Styles in the Age of AI

✨ Vibe Coding

Vibe coding refers to an intuitive and exploratory way of working with AI. Developers rely on natural language prompts and personal intuition, allowing the AI to generate code based on intent rather than explicit structure.

This style is fast, creative, and useful for experimentation, but it often produces results that are hard to reproduce or maintain. Because prompts are informal and rarely documented, consistency becomes a challenge.

🎯 Prompt Engineering

Prompt engineering introduces intention and structure. Developers design prompts carefully to guide the AI toward specific and predictable outcomes.

This approach improves reliability and reduces randomness. However, prompts are still often treated as one off inputs, used once and discarded, rather than as reusable artifacts.

Prompt Driven Development

Prompt driven development treats prompts as first class technical artifacts.

In this approach, prompts are:

Written intentionally
Refined and iterated over time
Documented and versioned
Used to guide workflows, not just outputs

Rather than interacting with AI in isolated moments, developers design processes where prompts support planning, implementation, and iteration in a repeatable way.

📌 Five Key Learnings from the Video

1️⃣ Prompts Are Part of the Codebase

One of the main ideas demonstrated is that prompts should not be ephemeral. When prompts are saved, documented, and versioned, they capture architectural intent and decision making, just like code or design documents.

Using Markdown files inside the repository makes this process lightweight and easy to share.

2️⃣ Re Prompting Is an Expected and Valuable Practice

The video clearly shows that the first prompt is rarely sufficient.

Prompt driven development assumes iteration. Prompts improve through feedback, refinement, and clarification. This process is similar to refactoring code and should be treated with the same discipline.

Re prompting is not a failure. It is part of the workflow.

3️⃣ Documentation Can Drive Implementation

Instead of treating documentation as an afterthought, the workflow demonstrated uses documentation as the starting point for implementation.

By referencing a structured Markdown document, the AI can scaffold an application more consistently, reducing improvisation and making the process easier to reproduce.

4️⃣ AI Assisted Development Still Requires Validation

Even with AI generating code, traditional engineering practices remain essential.

The video reinforces the habit of:

Installing dependencies locally
Running and testing the application
Reviewing behavior before committing changes

Prompt driven development enhances productivity, but it does not replace testing or validation.

5️⃣ Context Improves AI Output

Providing richer context leads to better results. The video demonstrates this through:

Custom Chat Modes, which define purpose and output expectations
Copilot Vision, which uses screenshots to reason about UI changes

By narrowing context and constraints, developers can guide AI systems more effectively and reduce ambiguity.

🛠️ Applying These Ideas in Practice

The workflow shown in the video combines several VS Code features to support prompt driven development:

GitHub Copilot for ideation and implementation
Markdown files for prompt documentation
Custom Chat Modes for repeatable workflows
Copilot Vision for context aware UI changes

Together, these tools help transform AI interactions into a structured and intentional development process.

Conclusion

Prompt driven development offers a practical way to integrate AI into software engineering without sacrificing rigor.

By treating prompts as structured, reusable artifacts, developers gain:

Clearer workflows
Better documentation
More consistent outcomes
Easier collaboration

For teams and individuals looking to move beyond ad hoc AI usage, prompt driven development provides a scalable and repeatable model grounded in existing engineering best practices.

Host Your Node.js MCP Server on Azure Functions in 1 Simple Step

Yohan Lasorsa — Tue, 09 Dec 2025 15:44:53 +0000

Building AI agents with the Model Context Protocol (MCP) is powerful, but when it comes to hosting your MCP server in production, you need a solution that's reliable, scalable, and cost-effective. What if you could deploy your regular Node.js MCP server to a serverless platform that handles scaling automatically while you only pay for what you use?

Let's explore how Azure Functions now supports hosting MCP servers built with the official Anthropic MCP SDK, giving you serverless scaling with almost no changes in your code.

Grab your favorite hot beverage, and let's dive in!

TL;DR key takeaways

Azure Functions now supports hosting Node.js MCP servers using the official Anthropic SDK
Only 1 simple configuration needed: adding host.json file
Currently supports HTTP Streaming protocol with stateless servers
Serverless hosting means automatic scaling and pay-per-use pricing
Deploy with one command using Infrastructure as Code

What will you learn here?

Understand how MCP servers work on Azure Functions
Configure a Node.js MCP server for Azure Functions hosting
Test your MCP server locally and with real AI agents
Deploy your MCP server with Infrastructure as Code and AZD

Reference links for everything we use

Model Context Protocol - Official MCP documentation
Azure Functions - Serverless compute platform
Anthropic MCP SDK - Official TypeScript SDK
Azure Developer CLI - One-command deployment tool
Full sample project - Complete burger ordering system with MCP
Simple example - Minimal MCP server starter
GitHub Copilot prompt helper - Automated setup by Anthony Chu

Requirements

Node.js 22 or higher
Azure account (free signup, or if you're a student, get free credits here)
Azure Developer CLI (for deployment)
GitHub account (optional, for using Codespaces)

What is MCP and why does it matter?

Model Context Protocol is an open standard that enables AI models to securely interact with external tools and data sources. Instead of hardcoding tool integrations, you build an MCP server that exposes capabilities (like browsing a menu, placing orders, or querying a database) as tools that any MCP-compatible AI agent can discover and use. MCP is model-agnostic, meaning it can work with any LLM that supports the protocol, including models from Anthropic, OpenAI, and others. It's also worth noting that MCP supports more than just tool calls, though that's its most common use case.

The challenge? Running MCP servers in production requires infrastructure. You need to handle scaling, monitoring, and costs. That's where Azure Functions comes in.

🚨 Free course alert! If you're new to MCP, check out the MCP for Beginners course to get up to speed quickly.

Why Azure Functions for MCP servers?

Azure Functions is a serverless compute platform that's perfect for MCP servers:

Zero infrastructure management: No servers to maintain
Automatic scaling: Handles traffic spikes seamlessly
Cost-effective: Pay only for actual execution time (with generous free grant)
Built-in monitoring: Application Insights integration out of the box
Global distribution: Deploy to regions worldwide

The new Azure Functions support means you can take your existing Node.js MCP server and deploy it to a production-ready serverless environment with minimal changes. This comes up as an additional option for native Node.js MCP hosting, but you can still use the Azure Functions MCP bindings that were available before.

1 simple step to enable Functions hosting

Let's break down what you need to add to your existing Node.js MCP server to run it on Azure Functions. I'll use a real-world example from our burger ordering system.

If you already have a working Node.js MCP server, you can just follow this to make it compatible with Azure Functions hosting.

Step 1: Add the `host.json` configuration

Create a host.json file at the root of your Node.js project:

{
  "version": "2.0",
  "configurationProfile": "mcp-custom-handler",
  "customHandler": {
    "description": {
      "defaultExecutablePath": "node",
      "arguments": ["lib/server.js"]
    },
    "http": {
      "DefaultAuthorizationLevel": "anonymous"
    },
    "port": "3000"
  }
}

Note: Adjust the arguments array to point to your compiled server file (e.g., lib/server.js or dist/server.js), depending on your build setup. You can also change the port if needed to match your server configuration.

The hosts.json file holds metadata configuration for the Functions runtime. The most important part here is the customHandler section. It configures the Azure Functions runtime to run your Node.js MCP server as a custom handler, which allows you to use any HTTP server framework (like Express, Fastify, etc.) without modification (tip: it can do more than MCP servers! 😉).

There's no step 2 or 3. That's it! 😎

Note: We're not covering the authentication and authorization aspects of Azure Functions here, but you can easily add those later if needed.

Real-world example: Burger MCP Server

Let's look at how this works in practice with a burger ordering MCP server. This server exposes 9 tools for AI agents to interact with a burger API:

get_burgers - Browse the menu
get_burger_by_id - Get burger details
place_order - Place an order
get_orders - View order history
And more...

Here's the complete server implementation using Express and the MCP SDK:

import express, { Request, Response } from 'express';
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
import { getMcpServer } from './mcp.js';

const app = express();
app.use(express.json());

// Handle all MCP Streamable HTTP requests
app.all('/mcp', async (request: Request, response: Response) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
  });

  // Connect the transport to the MCP server
  const server = getMcpServer();
  await server.connect(transport);

  // Handle the request with the transport
  await transport.handleRequest(request, response, request.body);

  // Clean up when the response is closed
  response.on('close', async () => {
    await transport.close();
    await server.close();
  });

  // Note: error handling not shown for brevity
});

// The port configuration
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Burger MCP server listening on port ${PORT}`);
});

The MCP tools are defined using the official SDK:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';

export function getMcpServer() {
  const server = new McpServer({
    name: 'burger-mcp',
    version: '1.0.0',
  });

  server.registerTool(
    'get_burgers',
    { description: 'Get a list of all burgers in the menu' },
    async () => {
      const response = await fetch(`${burgerApiUrl}/burgers`);
      const burgers = await response.json();
      return {
        content: [{
          type: 'text',
          text: JSON.stringify(burgers, null, 2)
        }]
      };
    }
  );

  // ... more tools
  return server;
}

As you can see, the actual implementation of the tool is forwarding an HTTP request to the burger API and returning the result in the MCP response format. This is a common pattern for MCP tools in enterprise contexts, that act as wrappers around one or more existing APIs.

Current limitations

Note that this Azure Functions MCP hosting currently has some limitations: it only supports stateless servers using the HTTP Streaming protocol. The legacy SSE protocol is not supported as it requires stateful connections, so you'll either have to migrate your client to use HTTP Streaming or use another hosting option, like using containers for example.

For most use cases, HTTP Streaming is the recommended approach anyway as it's more scalable and doesn't require persistent connections. Stateful MCP servers comes with additional complexity challenges and have limited scalability if you need to handle many concurrent connections.

Testing the MCP server locally

First let's run the MCP server locally and play a bit with it.

If you don't want to bother with setting up a local environment, you can use the following link or open it in a new tab to launch a GitHub Codespace:

Create Codespace

This will open a VS Code environment in your browser with the repo already cloned and all the tools installed and ready to go. Otherwise you can just clone the repo.

Once you have the code ready, open a terminal and run:

# Install dependencies
npm install

# Start the burger MCP server and API
npm start

This will start multiple services locally, including the Burger API and the MCP server, which will be available at http://localhost:3000/mcp. This may take a few seconds, wait until you see this message in the terminal:

🚀 All services ready 🚀

We're only interested in the MCP server for now, so let's focus on that.

Using MCP Inspector

The easiest way to test the MCP server is with the MCP Inspector tool:

$ npx -y @modelcontextprotocol/inspector

Open the URL shown in the console in your browser, then:

Set transport type to Streamable HTTP
Enter your local server URL: http://localhost:3000/mcp
Click Connect

After you're connected, go to the Tools tab to list available tools. You can then try the get_burgers tool to see the burger menu.

Using GitHub Copilot (with remote MCP)

Configure GitHub Copilot to use your deployed MCP server by adding this to your project's .vscode/mcp.json:

{
  "servers": {
    "burger-mcp": {
      "type": "http",
      "url": "http://localhost:3000/mcp"
    }
  }
}

Click on "Start" button that will appear in the JSON file to activate the MCP server connection.

Now you can use Copilot in agent mode and ask things like:

"What spicy burgers do you have?"
"Place an order for two cheeseburgers"
"Show my recent orders"

Copilot will automatically discover and use the MCP tools! 🎉

Tip: If Copilot doesn't call the burger MCP tools, try checking if it's enabled by clicking on the tool icon in the chat input box and ensuring that "burger-mcp" is selected. You can also force tool usage by adding #burger-mcp in your prompt.

(Bonus) Deploying to Azure with Infrastructure as Code

Deploying an application to Azure is usually not the fun part, especially when it involves multiple resources and configurations.
With the Azure Developer CLI (AZD), you can define your entire application infrastructure and deployment process as code, and deploy everything with a single command.

If you've used the automated setup with GitHub Copilot, you should already have the necessary files. Our burger example also comes with these files pre-configured. The MCP server is defined as a service in azure.yaml, and the files under the infra folder defines the Azure Functions app and related resources.

Here's the relevant part of azure.yaml that defines the burger MCP service:

name: mcp-agent-langchainjs

services:
  burger-mcp:
    project: ./packages/burger-mcp
    language: ts
    host: function

While the infrastructure files can look intimidating at first, you don't need to understand all the details to get started. There are tons of templates and examples available to help you get going quickly, the important part is that everything is defined as code, so you can version control it and reuse it.

Now let's deploy:

# Login to Azure
azd auth login

# Provision resources and deploy
azd up

Pick your preferred Azure region when prompted (if you're not sure, choose East US2), and voilà! In a few minutes, you'll have a fully deployed MCP server running on Azure Functions.

Once the deployment is finished, the CLI will show you the URL of the deployed resources, including the MCP server endpoint.

Example projects

The burger MCP server is actually part of a larger example project that demonstrates building an AI agent with LangChain.js, that uses the burger MCP server to place orders. If you're interested in the next steps of building an AI agent on top of MCP, this is a great resource as it includes:

AI agent web API using LangChain.js
Web app interface built with Lit web components
MCP server on Functions (the one we just saw)
Burger ordering API (used by the MCP server)
Live order visualization
Complete Infrastructure as Code, to deploy everything with one command

But if you're only interested in the MCP server part, then you might want to look at this simpler example that you can use as a starting point for your own MCP servers: mcp-sdk-functions-hosting-node is a server template for a Node.js MCP server using TypeScript and MCP SDK.

What about the cost?

Azure Functions Flex Consumption pricing is attractive for MCP servers:

Free grant: 1 million requests and 400,000 GB-s execution time per month
After free grant: Pay only for actual execution time
Automatic scaling: From zero to hundreds of instances

The free grant is generous enough to allow running a typical MCP server with moderate usage, and all the experimentation you might need. It's easy to configure the scaling limits to control costs as needed, with an option to scale down to zero when idle. This flexibility is why Functions is my personal go-to choice for TypeScript projects on Azure.

Wrap up

Hosting MCP servers on Azure Functions gives you the best of both worlds: the simplicity of serverless infrastructure and the power of the official Anthropic SDK. With just one simple configuration step, you can take your existing Node.js MCP server and deploy it to a production-ready, auto-scaling platform.

The combination of MCP's standardized protocol and Azure's serverless platform means you can focus on building amazing AI experiences instead of managing infrastructure. Boom. 😎

Star the repos ⭐️ if you found this helpful! Try deploying your own MCP server and share your experience in the comments. If you run into any issues or have questions, you can reach for help on the Azure AI community on Discord.

Serverless MCP Agent with LangChain.js v1 — Burgers, Tools, and Traces 🍔

Yohan Lasorsa — Tue, 21 Oct 2025 16:09:46 +0000

AI agents that can actually do stuff (not just chat) are the fun part nowadays, but wiring them cleanly into real APIs, keeping things observable, and shipping them to the cloud can get... messy. So we built a fresh end‑to‑end sample to show how to do it right with the brand new LangChain.js v1 and Model Context Protocol (MCP). In case you missed it, MCP is a recent open standard that makes it easy for LLM agents to consume tools and APIs, and LangChain.js, a great framework for building GenAI apps and agents, has first-class support for it.

This new sample gives you:

A LangChain.js v1 agent that streams its result, along reasoning + tool steps
An MCP server exposing real tools (burger menu + ordering) from a business API
A web interface with authentication, sessions history, and a debug panel (for developers)
A production-ready multi-service architecture
Serverless deployment on Azure in one command (azd up)

Yes, it’s a burger ordering system. Who doesn't like burgers? Grab your favorite beverage ☕, and let’s dive in for a quick tour!

TL;DR key takeaways

New sample: full-stack Node.js AI agent using LangChain.js v1 + MCP tools
Architecture: web app → agent API → MCP server → burger API
Runs locally with a single npm start, deploys with azd up
Uses streaming (NDJSON) with intermediate tool + LLM steps surfaced to the UI
Ready to fork, extend, and plug into your own domain / tools

What will you learn here?

What this sample is about and its high-level architecture
What LangChain.js v1 brings to the table for agents
How to deploy and run the sample
How MCP tools can expose real-world APIs

Reference links for everything we use

Use case

You want an AI assistant that can take a natural language request like “Order two spicy burgers and show me my pending orders” and:

Understand intent (query menu, then place order)
Call the right MCP tools in sequence, calling in turn the necessary APIs
Stream progress (LLM tokens + tool steps)
Return a clean final answer

Swap “burgers” for “inventory”, “bookings”, “support tickets”, or “IoT devices” and you’ve got a reusable pattern!

Sample overview

Before we play a bit with the sample, let's have a look at the main services implemented here:

Service	Role	Tech
Agent Web App (`agent-webapp`)	Chat UI + streaming + session history	Azure Static Web Apps, Lit web components
Agent API (`agent-api`)	LangChain.js v1 agent orchestration + auth + history	Azure Functions, Node.js
Burger MCP Server (`burger-mcp`)	Exposes burger API as tools over MCP (Streamable HTTP + SSE)	Azure Functions, Express, MCP SDK
Burger API (`burger-api`)	Business logic: burgers, toppings, orders lifecycle	Azure Functions, Cosmos DB

Here's a simplified view of how they interact:

There are also other supporting components like databases and storage not shown here for clarity.

For this quickstart we'll only interact with the Agent Web App and the Burger MCP Server, as they are the main stars of the show here.

LangChain.js v1 agent features

The recent release of LangChain.js v1 is a huge milestone for the JavaScript AI community! It marks a significant shift from experimental tools to a production-ready framework. The new version doubles down on what’s needed to build robust AI applications, with a strong focus on agents. This includes first-class support for streaming not just the final output, but also intermediate steps like tool calls and agent reasoning. This makes building transparent and interactive agent experiences (like the one in this sample) much more straightforward.

Quickstart

Requirements

GitHub account
Azure account (free signup, or if you're a student, get free credits here)
Azure Developer CLI

Deploy and run the sample

We'll use GitHub Codespaces for a quick zero-install setup here, but if you prefer to run it locally, check the README.

Click on the following link or open it in a new tab to launch a Codespace:

Create Codespace

This will open a VS Code environment in your browser with the repo already cloned and all the tools installed and ready to go.

Provision and deploy to Azure

Open a terminal and run these commands:

# Install dependencies
npm install

# Login to Azure
azd auth login

# Provision and deploy all resources
azd up

Follow the prompts to select your Azure subscription and region. If you're unsure of which one to pick, choose East US 2.
The deployment will take about 15 minutes the first time, to create all the necessary resources (Functions, Static Web Apps, Cosmos DB, AI Models).

If you're curious about what happens under the hood, you can take a look at the main.bicep file in the infra folder, which defines the infrastructure as code for this sample.

Test the MCP server

While the deployment is running, you can run the MCP server and API locally (even in Codespaces) to see how it works. Open another terminal and run:

npm start

This will start all services locally, including the Burger API and the MCP server, which will be available at http://localhost:3000/mcp. This may take a few seconds, wait until you see this message in the terminal:

🚀 All services ready 🚀

When these services are running without Azure resources provisioned, they will use in-memory data instead of Cosmos DB so you can experiment freely with the API and MCP server, though the agent won't be functional as it requires a LLM resource.

MCP tools

The MCP server exposes the following tools, which the agent can use to interact with the burger ordering system:

Tool Name	Description
`get_burgers`	Get a list of all burgers in the menu
`get_burger_by_id`	Get a specific burger by its ID
`get_toppings`	Get a list of all toppings in the menu
`get_topping_by_id`	Get a specific topping by its ID
`get_topping_categories`	Get a list of all topping categories
`get_orders`	Get a list of all orders in the system
`get_order_by_id`	Get a specific order by its ID
`place_order`	Place a new order with burgers (requires `userId`, optional `nickname`)
`delete_order_by_id`	Cancel an order if it has not yet been started (status must be `pending`, requires `userId`)

You can test these tools using the MCP Inspector. Open another terminal and run:

npx -y @modelcontextprotocol/inspector

Then open the URL printed in the terminal in your browser and connect using these settings:

Transport: Streamable HTTP
URL: http://localhost:3000/mcp
Connection Type: Via Proxy (should be default)

Click on Connect, then try listing the tools first, and run get_burgers tool to get the menu info.

Test the Agent Web App

After the deployment is completed, you can run the command npm run env to print the URLs of the deployed services. Open the Agent Web App URL in your browser (it should look like https://<your-web-app>.azurestaticapps.net).

You'll first be greeted by an authentication page, you can sign in either with your GitHub or Microsoft account and then you should be able to access the chat interface.

From there, you can start asking any question or use one of the suggested prompts, for example try asking: Recommend me an extra spicy burger.

As the agent processes your request, you'll see the response streaming in real-time, along with the intermediate steps and tool calls. Once the response is complete, you can also unfold the debug panel to see the full reasoning chain and the tools that were invoked:

Tip: Our agent service also sends detailed tracing data using OpenTelemetry. You can explore these either in Azure Monitor for the deployed service, or locally using an OpenTelemetry collector. We'll cover this in more detail in a future post.

Wrap it up

Congratulations, you just finished spinning up a full-stack serverless AI agent using LangChain.js v1, MCP tools, and Azure’s serverless platform. Now it's your turn to dive in the code and extend it for your use cases! 😎 And don't forget to azd down once you're done to avoid any unwanted costs.

Going further

This was just a quick introduction to this sample, and you can expect more in-depth posts and tutorials soon.

Since we're in the era of AI agents, we've also made sure that this sample can be explored and extended easily with code agents like GitHub Copilot.
We even built a custom chat mode to help you discover and understand the codebase faster! Check out the Copilot setup guide in the repo to get started.

If you like this sample, don't forget to star the repo ⭐️! You can also join us in the Azure AI community Discord to chat and ask any questions.

Happy coding and burger ordering! 🍔

What’s in a Name? Fuzzy Matching for Real-World Data

Renee Noble — Fri, 17 Oct 2025 00:47:36 +0000

🎥 Watch the full PyCon AU 2025 talk here

When you work with human-entered data (registrations, surveys, customer forms, you name it!) you soon discover that people are very creative typists. Names, schools, companies, and addresses come in with abbreviations, nicknames, missing words, and typos galore.

That mess makes it hard to answer even simple questions like: “Do these two records refer to the same person?” or “How many participants came from this organisation?”

At PyCon AU 2025, I explored how different fuzzy matching techniques, from traditional algorithms to generative AI, can help make sense of that chaos.

The Fuzzy Matching Challenge

String comparison looks straightforward until you meet real-world data. “PLC Sydney” might really be “Presbyterian Ladies’ College Sydney.” “Certain Collage” is obviously a typo for “Certain College” (hopefully). And nicknames like Liz, Lizzy, and Elizabeth might all belong to the same person.

That’s where fuzzy matching comes in, using a variety of techniques we can rank how similar different non-identical words are to try and find the most likely match. But the question is, what fuzzy matching algorithms are best suited for matching what types of data? And can generative AI play a part in this matching game?

Comparing Algorithmic Approaches

I put six Python libraries to the test:

TextDistance and Python-Levenshtein – classic edit-distance approaches.
FuzzyWuzzy and RapidFuzz – hybrids that combine multiple distance metrics.
Nicknames and PyNameMatcher – specialised tools for given-name variations.

To test them, I generated around 100 fake student names with nicknames, misspellings, and swapped orderings. Then I measured how accurately each library matched them to their correct counterparts.

RapidFuzz came out ahead, matching almost every record correctly, and doing it fast! The edit-distance methods struggled most with multicultural names where order or character sets varied, and the nickname libraries were strong but less consistent overall.

When Generative AI Shines

Algorithmic fuzzy matching is fast and accurate, but it only looks at characters, not meaning. That’s where I turned to Azure OpenAI Service for a different kind of help.

By feeding in real school-name data, I found that straight out of the box GPT-5 was exceptionally good at recognising and correcting school names, especially when they were abbreviated, misspelled, or included local school nicknames.

For example, it could confidently map:

“PLC Syd” → “Presbyterian Ladies’ College Sydney”
“Cerdon Collage” → “Cerdon College”
“St Cats” → “St Catherine’s School, Waverley”

That level of contextual correction is almost impossible to achieve with pure algorithmic matching unless you maintain a custom dictionary of every possible variation. And who has time for that!

The trade-off, of course, is performance. Generative models are slower and costlier to run at scale. But when used selectively, just for ambiguous or hard-to-match cases, they can dramatically improve accuracy. And of course this is something this specifically works well for names, like schools, that are well documented on the internet – something that doesn’t apply to the names of individual school students.

Can we have the best of both worlds?

hybrid AI + Algorithmic matching!

In practice, the best results came from a hybrid approach, using traditional fuzzy-matching algorithms for most cases, and bringing in Azure OpenAI only when the names got tricky. For example, RapidFuzz could quickly match “Lizzy Wong” to “Elizabeth Wong,” while the generative model was better at reasoning through ambiguous inputs like “Sally-Anne W.” or reversed multicultural name orders. By combining both, I could match almost every student record accurately, keeping the speed of algorithmic methods while adding the contextual understanding of generative AI.

Try It Yourself

🎥 You can watch my full PyCon AU 2025 talk here:
What’s in a Name: Fuzzy Matching Techniques for Proper Nouns

📁 If you’d like to explore this further you can check out my fuzzy matching repo.

Take a look at the libraries and tool I mentioned above, they’re easy to install and experiment with in Python. If you’re already using Azure OpenAI, it’s worth testing how a small retrieval-augmented setup might complement your existing matching logic.

Chat to us!

💬 To chat more about AI solutions you can join the AI Foundry Discord, where advocates like me are chatting about the latest tools all the time.

Join the Azure AI Foundry Discord here

Good luck on your fuzzy matching adventures!

Sesiones de mentoría Ellas en Tecnología con Microsoft Reactor

Cynthia Zanoni — Tue, 16 Sep 2025 19:22:41 +0000

Ellas en Tecnología es una iniciativa de WoMakersCode en colaboración con Microsoft Reactor, creada para promover la empleabilidad, la visibilidad y el crecimiento personal de mujeres en el sector tecnológico en América Latina.

Durante cuatro encuentros virtuales y gratuitos, exploraremos herramientas y estrategias prácticas para fortalecer tu carrera, desde la creación de CVs con inteligencia artificial hasta el desarrollo de la confianza profesional.

👉 Todos los eventos serán transmitidos en vivo en español. Inscríbete aquí

👩‍💻 Aprende con especialistas

En cada sesión tendrás la oportunidad de aprender directamente de expertas en tecnología y carrera de Microsoft y NTT Data, quienes compartirán sus experiencias, consejos prácticos y estrategias para avanzar en el mercado laboral y en tu desarrollo profesional.

Una serie de transmisiones en vivo para impulsar tu desarrollo personal y profesional. Inscríbete aquí

DEV Community: Microsoft Azure

Getting started with GitHub Copilot part 2, streamable responses

Series on Copilot SDK

Addressing the problem

Links

Get started with GitHub Copilot CLI: A free, hands-on course

What GitHub Copilot CLI can do

What the course covers

Who this is for

How the course teaches

Get started

Get started with GitHub Copilot SDK, part 1

Series on Copilot SDK

Install

The parts

Your first app

What's next

The JavaScript AI Build-a-thon Season 2 starts March 2!

How the program works!

Phase I: Learn & Skill Up Schedule (Mar 2 - 13)

Phase II: Global Hack! (Mar 13 - 31)

Start Now (Join the Community)

Build a Responsive UI through Prompt Driven Development

🎥 Video Reference

🏗️ Understanding the Application and Its Limitations

📌 Five Key Learnings from the Video

1️⃣ Prompts Should Be Specific and Context Aware

2️⃣ Custom Chat Modes Enable Persistent Problem Solving

3️⃣ Responsive Design Requires Coordinated Changes

4️⃣ Progressive Enhancement Improves Usability Across Devices

5️⃣ Prompt Driven Development Goes Beyond UI Changes

🛠️ Tools and Features Demonstrated

Conclusion

🐛 Fix a Chat App with Copilot Chat using Prompt Driven Development

🎥 Video Reference

🏗️ Understanding the Application Context

🎯 Identifying and Fixing an Accessibility Issue

📌 Five Key Learnings from the Video

1️⃣ Start by Asking Questions, Not Making Changes

2️⃣ Visual Context Improves Debugging Accuracy

3️⃣ Custom Chat Modes Enable Specialized Workflows

4️⃣ External Context Can Be Integrated Seamlessly

5️⃣ Validation Is a First Class Step

🛠️ Tools and Features Demonstrated

Conclusion

Refactor an Existing Codebase using Prompt Driven Development

🎥 Video Reference

🏗️ Understanding the Refactoring Context

🎯 Defining the Refactoring Goal

📌 Five Key Learnings from the Video

1️⃣ Clear Intent Improves Prompt Quality

2️⃣ Prompt Files Enable Structured Refactoring

3️⃣ Observability Is Essential During AI Assisted Refactoring

4️⃣ Problems and Errors Are Part of the Workflow

5️⃣ Validation Completes the Refactoring Loop

🛠️ Supporting Techniques Demonstrated

Conclusion

Introduction to Prompt-Driven Development

🎥 Video Reference

🧠 Coding Styles in the Age of AI

✨ Vibe Coding

🎯 Prompt Engineering

Prompt Driven Development

📌 Five Key Learnings from the Video

1️⃣ Prompts Are Part of the Codebase

2️⃣ Re Prompting Is an Expected and Valuable Practice

3️⃣ Documentation Can Drive Implementation

4️⃣ AI Assisted Development Still Requires Validation

5️⃣ Context Improves AI Output

🛠️ Applying These Ideas in Practice

Conclusion

Host Your Node.js MCP Server on Azure Functions in 1 Simple Step

TL;DR key takeaways

What will you learn here?

Reference links for everything we use

Requirements

What is MCP and why does it matter?

Why Azure Functions for MCP servers?

1 simple step to enable Functions hosting

Step 1: Add the host.json configuration

Step 1: Add the `host.json` configuration