AI Engineer World's Fair 2025

The Agent Awakens: Collaborative Development with Copilot

Loading slides…

Read the talk

The Agent Awakens: Collaborative Development with Copilot

From a changing brunch request to a reviewable pull request, effective Copilot collaboration depends on explicit context, prepared environments, and deliberate human control.

From a talk by Christopher Harrison and Jon Peck

Before you start: Familiarity with Git branches, pull requests, and a code editor will help you follow the workshop; prior experience with Copilot or MCP is not required. The original hands-on lab required a personal or non-enterprise-managed GitHub account.

First brunch, then somewhere new, then waffles

A request to go to brunch sounds straightforward. Christopher Harrison recommends a restaurant; his partner says they have been there too often and wants somewhere new. He suggests another place. Then comes another constraint: she wants waffles. Each recommendation made sense given the information available, and each new detail changes the useful answer. Some constraints may have been known from the start; others emerge through conversation. That is the working meaning of Copilot as an AI pair programmer: collaboration includes discovering and sharing context, rather than expecting a perfect first request.

Context includes the repository, not just the prompt. Copilot reads code, so the same choices that help a new teammate understand a project also help it: descriptive function and variable names, clear structure, and fewer unexplained abbreviations or single-letter variables. A line or two of comments can explain what a piece of code does and how it does it. A navigable project layout makes the relevant implementation easier to find. These are ordinary code-quality practices with an additional consumer.

The next ingredient is intent. Older chatbots trained users to send terse, command-like inputs, but a development request can use natural language to explain both the desired result and its constraints. Harrison’s formulation is “don't be passive-aggressive with Copilot”: if you know an important requirement, tell it. An unstated preference cannot reliably guide an implementation.

3:513:58
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

3:51 · section reference included

Choose how much of the work to delegate

Copilot’s workloads differ in scope and in who steers the next action. Completions support a developer who already knows what to write. Chat introduces a question-and-response interaction, but a webpage change quickly exposes the limits of generating one file: HTML, JavaScript, and CSS may all need coordinated changes. Edits extends the interaction across files; IDE agent mode adds project navigation, task execution, and an iterative attempt to recover from errors.

WorkloadTypical scopeInteraction
CompletionsNext line, function, or classSuggestions while you type
ChatAnswer or generated fileAsk, inspect, refine
EditsCoordinated changes across filesDirect the editing task
IDE agent modeProject-level implementationNavigate, edit, run tasks, retry
Coding AgentDelegated GitHub issueBackground work and a pull request

Coding Agent moves the task out of the IDE interaction and into a GitHub issue workflow. Assign an issue, let the agent work in the background, and review the resulting pull request. It can run scripts and attempt corrections along the way. The newest mode receives the visual emphasis in the workshop, but that does not make it the best choice for every task.

Table compares Completions, Chat/Edits, Agent Mode, and Copilot coding agent by change scope, interaction frequency, inner or outer loop, and developer canvas.Open full source frame
GitHub Copilot code-generation modes, with the coding agent highlighted.
8:328:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

8:32 · section reference included

Get the lab into a working environment

The recorded workshop separates organization membership from Copilot access. Participants then visit OctoHOL, signed in with their GitHub handle, and accept the organization invitation. John Peck then provisions Copilot seats; attendees do not need to submit a separate seat request. Harrison repeatedly asks people to report failures, because silence otherwise looks like successful setup.

Harrison shares his GeekTrainer handle and offers the slide deck before directing participants to the agent-sdlc-lab short link displayed in the recording. The repository contract is specific: owner OctoHOL, repository name equal to the participant’s handle. Exercises zero and one are the starting point.

The repeated setup repairs are useful because they distinguish a repository that merely exists from the repository the lab needs:

  1. If organization access appears missing, inspect the owner dropdown in New repository.
  2. Begin at step zero, Set up the environment, rather than creating an empty repository independently.
  3. Open the referenced template in a new tab and select Use a template.
  4. Set the owner to OctoHOL and the name to your handle. Private visibility is acceptable.

The short-link slug is agent-sdlc-lab; SDLC means software development life cycle. In one repair, an attendee has created the wrong repository, and Harrison walks through its Settings deletion controls and confirmation before returning to the template flow. That deletion is a correction to an accidental lab repository, not a routine setup step.

The first exploratory pull request can remain unmerged. Template actions require GitHub sign-in; after creating the Codespace, participants return to their repository, create issues, and begin trying Coding Agent. A loaded Codespace does not necessarily mean chat has connected: the connection is established lazily, so the lab asks participants to send hello. A separate premium-request exhaustion error is referred for help, without a recorded resolution.

Faster participants can advance to exercise two or use the optional exercises. Codespaces is a separate product—a cloud container chosen here to avoid local installation work. During the billing discussion, Harrison estimates Enterprise at roughly $40 per month and Business at roughly $20; the historical Enterprise list price was $39 USD per user per month, with GitHub Enterprise Cloud required. His Business exclusion for Coding Agent belongs to its launch-era Enterprise/Pro+ eligibility, not a permanent plan distinction. The question about third-party-model credit consumption is not directly answered. A later stalled Codespace loads after a refresh.

11:0911:17
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

11:09 · section reference included

Give the issue requirements and the agent an environment

The demonstration delegates game-submission functionality. Its issue lists the requirements rather than relying on the agent to infer what submission should mean. For a more substantial change, Harrison would also include a suggested workflow for building the feature. This is the move from pair programmer to peer programmer: the issue must carry enough context for work to proceed without a developer supplying every next step.

Assignment also requires somewhere to execute. The workflow displayed as Copilot Setup Steps prepares the GitHub Actions environment before agent work, installing the required services and packages. The corresponding configuration identifiers are .github/workflows/copilot-setup-steps.yml and the job ID copilot-setup-steps, as specified in Harrison’s later setup guidance. The distinction matters: a readable workflow name describes its purpose, while the filename and job identifier connect that preparation to the agent’s startup.

Preparation and containment are linked. Harrison describes restricted outbound access and offers two ways to make dependencies available: permit the necessary destinations or install dependencies during setup. His description of blocking every external resource is broader than the launch design’s customizable trusted-destination list. The firewall documentation now also distinguishes agent traffic from setup processes and MCP traffic. The operational lesson is to provision the environment deliberately rather than assume the agent can fetch anything it needs.

The remaining boundaries separate proposed changes from accepted changes:

  • Ephemeral execution: GitHub Actions creates an environment for the work and tears it down afterward.
  • Branch-limited writes: the agent changes its own branch rather than writing directly into the base branch.
  • Draft pull request: the work is already a pull request, but remains in draft while it is being developed.
  • Workflow approval: a human selects Approve workflow runs before the pull request’s workflows can run, including the project’s security and test checks.
  • Independent approval: under the launch-era rule discussed here, the person who assigned the issue cannot supply the approval that satisfies required review. They can still inspect and comment on the work.

An attendee asks how that last rule works for a sole programmer. The session does not resolve the exception.

30:3530:52
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

30:35 · section reference included

Continue the work through the pull request

To extend the game feature, Harrison adds a comment requesting an endpoint to search games by name. The location matters: this is a comment on the pull request. An eyes reaction appears as Copilot resumes work, and View session reveals a new session continuing from the previous implementation. The demonstration establishes that the follow-up has started; it does not show a completed, validated search endpoint. Asked whether this runs on self-hosted runners, Harrison answers no for the version being demonstrated and deliberately avoids promising future support.

The next integration question is more ambitious: can a GitHub App installed by customers generate rich prompts and cause Copilot to work on their repositories? Harrison initially rejects treating Copilot as an open API for arbitrary customer codebases. He suggests exposing an MCP server that customers invoke through their own Copilot instead. When the question narrows to whether an installed app’s permissions permit assigning the customer’s Copilot on their behalf, he says he does not know and offers a follow-up. That narrower authorization question remains open.

When generated work is wrong, the repair depends on how far it has diverged:

  • A useful implementation with a misunderstanding: add a pull-request comment clarifying the desired behavior.
  • A fundamentally wrong direction: unassign Copilot, revise the issue, and reassign it to start again.
  • A recurring failure: investigate what the agent did not understand about the request or its environment.

Harrison repeatedly returns to missing context as his diagnostic starting point. The practical question is what information would have changed the agent’s decision, rather than how many times to repeat the same request.

36:1136:22
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

36:11 · section reference included

Put durable context in the repository

Repository instructions make the project’s expectations available beyond one issue or conversation. Harrison opens copilot-instructions.md, describing it as guidance used by Coding Agent and IDE chat. The visible Tailspin Toys file starts with a project overview, Code Standards, and Required Before Each Commit. As he scrolls, it also supplies language guidance, implementation specifics, and a map of the repository. These answer the questions a new contributor would otherwise have to reconstruct from scattered files.

VS Code displays copilot-instructions.md with a Tailspin Toys project overview, Code Standards, and Required Before Each Commit headings.Open full source frame
Repository guidance in copilot-instructions.md.

Model Context Protocol (MCP) adds a different source of context. Copilot can inspect commands exposed by configured servers and select one to obtain external information or perform an operation. This extends what it can use beyond its training knowledge and the code already available to it. Harrison suggests a search service for a large repository as one application: expose a way to find relevant code and information rather than expecting the model to discover everything unaided. The lab includes an MCP exercise.

42:0742:44
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

42:07 · section reference included

Apply repeatable patterns to the right files

Many coding tasks repeat a local pattern: another Flask endpoint, another React component, another test. Specialized instruction files can describe that pattern and point to an existing implementation or test as the prototype. They can be attached manually to chat, or selected automatically through an applyTo header. Harrison’s test example targets files in the server test folder whose names begin with test_; other examples target JSX, TSX, or .svelte files. He describes this scoped feature as Chat-only in the workshop’s version.

For a repository using server/tests/, the same selection mechanism can be expressed in .github/instructions/server-tests.instructions.md:

markdown

---
applyTo: "server/tests/test_*.py"
---

Follow the existing server tests when adding or changing tests.
Use the established fixtures and assertion style.
Keep new endpoint tests consistent with the existing game endpoint tests.

The complete extension is *.instructions.md; repository-wide guidance conventionally lives in .github/copilot-instructions.md. The VS Code custom-instructions guide documents these file forms. The pattern selects where the guidance applies, while the body tells Copilot what conventions to preserve.

Treat these files as maintained repository artifacts. Harrison compares the investment to writing a small automation script whose benefits accumulate with repeated use. An audience contribution recommends starting minimally and updating the guidance when mistakes reveal a missing rule. Harrison says instruction files are his main aid for getting consistent behavior during probabilistic live demonstrations. Team leads also have a role: record dependency choices, implementation patterns, and architectural decisions when the team makes them, so the instructions reflect the actual project.

An issue can repeat a requirement already present in an instruction file. Harrison says that repetition was unnecessary in his example, but intended to reinforce the requirement. More consequential is contradiction: the issue, repository guidance, specialized instructions, and referenced files should describe a consistent approach. His warning that there is no last-write rule should not be generalized into a current absence of instruction priority: VS Code now distinguishes priority between instruction types from the unspecified order in which instruction files are combined. Consistent guidance avoids depending on either mechanism to reconcile conflicting requirements.

45:0945:18
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

45:09 · section reference included

Keep the review process and take over when useful

MCP configuration raises an environment distinction. In the workshop, Harrison contrasts local VS Code connectivity with Coding Agent and says the remote agent needs its firewall opened for an MCP server. That answer belongs to the demonstrated setup; the firewall scope described earlier has since been documented differently. For authentication configuration, he points to repository settings and variables as a way to centralize setup, while initially qualifying his suggestion of organization-level configuration.

AI-generated code still goes through the normal DevOps flow. Developers already combine remembered code, examples, and copied snippets that need adaptation. The source of a proposed change does not remove the need for manual review, linters, security scans, or unit tests. Those safeguards remain the route by which a proposed implementation becomes acceptable repository code.

Scope is another reason to choose the workload deliberately. Asking an agent to update one file does not guarantee it will leave every other file alone. It may decide that additional changes are necessary. Harrison recommends Edit or Ask mode when direct developer steering is more appropriate than allowing the agent to determine the work. The prompt expresses the requested scope; reviewing the diff establishes what actually changed.

If the result is almost right and only one file needs attention, another agent session may be unnecessary. The output is an ordinary Git branch. Clone the repository if needed, check out that branch, and edit it manually—or continue with Copilot locally. From an existing clone, the handoff can be as small as:

bash

git fetch origin
read -r -p "Agent branch name: " agent_branch
git checkout "$agent_branch"

Harrison reaches for git checkout in the demonstration because it restores direct control without discarding the useful work already on the branch.

51:0351:11
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

51:03 · section reference included

Remote MCP access carries credentials and authority

Returning to the MCP architecture diagram, an attendee asks whether a remote agent can connect to a remote server and how long that access lasts. Harrison answers that the connection can act on the user’s behalf, but its lifetime depends on the configured credentials. For the GitHub MCP server, a token with an expiration is his concrete example. He does not describe Copilot as automatically signing the user out after a fixed interval.

Architecture diagram connects an IDE host and GitHub Copilot client to MCP servers, local data sources, and a remote server linked to an internet service.Open full source frame
MCP connections between Copilot, local servers, and remote services.

The direction of initiation also matters. In this interaction, the MCP server does not independently start the agent’s task; the user expresses an intent, and Copilot chooses whether to invoke a server. Harrison describes an interactive confirmation button, though he does not demonstrate it in this setup. That should not be transferred to cloud-agent behavior: the repository MCP configuration guide now says configured tools can run without per-use approval. Vet a server as a service that may access information and exercise the user’s authority. A renewed question about creating issues for another company and assigning its internal Copilot is deferred to an offline discussion.

56:1656:20
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

56:16 · section reference included

Separate issue environments, compose shared guidance

For the GitHub-hosted Coding Agent shown here, the internal model is not exposed to users. Harrison says GitHub selects it for the particular workload; possible future model visibility or selection is speculation in this discussion. Multiple delegated issues do not imply one shared workspace: each assignment receives its own environment. His example of assigning a hundred issues illustrates that arrangement, rather than establishing a tested concurrency limit.

Shared guidance need not become one enormous file. Harrison shows an instruction file referencing another instruction file, and explains that applyTo can select folders. Teams can therefore separate specialized guidance and connect it where needed. This demonstrates composition and file selection, not the deterministic folder-override hierarchy proposed in the audience question.

For shared MCP setup, Harrison describes organization- or repository-level server lists for Coding Agent, and a repository mcp.json file for VS Code. The server configuration can be shared, but each user still supplies credentials because operations act on that user’s behalf. A closing correction narrows the capability claim: the participant addressed as Harold says Coding Agent supports tools only at that time, while MCP resources have just arrived in VS Code. Harrison accepts the correction. Configuring the same server therefore does not imply identical capabilities across the two clients.

The final question asks about MCP namespace collisions. Harrison answers the related selection problem: Copilot must decide which server to call and when. If a particular scenario should use a particular server, encode that routing guidance in the instructions. He gives Azure MCP as an example whose installation prompts VS Code users to add instruction guidance. The session does not establish collision-resolution semantics, but it ends with a concrete maintenance action: when tool selection misses the intended behavior, add the missing context to the repository guidance that will shape the next request.

58:3158:40
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

58:31 · section reference included

Resources

Updates since the talk

Transcript download
Full transcript

Loading transcript…