Session 13: Copilot Squad and AI-Accelerated NUnit 4 Migration
Date: July 17, 2026
Duration: 1 hour 9 minutes
Presenters: Zorn Xu, Stan Yang
Participants: 75+ attendees visible during the live session
Session Recording
📋 Overview
Session 13 explored how AI can support a large, real-world NUnit 4 migration through two complementary approaches. Zorn Xu presented Copilot Squad, a multi-agent delivery model that assigns explicit roles, preserves team memory, and continuously publishes a CargoWise NUnit 4 migration dashboard. Stan Yang then showed how deterministic conversion tools, reusable Agent Skills, and a domain-specific reviewer agent can automate migration work while keeping build, test, and review evidence central.
Together, the talks moved beyond “ask one assistant to write code.” The session demonstrated an engineering system in which agents divide work, exchange durable artifacts, invoke specialized tools, recover context, validate results, and surface domain-specific risks for human review.
🎯 Key Topics Covered
1. Why a Single AI Prompt Is Not Enough
One-shot prompts can be useful for isolated code generation, but a delivery system needs repeatability, traceability, shared state, quality gates, and the ability to continue across sessions. Zorn framed the migration dashboard as a long-running product rather than a single generated artifact.
Reasons to use multiple sub-agents:
- parallel acceleration across independent tasks;
- context isolation so each role receives focused information;
- specialization around data, frontend, testing, review, and publishing;
- mutual review and explicit quality gates;
- fault tolerance when one task or session fails;
- traceable decisions, handoffs, and outputs.
2. Copilot Squad as an AI Team
Copilot Squad organizes agents around roles and a lead/orchestrator rather than simply opening multiple chat windows.
| Role | Responsibility |
|---|---|
| Lead / Orchestrator | Decompose goals, assign roles, and converge on a solution |
| Scribe | Preserve decisions, session logs, and handoff notes |
| Data | Scan repositories, define JSON contracts, and validate alignment |
| Frontend | Build a readable static dashboard and charts |
| Tester | Validate outputs, edge cases, and stability |
| Reviewer | Apply quality gates, identify risks, and provide feedback |
Humans continue to own goals and judgment. The AI team works in parallel, produces drafts, preserves records, and submits its output for human validation.
3. Durable Team Memory and Reusable Assets
The Squad directory acts as the team's shared brain. It separates thread-level coordination from individual agent memory and reusable assets. Decisions and handoffs remain available after one conversation ends, allowing later runs to continue without reconstructing the entire history.
The design principles emphasized:
- one clear responsibility per agent;
- asynchronous collaboration through files and artifacts;
- layered knowledge, from shared goals to role-specific context;
- reusable scripts, schemas, and UI components;
- explicit submit, merge, automate, and review steps.
This makes collaboration sustainable and reduces dependency on a single perfect prompt or a single engineer's memory.
4. NUnit 4 Migration Dashboard
The Squad delivered a static dashboard showing NUnit migration status and history across CargoWise projects. Its architecture deliberately avoided a backend service:
- Scan CargoWise project files and shared references.
- Classify projects as fully migrated, in transition, or not migrated.
- Persist current status and history as JSON files.
- Render summary cards, progress bars, breakdowns, search, and trend charts in a static UI.
- Publish the site through GitHub Pages.
GitHub Actions provided scheduled and manual triggers, generated the data, retained history, published the site, and produced a continuously updated result. The key lesson was that automation creates value repeatedly after the initial agent session ends.
5. The NUnit 4 Migration Challenge
Stan described why the migration could not be delegated to a generic code-generation prompt. CargoWise contains a very large test universe with complex class inheritance, cross-project dependencies, global state, fixtures, and behavior that differs between NUnitCore and NUnit 4.
Migration risks included unsupported global setup patterns, attribute and lifecycle changes, parameterized-test differences, project-file updates, and failures that become visible only through builds or test execution. The workflow therefore needed deterministic transformations plus verification—not just plausible edits.
6. Conversion Tool and Migration Skill
The NUnit Conversion Tool encoded known transformations for assertions, attributes, global state, lifecycle behavior, and project files. A reusable nunitcore-to-nunit Skill then orchestrated the complete workflow around that tool.
Skill workflow:
- Build the conversion tool.
- Run and record a baseline test result.
- Execute the conversion tool against the target project.
- Build and test the migrated project.
- Diagnose and fix remaining errors.
- Verify that the final result matches the baseline.
The example showed a baseline of 30 passing tests, an intermediate result of 29, and a verified final result of 30. This illustrates why an agent workflow should compare behavior before and after transformation rather than stopping when the code compiles.
7. Documentation as the Foundation of Skills
Skills depend on durable domain knowledge. When good migration documentation already exists, it can become the basis of a reusable Skill. When it does not, the team must first study the source code, project structure, dependencies, failure patterns, and successful fixes.
The session showed a second specialized workflow for abstract-class migration: environment setup, class discovery, project analysis, baseline verification, conversion, and fixes. Each solved case can improve the documentation and make later migrations more repeatable.
8. Domain-Specific NUnit Migration Reviewer Agent
Generic automated review is fast and can find obvious issues, but it often lacks the domain context needed to prioritize meaningful migration risks. Stan demonstrated a reviewer agent built from a migration checklist, Skill-Creator, documentation, PR comments, and source-code context.
The agent definition lives with the CargoWise repository and can be used from a GitHub PR, Visual Studio Code, or the Copilot CLI. By grounding the reviewer in known NUnit migration patterns, teams can identify high-risk changes more consistently while leaving final judgment with human reviewers.
9. Tools, Skills, and Agents Work Together
The closing summary separated three complementary responsibilities:
| Capability | Best use |
|---|---|
| Automation tool | Handle known transformations consistently and exactly |
| Migration Skill | Orchestrate the tool, baseline tests, fixes, and verification |
| Reviewer Agent | Review migration PRs using domain-specific knowledge and checklists |
The team's broader lesson was to use LLMs to help build reliable tools, not to delegate every operation to a model. Repetitive work becomes more productive when deterministic automation, agent orchestration, and domain-specific review are combined.
📊 Presentations & Materials
Session Recording
🎥 Watch the July 17, 2026 recording
Interactive Session Deck
🖥️ Open the Zorn Xu & Stan Yang interactive deck
The interactive HTML deck includes speaker introductions, the Copilot Squad structure, NUnit 4 migration Skill summary, and Q&A controls.
Recording highlights:
- Copilot Squad architecture and multi-agent design principles
- Durable team memory, reusable assets, and quality gates
- NUnit 4 migration dashboard architecture and GitHub Actions publishing
- Live walkthrough of the Squad workspace and generated dashboard
- NUnitCore-to-NUnit conversion tool and migration Skills
- Domain-specific automated review for CargoWise migration PRs
- Interactive quiz, summary, lessons learned, and Q&A
🔗 Featured Resources
- Interactive Session 13 Deck - Speaker and workflow overview included with this session
- GitHub Copilot in VS Code - Coding-agent capabilities used throughout the demonstrations
- Agent Skills in VS Code - Reusable instructions, scripts, and domain resources
- GitHub Actions Documentation - Scheduled automation and static-site publishing
- NUnit Documentation - NUnit framework concepts and migration references
🎮 Quiz Activity
The first talk concluded with a three-question “Award-winning quiz.” The questions reviewed why the Squad needs an orchestrator, how agents exchange durable information, and how human judgment fits into Copilot Squad delivery. Participants answered interactively during the live session.
The recording did not display a scored leaderboard or a verifiable list of prize winners.
🏆 Quiz Results & Winners
| Status | Details |
|---|---|
| No ranking published | An interactive prize quiz was held, but the recording did not show a scored ranking or winner list. |
🔑 Key Insights
- Multi-agent work needs structure: roles, orchestration, shared memory, and quality gates turn parallel agents into a team.
- Artifacts enable continuity: decisions, logs, schemas, and handoffs make collaboration resumable and traceable.
- Automation should continue creating value: scheduled scans and publishing outlive the original chat session.
- Use deterministic tools for known transformations: LLMs can build and orchestrate tools without replacing every exact operation.
- Verification closes the migration loop: baseline and final test results reveal behavioral regressions that compilation alone misses.
- Domain context improves review quality: a specialized reviewer agent can focus on migration-specific risks instead of generic comments.
📚 Further Learning
For Developers
- Start a migration by capturing a reproducible build and test baseline.
- Extract repeatable transformations into a deterministic tool and wrap the end-to-end procedure in a Skill.
- Preserve agent decisions and handoffs as files rather than relying on chat history.
For Teams
- Define explicit roles and quality gates before introducing parallel agents.
- Publish operational outputs such as dashboards through scheduled, observable workflows.
- Build reviewer agents from real defects, checklists, documentation, and repository context.
🙏 Acknowledgments
Special thanks to:
- Zorn Xu for presenting Copilot Squad and the NUnit 4 migration dashboard
- Stan Yang for presenting migration tools, Skills, and the reviewer agent
- Aimee Li for hosting and facilitating the session
- All participants for the quiz responses, questions, and discussion
Build a system, not a one-off prompt
Combine role-based agents, durable memory, deterministic tools, verification, and domain review so each run improves the next one.
Preserve human judgment
Agents can parallelize work and surface risks, but humans should continue to own goals, prioritization, and the final delivery decision.
Session 13 | July 17, 2026 | Copilot Squad and AI-Accelerated NUnit 4 Migration | Zorn Xu, Stan Yang