AI Engineer World's Fair 2025
Piloting agents in GitHub Copilot
Loading slides…
Read the talk
Piloting agents in GitHub Copilot
A brunch negotiation leads into a practical guide to Copilot’s workloads, repository instructions, external tools, and the review gates that keep asynchronous coding accountable.
From a talk by Christopher Harrison
Before you start: Familiarity with GitHub repositories, pull requests, automated tests, and basic web application development will help you follow the examples.
A valid answer can still miss the requirement
Christopher Harrison’s partner suggests brunch. He recommends a restaurant, but they have been there too often. He suggests another. Then she adds that she wants waffles, and the destination changes again. Each recommendation was reasonable given the information available; the useful answer emerged as the constraints became explicit. Working with Copilot follows the same pattern: provide context, inspect the response, and clarify what the solution needs to satisfy.
Context extends beyond the prompt. Copilot also draws on the code and project material it can see. Descriptive names communicate more than unexplained abbreviations or single-letter variables. Comments help when the code alone cannot explain the intent. A clear project structure makes relevant resources easier to locate. These are the same affordances that help a human pair programmer understand an unfamiliar repository.
The practical rule is to supply information you already know. Instructions can carry project background; the immediate request should state the intended outcome and any particular implementation requirements. There is no advantage in making Copilot infer a constraint you could state directly. Harrison also encourages natural-language explanations rather than the terse commands people learned to use with older chatbots: clarity and specificity matter more than brevity.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Choose how much of the work to delegate
Copilot’s workloads differ in how the developer directs the work and how much the system can do between interactions. The newly highlighted coding agent is another option, not an automatic replacement for the others.
| Workload | Interaction | Useful situation |
|---|---|---|
| Code completion | Suggests code as you type | You know the next step and want help writing it |
| Ask | Answers a focused request | Explain code or request a specific artifact |
| Edit | Coordinates changes across files | Update related HTML, CSS, and JavaScript |
| Local Agent | Explores files and runs commands | Implement a change, build, test, and attempt repairs |
| Coding agent | Takes an assigned repository issue | Work asynchronously while you handle something else |
The key transition from Edit to Agent is the ability to investigate the project and act on feedback from builds or tests. The further transition to coding agent changes the collaboration rhythm: the developer hands off an issue instead of continuously steering an editor session.
The workshop is designed to make that progression concrete. Its setup sequence is:
- Accept the organization invitation using the email associated with the GitHub account, then accept the Copilot license. If the email does not arrive, the workshop organization’s page can expose the pending invitation banner.
- Follow the README through environment setup, issue assignment, external services, context, a sitewide update, and review.
- Open the environment in Codespaces, avoiding a local installation.
- Create the workshop repository under the workshop organization, using the attendee’s GitHub handle as its name, then begin exercises zero and one.
The organization ownership requirement belongs to this workshop’s access arrangement.
Some attendees can start coding-agent work, but the organization’s expected entitlement does not appear to reach everyone. Under the preview access rules Harrison describes, assigning issues requires Copilot Pro+ or Enterprise; he says the rest of the lab can be attempted with Copilot Free. He begins demonstrating the exercises and points out that the public lab can be revisited later.
An audience question gives this division of responsibility another name: vibe coding. Harrison considers agent-driven work, where Copilot leads the operation, to fit that description to some extent, while leaving the choice of working style to the developer. Asked about Cascade, Cursor, and Windsurf, he offers no comparative ranking: he does not know their feature sets well enough, but can answer specific questions about what Copilot can do.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connect to live information—or supply the schema
Can Copilot understand a live SQL database? The model’s learned knowledge does not itself provide a connection to that database. Model Context Protocol, or MCP, supplies a route to external capabilities: a request reaches Copilot, Copilot calls an MCP server, and the server accesses an external resource. The GitHub MCP server, for example, can support creating an issue or searching from chat. A database integration can expose schema or data through the same general arrangement.
Harrison names GitHub, Azure, and Playwright servers alongside community implementations. Choosing one is a trust decision because a server may perform actions as well as retrieve information. Building a server yourself is another option, although Harrison explicitly says he has not yet done so himself; he describes the basic responsibility as receiving a request, processing it, and exposing capabilities Copilot can call.
A follow-up question narrows the requirement: what if the database is available only as a .sql backup? For query generation, the useful context may be the data definition language, or DDL, rather than a live connection or the database’s records. Harrison recommends including the schema in instructions. For example, a game schema could provide enough structure to formulate a publisher-and-category query:
sql
CREATE TABLE games (
id INTEGER PRIMARY KEY,
title TEXT NOT NULL,
publisher TEXT NOT NULL,
category TEXT NOT NULL
);
SELECT id, title
FROM games
WHERE publisher = :publisher
AND category = :category
ORDER BY title;
The table definition tells the assistant which columns exist. It does not grant database access; executing the query remains a separate operation.
The discussion then turns to instruction-file scope, including an audience question about agents.md and copilot-instructions.md. By this point, Codespaces, network, and access failures prevent the planned hands-on rhythm. Harrison explicitly switches to live Q&A and demonstrations.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Give the asynchronous agent a specification and an environment
The coding-agent demonstration starts with an issue requesting endpoints for creating and editing games. After assignment, an eyes reaction indicates that Copilot has taken the task. Because the agent works asynchronously, missing requirements may remain undiscovered until it returns a result. The issue should therefore state both the desired outcome and the approach when the developer already knows it. Harrison compares this to asking someone to paint a wall: if a particular shade of red matters, specify the shade.
The issue supplies task-specific intent; copilot-instructions.md supplies recurring project knowledge. Harrison opens an ordinary Markdown file describing a developer-themed crowdfunding platform. It contains coding standards, requirements before commits, Python and Flask guidance, Svelte and Astro conventions, styling and Actions guidance, available scripts, and the repository structure. Both chat and coding agent can use this shared material, so the same background does not need to be rewritten into every request.
The next dependency is the execution environment. Coding agent works through GitHub Actions, and the demonstrated setup workflow is displayed as Copilot Setup Steps. It installs the libraries, frameworks, services, and other prerequisites the agent will need, and can run preparation scripts. Instructions describe how to work; setup makes that work possible.
The resulting pull request exposes a View session action. Harrison opens it to inspect Copilot exploring the project and gathering information. He points to the pull request’s recent creation time to establish that the work is live, rather than a prepared result. The session makes four distinct inputs visible in the workflow: the issue, repository instructions, the project itself, and the prepared environment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Separate shared instructions from task and file guidance
Does a developer need to invoke @workspace to make custom instructions available? Harrison answers by switching local chat to Agent mode and leaving Claude 3.7 selected; the lab uses Claude 3.5, without a claimed model ranking. He requests publisher and category filters, dropdown lists, a page refresh when selections change, and passing tests. After a delay, copilot-instructions appears under the response’s references, showing that the shared instructions were included. This part of the demonstration establishes instruction use, not a completed filtering feature.
For more specialized guidance, Harrison introduces *.instructions.md files in local chat. A Flask endpoint instruction file can describe endpoint conventions, unit-test expectations, project notes, and links to existing files that provide a pattern to follow. It can be attached manually to a task. An applyTo pattern can instead attach guidance automatically when matching files are involved, as documented in the historical VS Code 1.100 release notes.
The demonstrated matching example is a test file such as server/tests/test_games.py. A compact instruction file for that pattern could look like this:
markdown
---
applyTo: "server/tests/test_*.py"
---
Follow the existing Flask endpoint test conventions.
Use neighboring tests as examples before adding a new pattern.
Include tests for the endpoint behavior changed by the task.
The same mechanism can target React components through JSX or TSX patterns. Repository-wide instructions carry the common baseline; matching instruction files add relevant detail. Because these files live in the repository, the effort of writing them becomes reusable team knowledge, much like scripting a small task that otherwise repeats indefinitely.
An audience member asks whether the setup workflow needs its specific name; Harrison says the documented naming is required. Another asks how to share organization standards. Harrison offers three routes:
- Organization instructions: store shared guidance at the organization level.
- MCP search: expose standards through a server that can retrieve relevant material.
- Copilot Spaces: curate repositories and selected files containing knowledge, standards, and examples for use on GitHub’s website.
Spaces is introduced as a newly announced way to collect that context.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Prepare dependencies without surrendering execution boundaries
Can the agent change its own setup workflow when it discovers a missing dependency? Harrison distinguishes authoring assistance from the launched job. A developer can use local Copilot to generate the workflow, but he says the running coding agent cannot go back and revise that setup. It can still run scripts and tests inside its environment. Returning to the session output, Harrison says the tests appear to have passed, then notices SQLAlchemy output that prompts him to plan a project update.
The security explanation starts with an ephemeral Actions workspace: it is created for the job and torn down afterward. Harrison describes repository access as read-only except for the agent’s own branch. In the demonstration, copilot-fix-2 corresponds to issue 2; he presents that as the branch-naming pattern in use. He also describes external calls, including package installation, as blocked unless allowed through the firewall. The initial setup workflow is the stated exception for installing known prerequisites.
These configuration details are version-sensitive. For present-day setup, the environment documentation specifies .github/workflows/copilot-setup-steps.yml and the job ID copilot-setup-steps, rather than relying on a display name. The current firewall documentation describes required GitHub access and an enabled-by-default dependency allowlist; MCP servers and processes started during setup fall outside that firewall’s coverage. Harrison’s historical network explanation should therefore not be treated as a current guarantee of total isolation.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
An agent’s test run does not replace pull-request validation
A Dependabot version-bump pull request illustrates the repository’s ordinary checks: unit tests and end-to-end tests run before changes are merged. The coding-agent pull request introduces an additional approval boundary. Its workflows have not run automatically; a person must authorize them with the displayed button. Harrison says to review the code before granting that execution.
The same unit-test script can run inside the agent’s environment and again during pull-request validation. That duplication is intentional. AI changes how code is produced, not the fundamentals of DevOps. A developer would normally write code, test locally, open a pull request, obtain another developer’s review, and run the repository’s tests, linters, and security scans. Copilot-generated changes retain those gates.
Running every test after every small edit is a separate question. Harrison estimates that unit or end-to-end test runs in this small demonstration project take 30–40 seconds. For a larger project whose suite takes minutes, he suggests directing the agent to run tests relevant to the current change during iteration, then run everything at the end. Put that policy in the prompt or the instructions if it should recur.
Harrison has also observed Claude Sonnet 4 sometimes start with a smaller test set and expand to the full suite on its own. That observation does not remove the need to specify the desired testing policy: when a particular sequence matters, tell the agent.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Connect services and bring external issues into the workflow
Asked about streaming HTTP MCP servers, Harrison confirms remote MCP support, including for coding agent. His answer covers remote connectivity without separately explaining streaming transport behavior. In the demonstrated configuration, he directs attendees to repository Settings → Coding Agent for the MCP server list, then Environment → Copilot for variables governing network access. He says the remote service must be allowed through the network configuration; the exact variable names are not given.
For teams tracking work in Jira or Azure DevOps, the session’s assignment route still begins with a GitHub issue. Harrison proposes a straightforward bridge: copy the external issue into GitHub with a script, then assign that issue to Copilot. He makes no commitment about future native integrations. The actionable requirement is to bring the task specification into the issue system that the demonstrated agent accepts.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Teach library usage and curate what the agent should imitate
The final technical questions concern internal libraries maintained in other repositories. How can Copilot reuse them instead of generating replacements? Start by showing existing usage. Harrison compares this to his own work with Svelte: he can use the framework effectively without knowing its implementation internals. In the same way, examples of calls and conventions can give Copilot the information it needs without exposing the library’s entire source tree.
The supporting context can grow with the library collection:
- Existing examples: show the imports, calls, and patterns already used in the application.
- Instruction files: list relevant APIs in shared guidance or scope them to the file types that need them.
- Searchable documentation: use an MCP server when the collection is large enough that retrieving relevant material is more useful than including it all.
The goal is to make the intended way of using the library easy to discover.
Asked about fine-tuning, Harrison says it is not supported in the offering he is discussing. He also identifies a problem with treating an organization’s codebase as an undifferentiated training source: it contains both code people want copied and code they would rather leave behind. Curated retrieval through MCP gives the organization a way to choose which examples the assistant sees and which it excludes. The quality of the supplied precedent matters as much as its availability.
The last question asks how assigning an issue consumes an Enterprise premium-request allowance. Harrison declines to supply a billing explanation, and the session ends without a consumption formula or price. He returns to the lab-access slide so attendees can continue independently. The demonstration reaches environment preparation, agent work, and pull-request validation; it does not show an application deployment.
Suggest correction
This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.
Resources
From the talk
GitHub's official MCP server project and setup documentation.
Further reading
- VS Code 1.100: instruction files and applyToDocumentation
April 2025 release notes explain manual instruction attachment and file-pattern selection using applyTo.
A guided workshop built around a game crowdfunding application with Flask, SQLAlchemy, Astro and Svelte.
Updates since the talk
Current instructions for preparing dependencies and configuring the agent's GitHub Actions environment.
Current network controls, default allowlists, setup-step exceptions and limits of firewall protection.
Full transcript
Loading transcript…