Debugging Workshop

Introduction

Debugging is one of the most time-consuming and cognitively demanding parts of software development. It requires understanding complex systems, tracing the flow of data, and isolating subtle issues that can hide behind layers of logic.

AI tools like GitHub Copilot can accelerate this process by acting as a collaborative debugging assistant. Instead of manually digging through logs or guessing at causes, you can guide the AI to explore, instrument, and reason about your codebase alongside you.

Why Use AI for Debugging?

• Accelerated Diagnosis:
  AI can quickly read through large portions of code, identify likely problem areas, and suggest where to look next.

• Automated Experimentation:
  It can add new logs, test cases, or run the app in different ways to gather the evidence needed to confirm or reject ideas.

• Broader Context Awareness:
  Copilot can connect clues across files, layers, and frameworks — from frontend UI issues to backend logic bugs — providing a systems-level perspective on what might be going wrong.

• Learning and Documentation:
  By explaining the reasoning behind its suggestions, AI helps engineers better understand their own systems and capture debugging knowledge for future reference.

When It Works Best

AI debugging works best when:

• You provide clear context — the AI can run the project, see the logs, and understand the runtime environment.

• You collaborate interactively — prompting the AI step by step, verifying assumptions, and refining its understanding.

• You treat it as a partner, not an oracle — the AI amplifies your reasoning rather than replaces it.

Limitations and Cautions

While AI is powerful, it isn’t infallible. It may misinterpret symptoms, suggest irrelevant changes, or fail to see issues that require deep domain context. The key is knowing when to trust it, and when to investigate further yourself.

Throughout this workshop, you’ll learn how to combine your debugging intuition with AI’s speed and breadth of understanding to diagnose and fix real bugs efficiently.

✏️ Team Formation and Setup (15 min)

Before we start debugging, you’ll form a pair programming team and set up your environment so GitHub Copilot can fully interact with your codebase. This setup ensures everyone has a bug to fix, an AI partner ready to help, and a clear workspace for collaboration.

Form Your Pair

• Partner up with another participant.

• Each pair will share a single VS Code workspace and collaborate with Copilot to identify and fix the bugs in the codebase provided.

Clone the Workshop’s Codebase

Throughout this workshop we’ll be covering several core concepts in AI-assisted debugging by fixing pre-prepared bugs in an example codebase, TaskFlow.

• GitHub - bitovi/taskflow: Example project used for training ai-enablement

TaskFlow is a full-stack web application built with NextJS. We’ve already added several branches to the codebase that contain specific types of bugs you’re likely to find in real-world development scenarios, including:

• Type check & linting bugs

• Basic Logic Bugs

• Full stack bugs that require server + client integration to debug

• Database bugs

As the workshop progresses, you’ll gain experience pair-programming with Copilot and learn the best practices for debugging in different contexts.

Prepare Your Environment

1. Install Docker Desktop

   1. IMPORTANT: If you’re installing for the first time, make sure you open the app and complete the setup steps before continuing.

2. Set up VS Code with Copilot in Agent Mode

   1. Installing the GitHub Copilot Extension in VS CodePreview

   2. Switch to Agent Mode - Switching ModesPreview

3. Install VS Code Extensions

   1. Dev Containers Extension

   2. Docker Container Tools Extension

   3. Docker Extension

4. TaskFlow Demo App Cloned & Loaded in VS Code

   1. git clone https://github.com/bitovi/taskflow.git && cd taskflow

   2. IMPORTANT: Load the taskflow folder as a single folder, not as part of a workspace.

Open

Open

5. TaskFlow loaded in a Dev Container

   1. CMD + Shift + P → Dev Containers: Reopen in Containers

      1. Open

         

   2. Or click the dialog box that should pop up

      1.  

         Open

         

6. Run the setup script

   1. npm run setup

      1. This ensures that everything is configured properly (sometimes the dev container doesn’t do this properly on the first run)

7. Copilot is able to view project files

   1. Prompt: “Tell me about my current project."

      1. It should be able to view your files and have context of the codebase.

✅ You’re Ready When…

• You’re paired up.

• TaskFlow is loaded in VS Code, and you’re able to run it.

• Copilot can “see” your project.

Once everyone is set up, we’ll use TaskFlow to explore various debugging scenarios and how Copilot can assist in each.

Core Debugging Concepts

1. Using Copilot to Run Your ProjectPreview (15 min)

   1. Learn the basics of using Copilot to configure and run your app, including running development servers, tests and other basic tasks.

2. Fixing Failing TestsPreview (15 min)

   1. Use Copilot to fix failing unit tests

3. Full-Stack Debugging with Structured LoggingPreview (15 min)

   1. Learn how to debug complex execution environments by adding detailed logging.

4. Debugging with MCP + PostgreSQLPreview (15 min)

   1. Use Copilot to directly query a PostgreSQL database to help debug complex data bugs. You’ll also learn how to integrate with MCP servers.

Conclusion

Throughout this workshop, you transformed GitHub Copilot from a simple autocomplete tool into a full engineering partner. You learned how to let Copilot run commands, read terminal output, fix failing tests, debug complex client–server interactions with unified logs, and even query a live PostgreSQL database through MCP.

Each step expanded Copilot’s capabilities—and your ability to guide it:

• You gave Copilot visibility into your project through the terminal.

• You used structured prompts to walk it through the debugging loop.

• You added logging and orchestration so it could reason across environments.

• You connected it to external systems with MCP to inspect real data.

The key lesson is that Copilot becomes most effective when you provide context, structure, and visibility. With clear prompts and the right tools, Copilot can help you diagnose issues, trace behavior across systems, validate assumptions, and fix bugs end-to-end.

You now have a full toolbox for integrating Copilot into your real debugging workflows—from unit tests to full-stack behavior to database integrity. These skills will scale with your own projects and with the rapidly growing ecosystem of MCP-powered tools.

This is a starting point—continue exploring, experimenting, and shaping Copilot into the teammate you need.