GitHub Copilot Mastery: GH-300 & GH-600 Certification Program

You can explain what Copilot is doing when it suggests code, which is what lets you judge a suggestion instead of accepting it.

1. From autocomplete to code generation1 hr
   • token prediction
   • code-trained models
   • suggestion ranking
   • inline vs chat
   • latency budget
2. What goes into the context window1 hr
   • current file
   • open tabs
   • neighbouring files
   • symbol references
   • what is excluded
3. Why suggestions are confidently wrong1 hr
   • plausible syntax
   • invented APIs
   • outdated patterns
   • silent logic errors
   • no execution feedback
4. Copilot plans and what each includes1 hr
   • individual
   • business
   • enterprise
   • feature differences
   • data handling terms
5. Trust calibration as a skill1 hr
   • verify before accept
   • high-risk categories
   • review discipline
   • over-reliance signals
   • measuring your own accuracy
6. Where Copilot fits beside other AI tools1 hr
   • IDE assistants
   • chat assistants
   • autonomous agents
   • review bots
   • choosing per task

Hands-on project: Write a short internal briefing for your team on how Copilot builds its context, where its suggestions come from, and three categories of suggestion to never trust.

You can get Copilot working correctly in any common editor and know which organisation settings are affecting what you see.

1. Installing in VS Code and JetBrains1 hr
   • extension install
   • authentication
   • status indicators
   • keybindings
   • troubleshooting
2. Neovim, Visual Studio and the CLI1 hr
   • Neovim plugin
   • Visual Studio support
   • gh copilot CLI
   • terminal suggestions
   • shell explain
3. Account types and seat assignment1 hr
   • personal vs org seat
   • seat management
   • billing
   • policy inheritance
   • access revocation
4. Settings that change suggestion behaviour1 hr
   • enable by language
   • inline suggest delay
   • public code filter
   • telemetry settings
   • per-workspace config
5. Content exclusion and what it hides1 hr
   • exclusion syntax
   • repository scope
   • organisation scope
   • verification
   • known gaps
6. Proxies, firewalls and offline failure modes1 hr
   • network requirements
   • proxy configuration
   • certificate interception
   • degraded mode
   • diagnostics

Hands-on project: Configure Copilot in two IDEs with content exclusion applied, and document which suggestions changed as a result.

You can shape inline suggestions deliberately rather than hoping the next keystroke produces something useful.

1. Writing code that invites good suggestions1 hr
   • descriptive naming
   • type annotations
   • function signatures first
   • small functions
   • consistent style
2. Comment-driven generation1 hr
   • intent comments
   • example in comment
   • constraint statements
   • expected output
   • comment removal after
3. Accepting, cycling and partial acceptance1 hr
   • accept full
   • accept word
   • cycle alternatives
   • reject and retype
   • keyboard efficiency
4. Open tabs as context control1 hr
   • tab influence
   • closing noisy files
   • opening reference files
   • ordering effects
   • workspace hygiene
5. Language and framework differences1 hr
   • strong typing advantage
   • dynamic language pitfalls
   • framework idioms
   • niche language quality
   • version drift
6. Measuring suggestion usefulness1 hr
   • accept rate
   • edit-after-accept
   • time saved
   • noise cost
   • personal tracking

Hands-on project: Take a sparse file and, using only comments, naming and structure, drive Copilot to produce a correct implementation without editing its output.

You can use chat for the tasks it is genuinely better at than inline completion, and stop using it for the ones it is not.

1. Chat in the IDE versus inline1 hr
   • when chat wins
   • when inline wins
   • context differences
   • conversation state
   • cost of switching
2. Slash commands and participants1 hr
   • explain
   • fix
   • tests
   • workspace participant
   • terminal participant
3. Referencing files, selections and symbols1 hr
   • file references
   • selection scope
   • symbol references
   • multi-file context
   • reference limits
4. Iterating on an answer1 hr
   • follow-up prompts
   • constraint tightening
   • asking for alternatives
   • rejecting politely
   • knowing when to stop
5. Chat for comprehension rather than generation1 hr
   • explain this function
   • trace this bug
   • summarise this module
   • architecture questions
   • verifying the explanation
6. Managing a long chat session1 hr
   • context drift
   • starting fresh
   • summarising state
   • pinning constraints
   • session hygiene

Hands-on project: Resolve three realistic tickets using chat only, recording for each whether chat was faster than writing it yourself.

You can write prompts that produce code matching your codebase's conventions rather than generic tutorial code.

1. Specificity, constraints and acceptance criteria1 hr
   • stating constraints
   • edge cases up front
   • performance requirements
   • style requirements
   • definition of done
2. Giving examples from your own codebase1 hr
   • pattern anchoring
   • reference implementation
   • convention transfer
   • anti-example
   • example freshness
3. Decomposing a large request1 hr
   • task splitting
   • ordering
   • incremental verification
   • context reset
   • integration step
4. Custom instructions and repository context1 hr
   • instruction files
   • repository conventions
   • per-language rules
   • team sharing
   • precedence
5. Prompt patterns that reliably work1 hr
   • signature first
   • test first
   • pseudocode then code
   • refactor in steps
   • explain then implement
6. Recognising a prompt that will not work1 hr
   • under-specified intent
   • missing domain knowledge
   • too large a change
   • ambiguous naming
   • escalate to writing it yourself

Hands-on project: Produce a prompt pattern library for your team covering five recurring task types, with before and after examples.

You can make Copilot aware of a large codebase and understand why it still misses things.

1. How workspace indexing works1 hr
   • repository indexing
   • semantic search
   • symbol graph
   • index freshness
   • large repo limits
2. Asking questions about a whole codebase1 hr
   • where is this implemented
   • how does this flow work
   • finding usages
   • architecture summaries
   • answer verification
3. Monorepos and multi-root workspaces1 hr
   • monorepo context
   • multi-root setup
   • scope narrowing
   • cross-package questions
   • noise reduction
4. Knowledge bases and external documentation1 hr
   • knowledge base setup
   • doc indexing
   • citation of sources
   • staleness
   • access control
5. Limits of repository awareness1 hr
   • runtime behaviour
   • infrastructure config
   • tribal knowledge
   • recent changes
   • when to ask a human
6. Improving what the index can see1 hr
   • readme quality
   • consistent structure
   • dead code removal
   • naming clarity
   • doc colocation

Hands-on project: Evaluate workspace-aware answers on a repository of over a thousand files, documenting five questions it answered well and five it did not.

You can use Copilot to write tests that are worth keeping, and recognise the plausible-but-useless tests it produces by default.

1. Generating unit tests from implementation1 hr
   • test scaffolding
   • framework detection
   • naming conventions
   • setup and teardown
   • mocking
2. The tautological test problem1 hr
   • tests that mirror implementation
   • asserting nothing
   • mocked everything
   • false coverage
   • detection heuristics
3. Edge cases and boundary generation1 hr
   • boundary prompting
   • null and empty
   • error paths
   • concurrency cases
   • property ideas
4. Test-first development with Copilot1 hr
   • write test then implement
   • red-green loop
   • implementation from tests
   • avoiding overfit
   • refactor step
5. Integration and end-to-end test generation1 hr
   • fixture generation
   • test data
   • flaky pattern avoidance
   • setup cost
   • value judgement
6. Reviewing generated tests honestly1 hr
   • mutation thinking
   • does it fail when broken
   • coverage vs confidence
   • deletion criteria
   • review checklist

Hands-on project: Raise meaningful coverage on an untested module, with every generated test reviewed and at least three rewritten because they asserted nothing real.

You can drive a multi-file change with AI assistance without losing track of what changed or why.

1. Planning a refactor before touching code1 hr
   • change inventory
   • dependency order
   • test safety net
   • commit plan
   • rollback points
2. Small safe transformations at scale1 hr
   • rename patterns
   • signature changes
   • extract function
   • inline variable
   • mechanical edits
3. Framework and language version migrations1 hr
   • deprecation mapping
   • API differences
   • codemods
   • incremental migration
   • compatibility shims
4. Keeping changes reviewable1 hr
   • commit granularity
   • one concern per commit
   • diff size limits
   • commit messages
   • reviewer empathy
5. Verifying behaviour is unchanged1 hr
   • characterisation tests
   • golden output
   • diff of behaviour
   • performance check
   • rollback trigger
6. When to stop and do it by hand1 hr
   • thrashing signals
   • repeated wrong suggestions
   • context exhaustion
   • time budget
   • honest assessment

Hands-on project: Migrate a module from one framework version to another across at least fifteen files, with a reviewable commit sequence and passing tests at each step.

You can use an assistant to understand unfamiliar code and narrow a bug faster, while keeping the diagnosis your own.

1. Explaining unfamiliar code1 hr
   • function explanation
   • data flow tracing
   • dependency summary
   • naming the pattern
   • verifying the explanation
2. Interpreting errors and stack traces1 hr
   • stack trace explanation
   • error message decoding
   • likely causes
   • reproduction steps
   • ruling out
3. Hypothesis generation and narrowing1 hr
   • candidate causes
   • cheapest test first
   • bisecting
   • instrumentation suggestions
   • eliminating
4. Terminal and command assistance1 hr
   • gh copilot suggest
   • gh copilot explain
   • shell one-liners
   • dangerous command review
   • alias building
5. Where the assistant misleads you1 hr
   • confident wrong diagnosis
   • inventing causes
   • ignoring runtime state
   • anchoring bias
   • independent verification
6. Reading code faster with and without help1 hr
   • entry point first
   • call graph
   • data shapes
   • naming cues
   • when to stop reading

Hands-on project: Diagnose three bugs in an unfamiliar codebase using chat for comprehension, documenting the point at which your own reasoning took over.

You can use AI for the writing around code without producing documentation nobody trusts.

1. Docstrings and inline documentation1 hr
   • docstring generation
   • parameter documentation
   • example generation
   • accuracy checking
   • staying in sync
2. READMEs, guides and architecture notes1 hr
   • structure prompting
   • audience setting
   • diagram descriptions
   • keeping it short
   • review by a newcomer
3. Commit messages and pull request descriptions1 hr
   • why not what
   • conventional commits
   • PR template filling
   • change summary
   • reviewer guidance
4. AI-assisted code review1 hr
   • review prompts
   • finding categories
   • false positive rate
   • human judgement
   • review etiquette
5. Documentation that goes stale1 hr
   • drift detection
   • doc tests
   • generated vs written
   • ownership
   • deletion over staleness
6. Changelogs and release notes1 hr
   • change aggregation
   • audience framing
   • breaking change callouts
   • versioning
   • automation

Hands-on project: Produce API documentation, a migration guide and ten commit messages for a real change set, each reviewed and corrected.

You can keep velocity gains without letting defect rate rise, which is the failure mode teams actually experience.

1. The verification habit1 hr
   • read before accept
   • run before commit
   • test before PR
   • blast radius thinking
   • checklist discipline
2. Common defect patterns in generated code1 hr
   • off-by-one
   • wrong error handling
   • missing null checks
   • resource leaks
   • incorrect concurrency
3. Static analysis as a safety net1 hr
   • linters
   • type checkers
   • complexity limits
   • CI gating
   • suppression discipline
4. Measuring your own reliance1 hr
   • acceptance rate
   • revert rate
   • review comment rate
   • skill atrophy signals
   • deliberate practice
5. Team standards for AI-assisted code1 hr
   • disclosure norms
   • review expectations
   • test requirements
   • pairing rules
   • onboarding guidance
6. Where AI assistance is a net negative1 hr
   • unfamiliar domains
   • security-critical code
   • performance-critical paths
   • learning situations
   • honest trade-off

Hands-on project: Measure your own accept-then-revert rate across a week of work and produce a personal verification checklist from the findings.

You can stop an assistant introducing a vulnerability or a licence problem into your codebase, with controls rather than vigilance alone.

1. Vulnerability classes in generated code1 hr
   • injection flaws
   • weak cryptography
   • insecure deserialisation
   • path traversal
   • authentication gaps
2. The public code filter and licensing1 hr
   • duplication detection
   • filter behaviour
   • licence obligations
   • attribution questions
   • policy position
3. Secrets and sensitive data in prompts1 hr
   • secret leakage
   • prompt hygiene
   • content exclusion
   • secret scanning
   • rotation after exposure
4. GitHub Advanced Security integration1 hr
   • code scanning
   • secret scanning
   • dependency review
   • autofix suggestions
   • triage workflow
5. Supply chain and dependency suggestions1 hr
   • hallucinated packages
   • typosquatting risk
   • version pinning
   • SBOM
   • dependency review
6. Security review for AI-assisted work1 hr
   • review checklist
   • threat modelling
   • high-risk file list
   • mandatory human review
   • audit evidence

Hands-on project: Audit a codebase written with AI assistance for injected vulnerabilities, secret exposure and licence risk, and produce a remediation plan.

You can roll Copilot out across an organisation with the controls a security team will accept.

1. Organisation and enterprise policy settings1 hr
   • policy inheritance
   • feature toggles
   • public code filter policy
   • chat availability
   • audit of settings
2. Seat management and cost control1 hr
   • seat assignment
   • inactive seat reclamation
   • cost per developer
   • budget forecasting
   • approval workflow
3. Content exclusion at scale1 hr
   • repository patterns
   • organisation-wide rules
   • sensitive path lists
   • verification
   • known limitations
4. Audit logs and compliance evidence1 hr
   • audit log events
   • retention
   • access reviews
   • evidence for auditors
   • incident investigation
5. Data handling and contractual terms1 hr
   • prompt retention
   • training data usage
   • regional processing
   • DPA review
   • legal sign-off
6. Pilot design and phased rollout1 hr
   • pilot cohort
   • success criteria
   • feedback loop
   • expansion gates
   • rollback plan

Hands-on project: Produce a rollout plan for a two-hundred-developer organisation: seat strategy, policy configuration, exclusions, training and a measurement plan.

You can tell whether the tool is actually helping, with evidence rather than survey enthusiasm.

1. Metrics that mean something1 hr
   • cycle time
   • PR throughput
   • defect escape rate
   • review burden
   • developer-reported friction
2. Metrics that mislead1 hr
   • lines of code
   • acceptance rate alone
   • self-reported productivity
   • survey bias
   • Goodhart effects
3. Designing a fair comparison1 hr
   • baseline period
   • task comparability
   • confounders
   • sample size
   • statistical humility
4. Adoption, training and uneven benefit1 hr
   • skill dependence
   • language dependence
   • task dependence
   • training programme
   • champion model
5. Reporting honestly to leadership1 hr
   • what improved
   • what did not
   • cost per seat
   • recommendation
   • revisit cadence
6. Renewal decisions and vendor review1 hr
   • renewal criteria
   • alternatives assessment
   • negotiation data
   • seat right-sizing
   • exit plan

Hands-on project: Design and run a four-week measurement study comparing assisted and unassisted work, and present findings honestly including where there was no gain.

You can deliver a real feature end to end with AI assistance at a quality bar you would defend in review, and answer certification-style questions under time.

1. Planning and decomposition1 hr
   • ticket analysis
   • change inventory
   • prompt plan
   • test strategy
   • commit plan
2. Implementation across the codebase2 hrs
   • multi-file change
   • convention adherence
   • incremental verification
   • context management
   • pair discipline
3. Tests, documentation and the pull request2 hrs
   • test generation and review
   • docstrings
   • PR description
   • reviewer guidance
   • CI green
4. Security audit of your own output2 hrs
   • vulnerability scan
   • secret check
   • licence review
   • dependency review
   • remediation
5. Measurement write-up and rollout plan2 hrs
   • metrics gathered
   • honest findings
   • policy recommendations
   • training plan
   • cost model
6. Timed certification simulation and review1 hr
   • question formats
   • time budgeting
   • distractor elimination
   • mock exam
   • panel review

Hands-on project: Deliver a complete feature on a real codebase using AI assistance throughout: planning, implementation across multiple files, generated and reviewed tests, documentation, commit sequence and pull request — plus a security audit of your own output, a measurement write-up, an organisation rollout plan, and a timed certification-style exam.