AI Engineer World's Fair 2025

Collaborating with Agents in Your Software Development Workflow - Jon Peck & Christopher Harrison, GitHub

Loading slides…

Read the talk

Collaborating with Agents in Your Software Development Workflow

A game-submission lab shows how readable repositories, explicit instructions, isolated execution and ordinary code review turn agent delegation into a workable development process.

From a talk by Jon Peck and Christopher Harrison

Before you start: Familiarity with Git branches, pull requests and basic automated testing is helpful; the original hands-on lab required a personal or non-enterprise-managed GitHub account.

Brunch, somewhere new, and waffles

A request to go to brunch sounds straightforward. Christopher Harrison suggests a restaurant; his partner says they have been there too often and wants somewhere new. He suggests another place; she realizes she wants waffles. Each answer was reasonable given the information available. Each additional requirement changes what a good answer looks like. Requirements can be known but unspoken, or discovered through the conversation itself. That is the practical meaning of treating GitHub Copilot as an AI pair programmer: expect to exchange context as the task becomes clearer.

Context includes the codebase, not just the prompt. Copilot reads the project much as a new teammate would. Descriptive function and variable names expose intent; single-letter variables and unexplained abbreviations obscure it. A line or two of comments can explain what a piece of code does and why it takes a particular approach. A navigable directory structure helps the assistant find the relevant implementation. These are ordinary maintainability practices with an additional beneficiary: the tool trying to help change the code.

The next input is intent. Developers accustomed to older chatbots sometimes write terse prompts as though they were entering commands into a limited parser. Natural language gives them room to explain the goal, constraints and preferred approach. Harrison’s advice is direct: “don't be passive aggressive with Copilot.” If you knew a requirement but never supplied it, the next useful action is to state it.

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 work to delegate

The workshop distinguishes several ways of working with Copilot. The newest option receives the visual emphasis, but that does not make it the best choice for every task.

ModeScopeDeveloper interaction
CompletionsNext line, function or classKeep typing and accept useful suggestions
Original chatA question or individual fileAsk, inspect and follow up
EditsChanges across multiple filesSpecify the desired edit
IDE agent modeProject exploration, edits and external tasksDelegate an iterative task

A webpage change illustrates why the progression matters: even a simple update can involve HTML, JavaScript and CSS. Multi-file edits address that coordination problem. IDE agent mode adds the ability to navigate the project, run tasks such as unit tests, observe errors and attempt repairs.

Coding Agent moves delegation to GitHub. Assign it an issue, let it work in the background, and review the resulting pull request. It can run scripts and iterate on failures without requiring the developer to conduct every step inside the IDE. The workshop uses the historical name Coding Agent; GitHub’s current documentation calls this cloud agent. The distinction that matters here is where the work happens: an interactive IDE session versus a hosted task that returns a reviewable branch and pull request.

Table compares Completions, Chat/Edits, Agent Mode and Copilot coding agent by scope, interaction frequency, inner or outer loop, and developer canvas.Open full source frame
GitHub Copilot code generation modes, with 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 usable repository

In the recorded workshop, the hands-on portion begins with organization access. Participants sign in using their GitHub handle, visit the octohol organization and accept its invitation. Jon Peck provisions the Copilot seats; participants do not need to request those seats separately. Missing invitations need to be reported because the presenters cannot infer access failures from silence. Harrison also gives his GeekTrainer handle for follow-up and the slide deck.

The lab’s short address is gh.io/agent-sdlc-lab, with SDLC standing for software development life cycle. Its setup order matters:

  1. Open the lab instructions and begin with exercise zero, the environment setup.
  2. Open the template repository in a new tab and select Use a template.
  3. Set the owner to OctoHol and the repository name to your GitHub handle.
  4. Continue through exercises zero and one; the repository may remain private.

Several interruptions come from skipping the instructions and creating a repository independently, or mistyping the short address. For missing organization access, Harrison also checks whether OctoHol appears in the new-repository owner dropdown before referring the problem to Jon. These are the event’s provisioning conventions, rather than instructions to create a repository in that organization today.

One participant has created the wrong repository. Harrison walks them through deleting that accidental repository through Settings and its confirmation sequence so they can return to the template-based setup. Another participant asks whether to merge the exercise pull request: it can remain unmerged because this stage is about exploring the workflow.

Signing in is also necessary for the template control to appear. Once the repository exists, participants create a Codespace, then return to the repository to create issues for Coding Agent. A participant reports that the Git connection can lag behind the initial Codespaces load; the lab includes sending hello to start the interaction. A premium-request exhaustion error is referred to Jon without a recorded resolution. Meanwhile, another participant submits a typo-fix pull request to the instructions repository. Those who finish early can advance to exercise two or take the optional exercises included throughout.

Codespaces is a separate product from Copilot. It supplies a development container in the cloud, avoiding a room full of local software installations. Harrison quotes Copilot Enterprise at about $40 and Business at about $20 per month; the historical list prices were $39 and $19 per user per month, respectively, with Enterprise requiring GitHub Enterprise Cloud. His statement that Business lacked Coding Agent access reflects the initial launch eligibility; Business access was announced later in 2025. A stalled Codespace subsequently appears to recover after a refresh.

11:3611:55
Suggest correction

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

11:36 · section reference included

Give the agent requirements and an environment

The demonstration issue asks for game-submission functionality. Its requirements are enumerated so the agent can see what the feature must accomplish. For a more involved task, Harrison would also include a proposed implementation workflow. This is the brunch example applied to software: the issue must contain the constraints the developer already knows.

The issue describes the work; Copilot Setup Steps prepares somewhere to do it. The agent runs inside GitHub Actions, and the setup workflow runs before its implementation work. The demonstrated workflow installs services and packages needed by the project. Preparing those dependencies explicitly gives the agent an environment in which it can build and test, rather than leaving environment discovery as an accidental part of the feature request.

Delegation also requires containment. Harrison describes a firewall that blocks external access, including dependency installation, unless access is permitted or dependencies are installed during setup. That description is too absolute: the launch behavior already included trusted destinations. The current firewall documentation describes a recommended dependency allowlist and excludes setup-step processes and MCP servers from the agent firewall. Treat the workshop’s network discussion as its operational explanation, not a current firewall recipe or a guarantee of comprehensive protection.

The remaining boundaries separate implementation from acceptance:

  • Ephemeral execution: GitHub Actions creates an environment for the task and tears it down afterward.
  • Branch-limited writes: The agent changes its own branch rather than writing directly into the repository’s main line of development.
  • Draft status: Its output is a draft pull request—already a pull request, but not yet ready for the normal acceptance process.
  • Workflow approval: A human selects Approve workflow runs before the downstream checks shown in the demonstration can run.
  • Independent approval: Under the launch restriction discussed here, the person who initiated the task cannot provide the approval that satisfies required review; another reviewer is needed. The initiator can still inspect the changes and request revisions.

Draft status, permission to run CI, and approval to merge are separate decisions.

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

The independent-review requirement immediately raises a solo-developer question: what if there is nobody else to approve the work? An attendee suggests using two identities, but Harrison endorses no workaround. The next question has a concrete demonstration: can the developer iterate on the generated implementation? Harrison adds a pull-request comment asking for an endpoint to search games by name.

An attendee reports that comments are not working for them. On Harrison’s screen, however, the eyes reaction appears, and View Session shows a new session starting. That session continues from the prior work with the new request. The observed result is a restarted agent session, not a demonstrated completed search endpoint. Asked whether the agent supports self-hosted runners, Harrison answers no and retracts wording that could have sounded like a roadmap promise.

A different integration question concerns a GitHub App installed by customers. Could the app generate rich prompts and invoke Copilot against those customers’ repositories? Harrison rejects the general idea of an open Copilot API that lets an application operate on someone else’s codebase. He suggests exposing the application’s functionality through an MCP server, allowing customers to invoke it from their own Copilot sessions. When the question narrows to what an installed GitHub App can assign on a user’s behalf, he leaves that authorization case unresolved and offers to follow up.

35:5035:59
Suggest correction

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

35:50 · section reference included

Repair the result by repairing the context

When an implementation misses the goal, the next intervention depends on how far it has drifted:

  • A useful result with a missing requirement: Add a comment clarifying the desired change.
  • A fundamentally wrong approach: Unassign Copilot, rewrite the issue and reassign it to start again.
  • A recurring misunderstanding: Inspect what the agent knows about both the task and its environment.

Harrison repeatedly returns to context as a likely cause. The useful diagnostic is to ask what information would have made the intended implementation easier to infer.

Persistent repository instructions put that information in .github/copilot-instructions.md. Harrison shows guidance used by both Coding Agent and IDE chat: an application overview, implementation approach, coding standards, requirements before committing, language guidance and project-specific conventions. The file ends with a repository map that explains where to find things. The selected editor frame shows that map, including the roles of the server, client and scripts directories.

VS Code displays the Repository Structure section of copilot-instructions.md, listing server, client and scripts directories and their roles.Open full source frame
Repository structure documented in copilot-instructions.md.

Model Context Protocol, or MCP, supplies a different kind of context. A server exposes commands; Copilot can inspect the available commands and select one to retrieve external information or perform an operation. This lets a task draw on information beyond model training data and the files already in context. The lab includes an MCP exercise, and Harrison proposes specialized search over a large codebase as one possible use. Repository instructions explain how the project should work; an MCP integration can supply information or actions needed while doing that work.

40:1840:35
Suggest correction

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

40:18 · section reference included

Encode repeated patterns in scoped instructions

Creating another React component or Flask endpoint usually means repeating an established pattern. A scoped *.instructions.md file can describe that pattern, its rules and the existing files that demonstrate it. Harrison points to a games implementation and a test file as prototypes: follow the structure already present rather than infer a new convention. These instruction files can be attached to chat manually.

The applyTo header makes attachment conditional on a file pattern. Harrison’s test example targets files in the server test folder whose names begin with test_. An instruction file expressing that pattern could look like this:

markdown

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

Follow the existing game tests for test structure and fixtures.
Use the established assertions and error-response conventions.
Run the relevant tests before committing changes.

The same mechanism can target JSX or TSX components, or files ending in .svelte. In the workshop, Harrison limits this scoped-instruction feature to Copilot Chat; that is the support boundary described for this demonstration.

These files belong to the repository and should change with it. Start with useful guidance, then add corrections when the assistant repeatedly takes an unwanted approach. Harrison compares the investment to writing a small automation script whose benefits accumulate over repeated use. He also credits instruction files with helping him obtain consistent behavior during live demonstrations of a probabilistic tool. The team-level responsibility is broader than individual prompting: dependency choices, implementation patterns and architectural decisions should enter the instructions when those decisions are made.

An attendee notices that the issue repeats a requirement to pass tests even though the instructions already contain it. Harrison says the repetition was unnecessary but useful reinforcement. Contradiction is the larger problem. He describes the issue, instruction files and referenced files as combined context without a last-write-wins rule. Current VS Code documentation likewise does not guarantee ordering among project instruction files, although it separately defines priority among personal, repository and organization instructions. Keep project guidance consistent rather than relying on one conflicting file to override another.

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 configuration separate from acceptance

The MCP discussion returns to network access. Harrison contrasts local VS Code connections with hosted Coding Agent connections, saying the latter need firewall openings in the setup he is describing. An attendee then raises the difficulty of OAuth configuration. Harrison points to repository configuration and variables, and discusses organization-level centralization, initially qualifying that possibility with “I believe.” The exchange identifies configuration and credential management as separate work; it does not demonstrate a complete OAuth setup.

AI does not remove the DevOps review process. Before AI assistance, developers wrote from memory, followed examples and adapted code from Stack Overflow. That code still needed review. Generated changes need the same manual review, linters, security scans and unit tests. Those safeguards determine what is acceptable to merge regardless of where the implementation originated.

Scope is another reason to choose the assistance mode deliberately. Telling Coding Agent or IDE agent mode to update one file does not guarantee that it will leave every other file untouched. It may decide that related work is necessary. Harrison recommends edit or ask mode when the developer wants to steer a narrowly bounded change. The distinction is control over the work, not simply whether an assistant can generate the code.

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

Take over the branch when that is easier

A follow-up comment can still produce an imperfect revision. If the implementation is mostly correct and one file needs attention, the developer does not have to keep negotiating through the agent. Its output is an ordinary Git branch. Clone the repository if necessary, check out that branch, and make the remaining change manually—or continue with Copilot in the IDE. Creating another branch from the generated state is also an option.

Harrison demonstrates the git checkout handoff. From an existing clone, the same workflow can use the actual branch name from the pull request:

bash

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

Once on the branch, the developer can edit the remaining file and use the project’s normal validation process. Delegating the initial implementation does not make the result inaccessible to ordinary development tools.

54:3754:47
Suggest correction

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

54:37 · section reference included

Remote MCP access carries user authority

The MCP diagram connects an IDE host and Copilot client to local servers, a remote server, data sources and a remote service. A remotely running agent can also connect to a remote MCP server and act on the user’s behalf. That raises a different question from connectivity: how long does its authority last?

Diagram connects a VS Code or IDE host to a GitHub Copilot client, local MCP servers and a remote server, with arrows to data sources and a remote service.Open full source frame
MCP connections between an IDE client, servers and data sources.

Harrison answers through credentials. A connection to the GitHub MCP server can use a token with an expiration; access duration depends on that credential and the service’s behavior. He says Copilot does not independently impose an automatic sign-out. In the interaction being discussed, the MCP server also does not initiate the agent’s task on its own: the user requests work, and the agent decides which exposed operation to invoke.

Harrison describes a confirmation button for an MCP operation, but does not set up and demonstrate that interaction on screen. His operational advice is to vet MCP servers as software that can access information and act with your authority. A repeated question about creating issues for another company and assigning its internal Copilot is deferred to a conversation afterward.

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 execution per issue and guidance by scope

Asked which model powers Coding Agent and how its decisions can be understood, Harrison answers the model portion: the hosted product does not expose its internal model at the time of the workshop. GitHub selects it for the workload. Later documentation describes model selection, but does not identify the model used here; the question about decision visibility receives no separate explanation.

Multiple assignments produce separate task environments. Harrison illustrates this by saying he could create 100 issues and assign them all to Coding Agent. The mechanism is one environment for each assigned issue; the example does not establish a concurrency limit. Each issue receives its own agent execution rather than joining one shared working session.

Instructions can also be divided as a project grows. An attendee asks about avoiding one gigantic file across folders and teams. Harrison shows an instruction file referencing another instruction file, and explains that applyTo can target folders. That supplies composition and scoping: shared guidance can live in one place while specialized guidance applies to selected paths. It does not demonstrate an override hierarchy.

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

Share server definitions and explain when to use them

For shared MCP access, Harrison describes Coding Agent server configuration at organization or repository level. In VS Code, the repository’s mcp.json can distribute server definitions as a versioned artifact. Each user still supplies credentials because operations run on that user’s behalf. Sharing a server definition is therefore different from sharing authorization to use it.

The final capability distinction comes through a correction. Harrison initially agrees that the configuration can provide resources as well as tools. Harold clarifies that Coding Agent supports tools only at that time, while resource support has just arrived in VS Code. The two clients should not be assumed to support the same MCP capabilities simply because both connect to MCP servers.

A question about namespace collisions becomes a discussion of how Copilot chooses which server to call. Harrison does not resolve the literal collision case; instead, he gives a practical way to steer selection. If a particular scenario should use a particular MCP server, put that relationship in the instructions file. He cites Azure MCP Server registration in VS Code as an example that prompts the user to add instruction guidance. The repository can then tell the assistant both how to build the application and where to obtain the information or operations needed for a specific task.

1:00:591:01:17
Suggest correction

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

1:00:59 · section reference included

Resources

Updates since the talk

Transcript download
Full transcript

Loading transcript…