OneRange

GitHub Copilot: Advanced — Agentic Engineering with GitHub Copilot

Agentic engineering with GitHub Copilot for developers who set up how their team works with agents. Learners pick the right surface per job, layer custom instructions, define custom agents with scoped tools, add skills, hooks and MCP servers, run Copilot CLI interactively and in scripts, prepare cloud agent's environment, use code review as a gate, not an approval, and measure and govern agent work. Ends with a team agent setup used on one real change.

What this course covers

The course runs across 10 topics, each one a short adaptive session rather than a recorded lecture. The tutor explains the idea, works an example, checks understanding, and adjusts the next step to the answer given.

  • Designing your team's agent setup — Match each job to the right surface: agent mode in the editor for local changes, plan first for anything sizeable, cloud agent for background work on a branch that becomes a pull request (always, when you assign an issue), and Copilot CLI for the terminal and scripts. Learners also decide which jobs shouldn't go to an agent at all.
  • Layered instructions every surface reads — Building on the repository instructions Core introduced, layer .github/copilot-instructions.md, path-specific instruction files with applyTo globs, AGENTS.md, and organisation and personal instructions so each surface reads the right rules. Keep each short and specific, and remember they steer chat and agents but not inline suggestions.
  • Custom agents: profiles with scoped tools — Write an agent profile (a Markdown file with a description, an optional tools list and MCP servers, and instructions in the body) in .github/agents/, or share it from the organisation. Agents can use every tool by default, so restrict them to what the role needs and test the restriction.
  • Skills and hooks for Copilot agents — Package repeatable know-how as skills the agent loads when relevant, and add hooks that run your own checks at agent events. Check the current docs for locations and events, and test that a hook really blocks what it should.
  • MCP servers for agent mode and cloud agent — Connect MCP servers in the editor and in cloud agent's repository settings, keep tokens in Agents secrets (Settings > Secrets and variables > Agents, names starting COPILOT_MCP_) rather than in files, prefer read-only tools, and review what each server exposes before trusting it.
  • Copilot CLI: interactive and scripted — Use Copilot CLI for terminal work and run it non-interactively in scripts with explicit allow and deny rules for tools. Learners build a read-only reporting job and check exactly what it was allowed to do.
  • Getting cloud agent ready to succeed — Write issues with a problem, acceptance criteria and files to touch; preinstall dependencies with copilot-setup-steps.yml in a GitHub Actions session (setup steps don't run in the default cloud sandbox); keep its restricted network and one-repository scope; and steer the pull request with @copilot comments.
  • Review gates, not rubber stamps — Use Copilot code review as an extra reviewer: it by default leaves a Comment review that doesn't count as a required approval (organisations can configure it to approve, so check your settings). Keep branch protections, required human approvals and tests in front of every agent pull request.
  • Governing and measuring agent work — Agree organisation policies for cloud agent, agent mode, CLI and MCP, know the limits of content exclusion, and measure agent work with your own tests, code scanning and review outcomes, because usage metrics don't measure quality.
  • Capstone: a team agent setup, end to end — Ship one real change through your setup: layered instructions, a scoped custom agent, an MCP tool, a cloud agent or CLI run with least privilege, and a reviewed pull request with a short note on what you measured.

Skills you build

Results are measured against named skills in the OneRange taxonomy of more than 10,000 skills, so a manager sees proficiency per skill rather than a completion tick.

Who it is for

Software developers. The material is pitched at advanced level, and takes roughly 150 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

It sits in the Tool: GitHub Copilot track of the Vero AI Catalog, and can be assigned to one person, a team, or the whole company.

How it is delivered and assessed

Delivery is conversational and interactive, including branching scenario, guided lab, code lab exercises. There is no video to sit through and no slide deck to click past.

Understanding is checked with a tool assessment of 5 items, with a pass mark of 70%.

Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Also in this track

  • All GitHub Copilot training courses →
  • GitHub Copilot: Core — Agent Mode, Code Review & Cloud Agent Hand-offs — The working level of GitHub Copilot after Essentials. Developers run agent mode on multi-file tasks and review every edit, choose context on purpose, set up repository custom instructions and prompt files, respond to Copilot code review on pull requests, hand their first issues to Copilot cloud agent, use Copilot on github.com and keep company code safe. Ends with one change taken through the whole workflow.
  • What's New in GitHub Copilot — A short refresher on the latest GitHub Copilot updates for developers
  • GitHub Copilot: Mastery — Org Rollout, Governance & Agent Operations — Running GitHub Copilot across an engineering organisation. Leads set enterprise and organisation policies and model access, apply content exclusion at scale, enforce Copilot code review with rulesets, build cloud agent environments with allowlists and secrets, govern MCP servers, read usage metrics honestly, measure quality impact, plan the rollout and handle incidents. Ends with an org rollout and governance plan plus a pilot repository setup.
  • GitHub Copilot: Essentials — Docs & Onboarding Playbook — A focused playbook for documentation and onboarding with GitHub Copilot. Learners use Copilot Chat to explain an unfamiliar module, audit an out-of-date README, write a new README and doc comments, and produce a handoff note in which every claim is traced to a line of code. They leave with docs a new teammate can trust and a habit of checking Copilot's claims against the code. About 45 minutes including the final.
  • GitHub Copilot: Essentials — Refactoring & Migration Playbook — A focused playbook for safe refactoring and migration with GitHub Copilot. Learners pin today's behaviour with characterization tests, use Copilot Chat to rename, extract a function and simplify legacy code in small behaviour-preserving steps, then migrate off a deprecated Python call without breaking anything. They leave with a step-by-step routine that keeps every refactor protected by tests. About 45 minutes including the final.
  • GitHub Copilot: Placement Check — Start here. The placement check places developers at Essentials, Core, Advanced or Mastery so you can assign training from the right level.
  • GitHub Copilot Pathway — Coding with GitHub Copilot, from first suggestions to running it across an engineering org: inline suggestions, chat and agent basics (Essentials); agent mode, custom instructions, Copilot code review and first cloud agent hand-offs (Core); custom agents, MCP, Copilot CLI and cloud agent environments (Advanced); and policies, metrics, rollout and incident response at org scale (Mastery). Also includes 4 optional playbooks (Testing, Code Review, Refactoring & Migration, Docs & Onboarding) to take any time after Essentials; they don't count toward the certificate.

Related

Frequently asked questions

How long does this course take?

It runs roughly 150 minutes at a typical pace. Because every session adapts, someone who already knows a topic moves through it quickly instead of sitting through an explanation they do not need.

How is it assigned to a team?

An administrator assigns it from the Vero dashboard to one person, a team, a department or the whole company, and sees progress and results per person and per skill.

Can we customise it with our own documents and terminology?

Yes. Administrators can copy this course into their own library and adapt it — edit the outline, change the duration, swap the assessment format, or ground it in internal documentation so answers cite the company's own source material.

Course code TUL-GHC-251.