GitHub Copilot Expert
Using an AI coding assistant across the whole software lifecycle, and governing it
About this course
An advanced course on working with an AI coding assistant as a professional tool rather than an autocomplete novelty: how it builds context, how to steer it deliberately, and how to use it across requirements, tests, review, documentation, CI/CD and infrastructure code.
The last third is the part teams usually skip: policy and content controls, honest measurement of whether it is actually helping, responsible-AI risks in generated code, and a rollout that does not collapse after the pilot.
Six mentored modules with hands-on labs and a practice brief in each, plus a pre-assessment, a post-assessment and a group capstone.
What you’ll be able to do
- Build an accurate mental model of how the assistant assembles context, and steer it deliberately instead of hopefully
- Apply advanced prompting patterns — few-shot inline, chaining, test-driven prompting, negative constraints — and know which one a situation calls for
- Use chat, inline and agent modes across the lifecycle: story refinement, architecture decision records, threat modelling, test generation, review and documentation
- Generate and debug CI/CD workflows, infrastructure code and operational scripts, and review the output critically
- Understand enterprise rollout mechanics: network requirements, identity provisioning, proxies, restricted environments and plan differences
- Configure policy and content controls, and analyse audit logs
- Measure whether adoption is actually helping, using acceptance rate, time-to-merge, DORA and SPACE — and recognise the metrics that mislead
- Run a change-management approach that survives the end of the pilot
Before you start
What this course assumes you can already do.
- Professional software development experience on a team, including code review.
- Working knowledge of CI/CD and GitHub Actions workflow YAML.
- Docker basics: building an image and authoring a Dockerfile.
- Familiarity with REST API design, and some exposure to infrastructure as code.
- Basic security hygiene: secrets management and what static analysis is for.
- Your own GitHub Copilot subscription and a development environment for the labs.
The curriculum
Open any module to see its objective, every teaching topic, the practice brief and the checkpoint.
Recaps and reference material are included in the LMS.
PART 1The craft
01Advanced Prompting and AI Pair Programming
Stop being surprised by the assistant. Know what it can see, what it cannot, and which prompting pattern to reach for when a suggestion is close but wrong.
- How Copilot builds contextConcept
- Advanced prompting patternsConcept
- Lab: prompt engineering kataHands-on
Find out what the assistant can actually see
Run a controlled experiment on context. Take one function you need written and attempt it four ways: cold file, with the relevant type definitions open in tabs, with a comment anchor describing the contract, and with a failing test written first.
Knowledge checkpoint with explained answers
02Copilot Chat and Agentic Workflows
Work fluently in chat and agent modes, and take an issue to a pull request through a plan you have reviewed rather than code you have accepted blind.
- Copilot Chat deep-diveHands-on
- From issue to pull request: plan, review and iterateConcept
- Lab: issue to pull request with an agentHands-on
Take an issue to a reviewable plan, then break the plan
Pick a real issue that touches at least three files. Use whichever agentic issue-to-pull-request flow your environment currently provides to produce a plan, then review the plan properly before accepting any code.
Knowledge checkpoint with explained answers
PART 2Across the lifecycle
03End-to-End SDLC Acceleration
Use the assistant everywhere in the lifecycle it genuinely helps — and be specific about the places where accepting its output would be negligent.
- Requirements and architecture assistanceHands-on
- Test generation and quality assuranceHands-on
- Code review, refactoring and documentationHands-on
- Lab: full feature sprint simulationHands-on
One feature, every phase, with the failures recorded
Build a small service end to end with assistance at every phase: refine the story, draft an architecture decision record, threat-model it, generate tests, implement, document, and review a colleague's work.
Knowledge checkpoint with explained answers
04CI/CD and Engineering Workflows
Generate pipeline and infrastructure code fast, then review it like the security-relevant code it is.
- GitHub Actions with CopilotHands-on
- Infrastructure as code, scripting and ops accelerationHands-on
- Lab: build a CI pipeline from scratchHands-on
Review generated pipeline code like a security reviewer
Generate a full pipeline — lint, test, build, container image, software bill of materials — and a small infrastructure module. Then review the output as though you were signing off on it for production.
Knowledge checkpoint with explained answers
PART 3Enterprise and governance
05Extensions, Integrations and Enterprise Deployment
Understand how the assistant is extended with organisation-specific knowledge, and what an enterprise rollout actually has to solve before anyone writes a line of code.
- Extending Copilot with your own agents and skillsConcept
- Enterprise rollout patternsConcept
- Lab: bring your organisation's knowledge into the assistantHands-on
Design the rollout constraints before the pilot
Write the enterprise deployment note for an organisation you know: network, identity, proxy, restricted environments and plan choice. Then design — on paper — an extension that would bring your organisation's own knowledge into the assistant.
Knowledge checkpoint with explained answers
06Governance, Adaptation and Responsible AI
Put controls in place that hold, measure adoption in a way that would survive an auditor, and lead the change honestly — including being willing to report that it is not working.
- Policy and content exclusionsHands-on
- Measuring developer productivityConcept
- Responsible AI and adoption strategyConcept
- Questions and open discussionConcept
Build the measurement and the exit criteria together
Design the governance and measurement position for an adoption programme — including, up front, what result would make you recommend stopping.
Knowledge checkpoint with explained answers
A microservice built with AI-accelerated delivery, and the governance to go with it
A capstone that deliberately forces integration across all six modules: a technical deliverable, a governance or process artefact, and a presentation to a stakeholder audience. Working in a group, you build a full REST microservice from an issue backlog with the assistant used at every phase, capture before-and-after velocity, and present a productivity impact report.
Backlog and baseline — Set up the work and the measurement before the assistance starts.
Build with assistance at every phase — Requirements to implementation to tests, assisted and reviewed.
Pipeline and infrastructure — Generated, then reviewed as security-relevant code.
Governance artefact — The process deliverable that sits alongside the code.
Stakeholder presentation — Present it to a room that will ask hard questions.
Next course
Tell us about yourself or your team and we’ll let you know how and when you can take this course.