AI Engineer
← All speakers

Related work and projects

Bio, Work & Ideas

Christopher Harrison

Conference affiliation: GitHub · 2025

On this page

Christopher Harrison is a Senior Developer Advocate at GitHub and technical educator who helps software teams integrate GitHub Copilot into established development workflows. His approach emphasizes useful project context, carefully constrained coding agents, and accountability for AI-generated code.

From programming instruction to AI-assisted development

Harrison began experimenting with computers after his father brought home a Commodore VIC-20 when he was seven. He subsequently built a career as a technical trainer, presenter, and educational content creator before serving as a senior cloud advocate at Microsoft.

With Susan Ibach, Harrison taught Microsoft’s Python for Beginners series. His introductory Python programming repository collects course slides, examples, and solutions, while his GeekTrainer writing examines Python, accessible web development, pull-request reviews, Azure Static Web Apps, and engineering culture. He argues that purchasing better tools cannot compensate for weak communication or dysfunctional development practices.

At GitHub, Harrison’s developer education has expanded from AI pair programming and Copilot customization to coding agents, command-line workflows, browser-assisted debugging, and managing multiple concurrent agent sessions.

How Harrison thinks about coding agents

  • Context extends beyond the prompt. Readable code, clear function names, repository structure, representative examples, and precisely written issues all influence an agent’s output. Harrison’s guidance on AI pair programming treats missing project context as a practical engineering problem, not something clever wording alone can repair.
  • Repository instructions preserve institutional knowledge. Harrison recommends maintaining repository-level custom instructions that explain project architecture, coding standards, testing requirements, and available scripts. Path-specific instructions can also encode patterns for Flask endpoints, automated tests, or React and Svelte components, making organizational expectations reusable across agent interactions.
  • Coding agents require explicit operational boundaries. An agent assigned a GitHub issue needs a prepared execution environment, appropriate dependencies, restricted network access, and limited repository permissions. Harrison’s coding-agent onboarding framework emphasizes deliberate configuration before autonomous work begins.
  • External access increases responsibility. Model Context Protocol integration can connect assistants to internal libraries, organizational knowledge, browser-testing tools, and external services, but remote agents may require explicit firewall configuration. Harrison stresses evaluating third-party tools carefully because they can access sensitive information or act on a developer’s behalf.
  • Human-reviewed AI-generated code remains essential. His hands-on Copilot workshop preserves established safeguards: pull-request review, automated tests, linters, security scanning, and human approval. Agents can perform implementation and run checks, but responsibility for what enters production remains with the engineering team.

Read the topics behind these talks

4 conference talks

▶ Watch ↗

AI Engineer World's Fair 20251:04:06

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

Read the full talk →

Key ideas

Scroll to read ↓

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

  • Brunch, somewhere new, and waffles
    3:51 ↗
  • Choose how much work to delegate
    8:32 ↗
  • Get the lab into a usable repository
    11:36 ↗
  • Give the agent requirements and an environment
    30:35 ↗
  • Continue the work through the pull request
    35:50 ↗
  • Repair the result by repairing the context
    40:18 ↗
  • Encode repeated patterns in scoped instructions
    45:09 ↗
  • Keep configuration separate from acceptance
    51:03 ↗
  • Take over the branch when that is easier
    54:37 ↗
  • Remote MCP access carries user authority
    56:16 ↗
  • Separate execution per issue and guidance by scope
    58:31 ↗
  • Share server definitions and explain when to use them
    1:00:59 ↗
▶ Watch ↗

AI Engineer World's Fair 202559:07

Piloting agents in GitHub Copilot

Read the full talk →

Key ideas

Scroll to read ↓

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.

  • A valid answer can still miss the requirement
    5:29 ↗
  • Choose how much of the work to delegate
    10:12 ↗
  • Connect to live information—or supply the schema
    23:27 ↗
  • Give the asynchronous agent a specification and an environment
    30:16 ↗
  • Separate shared instructions from task and file guidance
    35:46 ↗
  • Prepare dependencies without surrendering execution boundaries
    42:09 ↗
  • An agent’s test run does not replace pull-request validation
    46:58 ↗
  • Connect services and bring external issues into the workflow
    52:05 ↗
  • Teach library usage and curate what the agent should imitate
    54:34 ↗
▶ Watch ↗

AI Engineer World's Fair 20251:19:33

Real World Development with GitHub Copilot and VS Code — Harald Kirschner, Christopher Harrison

Read the full talk →

Key ideas

Scroll to read ↓

A live VS Code workshop follows a disposable frontend prototype into reusable instructions, custom TDD modes, MCP tools and a workflow that separates specifications, planning and implementation.

  • When a working app stops being enough
    0:32 ↗
  • Start with an empty workspace
    5:21 ↗
  • Give the hydration tracker a stack and a design direction
    8:30 ↗
  • Run a second design experiment
    15:32 ↗
  • Inspect what the model assumed
    19:43 ↗
  • Point at the element you want to change
    22:33 ↗
  • Arrange the conversation and keep experiments reversible
    26:04 ↗
  • Put the organization’s choices into a starter
    32:12 ↗
  • Separate repository guidance from scoped rules
    38:10 ↗
  • Turn a repeated task into a prompt—and a workflow into a mode
    42:18 ↗
  • A TDD mode needs real tools
    48:33 ↗
  • Install MCP capabilities without putting tokens in the file
    56:21 ↗
  • Connect, discover and execute remote tools
    1:00:01 ↗
  • Model availability depends on tool compatibility
    1:04:47 ↗
  • Inspect a research call before turning it into a spec
    1:06:39 ↗
  • A smaller tool set does not guarantee a tool call
    1:10:05 ↗
  • Write the spec, write the plan, then implement
    1:13:30 ↗
  • Make the process—and the codebase—easier to follow
    1:18:16 ↗
▶ Watch ↗

AI Engineer World's Fair 20251:04:06

The Agent Awakens: Collaborative Development with Copilot

Read the full talk →

Key ideas

Scroll to read ↓

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

  • First brunch, then somewhere new, then waffles
    3:51 ↗
  • Choose how much of the work to delegate
    8:32 ↗
  • Get the lab into a working environment
    11:09 ↗
  • Give the issue requirements and the agent an environment
    30:35 ↗
  • Continue the work through the pull request
    36:11 ↗
  • Put durable context in the repository
    42:07 ↗
  • Apply repeatable patterns to the right files
    45:09 ↗
  • Keep the review process and take over when useful
    51:03 ↗
  • Remote MCP access carries credentials and authority
    56:16 ↗
  • Separate issue environments, compose shared guidance
    58:31 ↗

References