Reference & Certification
A GH-300 study map, a glossary, a one-page cheat sheet, and where to go next — everything to revise from and to keep within reach.
Think of this page as the cheat-sheet at the back of a board-game box: the quick reminders, the word list, and the “what beats what” tables all in one place, so you can look things up fast instead of re-reading the whole rulebook.
GH-300 study map
☺ Like you’re 10: A checklist of everything the big test might ask, so you can tick off what you already know and spot what still needs practice — like a packing list you check before a trip.
If you’re working toward the GH-300 GitHub Copilot certification, here’s how this course maps to what the exam emphasizes. Use it as a revision checklist — make sure you can answer each prompt cold. Aiming at Anthropic’s CCAR-F instead? The same foundations apply — that hub carries its own scenario-based study map.
Fundamentals & responsible use
- What Copilot is, the surfaces it runs on, the plan tiers — distinguish Free / Pro / Pro+ / Business / Enterprise capabilities. (C1)
- How completions use context; what Next Edit Suggestions adds. (C1)
- Responsible AI: human oversight, transparency, privacy, data handling, limits of generated code. (05, 20)
- Premium requests vs. the base model; what consumes budget. (C1, 20)
Using Copilot effectively
- The three chat modes (Ask / Edit / Agent) and when to use each. (C1)
- Context tools:
@workspace,#file, slash commands, semantic search. (C1) - Prompting best practices. (C1)
- Choosing models: the separate chat and completions models, Auto model selection, and BYOK / local models. (09)
Agents
- Agent mode (in-IDE) vs. the cloud agent (async) — the single most testable distinction. (C3)
- The issue-to-PR workflow; the cloud agent’s sandbox, self-review, and security scanning. (C3)
- Custom instructions, prompt files, Agent Skills (
SKILL.md), Spaces, and MCP. (C4, 06)
Building & extending
- Copilot Extensions: skillsets vs. agents, built as GitHub Apps. (12)
- The Copilot SDK and what it provides; BYOK. (12)
- Agent Skills structure and the shell-approval security caveat. (C4)
Administration & governance (heavier on Business/Enterprise)
- Policy management, access control, audit logs, the control plane. (20)
- Usage/metering review and cost governance. (20)
Certification objectives change. Confirm the current GH-300 objectives on the official certification page before sitting it — and note this course goes beyond the exam in places (the SDK capstone, multi-agent ops), which is good for real work even where it exceeds what’s tested.
Glossary
☺ Like you’re 10: A mini dictionary — every tricky word from the course explained in one line, so if you forget what one means you can look it up in a second.
Foxy: Wait — what does “agent” even mean again? I keep mixing it up with a plain chatbot!
Ellie the Elephant: I remember it word for word: an agent is Model + Tools + Memory + Planning. No tools, and it’s just a chatbot.
Nutty the Squirrel: And it’s stashed right here in the glossary and the cheat sheet — one line, always within reach.
Professor Owl: That’s the whole point of this page: forget a term, look it up in a second, and get back to building.
| Term | Meaning |
|---|---|
| Agent | An LLM wrapped in a loop that can use tools, keep memory, and act on the world. Model + Tools + Memory + Planning. |
| Agentic AI | Systems that don’t just respond but plan, act, observe results, and iterate toward a goal. |
| Agent mode | Copilot’s in-editor autonomous mode: plans, edits multiple files, runs commands, iterates. Claude’s in-editor/terminal equivalent is Claude Code. |
| Cloud agent | Copilot’s async background worker; turns an assigned issue into a draft PR in a sandboxed Actions environment. |
| Claude Code | Anthropic’s agentic coding tool in your terminal/editor: plans and edits across a codebase, with project memory (CLAUDE.md) and MCP. Claude’s parallel to Copilot’s agent mode + CLI. |
| Cowork | Anthropic’s async knowledge-work app: hand off a longer multi-step job and review the result. Claude’s parallel to Copilot’s cloud agent. |
| Agent HQ | A control plane that orchestrates coding agents from multiple providers across GitHub surfaces. |
| Agent Skill | A SKILL.md folder teaching an agent a repeatable specialized procedure (with optional scripts). |
| BYOK | Bring Your Own Key — using your own model-provider API keys with the Copilot SDK instead of the subscription. |
| Copilot Extension | An external capability plugged into Copilot Chat via @mention, built as a GitHub App; either a skillset (you provide API endpoints, Copilot handles the AI) or an agent (you control the full interaction). |
| Copilot SDK | A library exposing the same agent runtime behind Copilot CLI, to embed agentic workflows in your own apps (TS, Python, Go, .NET, Rust, Java). Anthropic’s counterpart is the Claude Agent SDK. |
| Custom instructions | Always-on project conventions an assistant loads as context: copilot-instructions.md / AGENTS.md for Copilot, CLAUDE.md for Claude. |
| Eval | Criteria-based testing of non-deterministic AI output; the “unit test” of AI systems; gates releases. |
| MCP | Model Context Protocol — open standard for connecting external tools/data (“MCP servers”) to an agent. See MCP — Tools for Agents. |
| NES | Next Edit Suggestions — predicts where your next edit will be, not just what comes after the cursor. |
| Premium request | A budgeted call to a frontier model; agentic, multi-step work consumes these per step. |
| Prompt file | A reusable, version-controlled prompt stored as Markdown in the repo. |
| Prompt injection | Malicious instructions hidden in content an agent reads, attempting to hijack its behavior; dangerous because tool-wielding agents can then take real actions. |
| ReAct | The Reason+Act loop most agents use: think, call a tool, observe, repeat. |
| Spaces | Copilot Spaces — curated project-specific knowledge bundles used to ground answers. |
| Token | The unit of text a model reads/generates (~¾ of a word). Context windows and pricing are measured in tokens. See How models work. |
| Context window | The maximum tokens (prompt + reply) a model can consider at once — its short-term memory. Overflow pushes older text out. |
| Hallucination | A confident, plausible, but false model output; it predicts likely text, not verified truth. Reduced by grounding and verification. |
| Temperature | The sampling randomness knob: low = focused/repeatable, high = varied/creative. |
| Prompting | Goal + context + constraints + examples + output format — the highest-leverage, tool-transferable skill. See Prompting & Context. |
| Few-shot | Steering a model by showing a few input→output examples rather than describing the format (zero / one / few-shot = 0 / 1 / several). |
| RAG | Retrieval-Augmented Generation — fetch relevant documents and add them to the prompt so the model answers grounded in real data. See Retrieval & RAG. |
| Embedding | A vector capturing the meaning of text, so similar meanings sit close together — enables search by meaning (semantic search). |
| Vector database | Stores embeddings and returns the top-k most similar to a query vector; the retrieval engine behind RAG. |
| Grounding | Basing an answer on supplied real documents instead of the model’s memory — the main defense against hallucination. |
| Fine-tuning | Further training that bakes knowledge/behaviour into a model’s weights. One of three ways to add knowledge (vs. long context and RAG). |
| Multimodal | A model that handles more than text — images, audio, video — as input and/or output. See Multimodal & Generative Media. |
| Diffusion model | The architecture behind most text-to-image generation: denoise from random noise toward an image. Distinct from the next-token LLM. |
| Machine learning (ML) | Systems that learn patterns from data instead of being explicitly programmed. A subset of AI; deep learning is a subset of ML. See The AI Landscape. |
| Neural network | Layers of simple units with weights learned from data; “deep learning” means many layers — the substrate under modern models. |
| Transformer / attention | The architecture behind modern LLMs; attention weighs which earlier tokens matter most for predicting the next one. |
| AGI | Artificial general intelligence — hypothetical human-level ability across any task. Today’s systems are narrow / task-specific. |
| Reasoning model | A model that generates step-by-step reasoning before answering, trading time for accuracy on hard problems. See Reasoning & Test-Time Compute. |
| Test-time compute | Spending more compute at inference (more “thinking”) to improve hard answers without a bigger model — the key 2025–26 shift. |
| Chain-of-thought (CoT) | Reasoning through intermediate steps before the answer; once a prompt trick, now native to reasoning models. |
| Agent memory | Continuity for agents: working memory (the context window) plus long-term episodic / semantic / procedural memory in a store. See Agent Memory. |
| Jailbreak | Coaxing a model past its safety guardrails to produce disallowed output. See AI Security. |
| Lethal trifecta | Private data + untrusted content + the ability to act = the data-exfiltration danger zone for agents. |
| Responsible AI | Fairness, transparency, privacy, accountability, human oversight, and safety — engineering practice, not PR. See Responsible AI & Safety. |
| Automation bias | Over-trusting confident machine output; a key reason to keep humans reviewing consequential AI decisions. |
One-page cheat sheet
☺ Like you’re 10: The whole course squished onto one page of quick reminders — the kind of note you’d love to have taped to your desk during the test (if you were allowed one!).
Which chat mode? Ask = understand. Edit = change what you know. Agent = do what you describe. Scope in Ask, execute in Agent.
Agent mode vs. cloud agent? Agent mode = synchronous, in your editor, you watch. Cloud agent = asynchronous, in the cloud, returns a draft PR. Claude parallel: Claude Code (synchronous) vs. Cowork / a cloud agent (asynchronous).
An agent = Model + Tools + Memory + Planning. No tools → it’s just a chatbot.
Model basics: it predicts the next token; measure context and cost in tokens; low temperature = repeatable, high = creative; it hallucinates when it lacks a fact — so ground and verify.
Give a model your knowledge: long context (stuff it in the window) · RAG (retrieve just what’s relevant — the usual pick) · fine-tune (bake into the weights). Grounding beats a bigger model for “it doesn’t know my stuff.”
Reasoning vs speed: for hard math / logic / planning / tricky debugging, reach for a reasoning model (it thinks step-by-step — test-time compute); for lookups and formatting, a fast standard model. Dial reasoning effort up only when accuracy is worth the latency and cost.
Four ways to build an agent: ① Agent Skill (Markdown) → ② Custom Agent (cloud-agent config) → ③ Copilot Extension (GitHub App: skillset or agent) → ④ Copilot SDK (embed the runtime). With Claude the same rungs are: a Skill / CLAUDE.md → a specialized config → an MCP server → the Claude Agent SDK. Pick the lowest rung that solves it.
Skillset vs. extension-agent? Skillset = you give ≤5 API endpoints, Copilot does the AI (start here). Agent = you control prompts/model/flow (more power, more work).
Multi-agent patterns: orchestrator–worker, pipeline, reviewer/debate, hierarchical. Use when tasks genuinely decompose; don’t over-decompose.
The two pipelines: A = agents help ship your software (issue→plan→code→review→test→deploy). B = your AI product’s own request-time flow (input→context→model→tools→response→log).
New AI pipeline stages: evals (replace exact-match tests), prompt/version management, model routing + fallbacks, tracing/observability, AI-specific security (prompt injection, OWASP ASI).
Cost levers: right-size the model (biggest lever), scope tasks tightly, monitor usage weekly, mind both premium requests and Actions minutes.
Guardrails (always): human gate on irreversible actions, least-privilege tools, sandboxing, full audit/trace, treat external content as untrusted.
AI security reflexes: everything the model reads is untrusted data, not commands (prompt injection); beware the lethal trifecta (private data + untrusted content + ability to act); least privilege + human gates + the OWASP LLM/Agentic Top-10 before prod.
Responsible AI: fairness, transparency, privacy, accountability, human oversight, safety. Match autonomy to blast radius; watch for automation bias; you own what you ship.
The ops flywheel: production failure → add it as an eval → fix prompt/tool → eval gate passes → redeploy. Failures become permanent tests.
Which model when
| Situation | Reach for… |
|---|---|
| Everyday coding, best balance | Auto — let Copilot route by task & availability |
| Hard multi-file reasoning, architecture, tricky bugs | A top frontier reasoning model (Claude Opus / GPT-5-class); raise reasoning effort |
| Fast, simple, high-volume edits | A fast/cheap model (or just Auto) |
| Refactor across a very large codebase | A 1M-context model with extended context |
| Agentic / tool-using task | A tool-calling-capable model (local: Llama 3.1+, Qwen2.5-Coder, Phi-4) |
| Sensitive/proprietary code — nothing leaves the machine | Local model via BYOK (Ollama / Foundry Local) |
| Offline / air-gapped | Local model + VS Code BYOK (no completions or semantic search) |
| Out of premium-request budget / cost-sensitive | A 0×–1× model, Auto, or a local model |
| Inline completions (ghost text) | The completions model — set separately; local not supported |
Downloads & study aids
Downloadable files (in the course zip):
- Printable cheat sheet — the whole course on one page (autonomy ladder, the agent loop, MCP config, the which-model-when table, guardrails, the ops flywheel): cheat-sheet.pdf.
- GH-300 exam-day sheet — a separate one-pager of just certification-scoped facts (logistics, the six domains, plans, privacy & data handling, modes & features): exam-day.pdf.
- MCP starter kit — ready-to-use
mcp.jsonand a VS Codeserversvariant, plus a README: mcp-starter/. - Diagram exports — clean SVGs of the autonomy spectrum, the agent loop, MCP architecture, and both pipelines, for your own notes and slides: diagrams/.
Interactive study aids (built into the course):
- Lab Track — one numbered, checkable path through every hands-on exercise.
- Self-Check — a quick 10 or the full 135-question bank, with instant feedback to test recall.
- Flashcards — a flip deck of the key terms, with shuffle and mark-known.
- Common Mistakes & Fixes — the failure modes that bite beginners, each with a one-line fix.
(In the single-file version, the interactive aids are in the sidebar; the downloadable files live in the multi-page course zip.)
Where to go next
- Official docs — the sources of truth for current features, limits, and pricing across the four assistant tracks: docs.github.com/copilot (Copilot), docs.claude.com (Claude, Claude Code, the API, and the Claude Agent SDK), platform.openai.com/docs (OpenAI models, the API, and the Agents SDK), and ai.google.dev (the Gemini API and Google AI Studio). Check them whenever this course’s specifics feel out of date.
- Agent SDKs — the runtimes you can embed in your own apps: the Copilot SDK (
github/copilot-sdk, the runtime you used in the capstone), the Claude Agent SDK, and the OpenAI Agents SDK — for the exact, current API of each. - Cookbooks & recipes — worked, runnable examples to study and adapt: the Claude Cookbook, the OpenAI Cookbook, and Google’s Gemini API cookbook in Google AI Studio.
- Copilot Extensions org — github.com/copilot-extensions — example skillsets and agents, plus the preview SDK for extension-agents.
- Awesome Copilot — community-curated skills, prompt files, and instructions to study and adapt.
- Provider blogs — for what shipped most recently (these products move fast): the GitHub Blog (AI & ML / Copilot), the Anthropic news & engineering blog, the OpenAI blog, and the Google AI / DeepMind blog.
- OWASP Agentic Security Initiative (ASI) Top 10 — the security checklist to run any agent system against before production.
Beyond this course — advanced & adjacent AI
☺ Like you’re 10: This course taught you to drive and build with AI helpers. There’s a whole other side — learning to build the engines themselves, plus kinds of AI that aren’t chatbots at all. Here’s the map of what’s next if you want to go deeper.
This course deliberately focused on applied, agentic AI — using and building with LLM assistants. That’s one important slice of a much bigger field. The areas below were intentionally left out of scope; when you’re ready to go wider or deeper, this is where each leads. (🦎 Cami the Chameleon’s world, it turns out, is bigger than one course.)
| Advanced / adjacent area | What it is | Reach for it when… |
|---|---|---|
| Classical ML & data science | Regression, classification, clustering, decision trees, feature engineering — the non-LLM machine learning that still powers most production systems. | You need prediction on structured / tabular data, not text generation. |
| Deep learning from scratch | The math and craft under the models: neural nets, backpropagation, gradient descent, PyTorch / TensorFlow. | You want to understand and build models, not just use them — the theory beneath How AI models work. |
| Training & fine-tuning your own models | Pretraining, fine-tuning, LoRA / PEFT, RLHF & alignment, distillation, quantization. | RAG and prompting aren’t enough and you must bake knowledge or behaviour into the weights. |
| Computer vision & classic NLP (as fields) | CNNs, object detection, segmentation; tokenization, parsing, and traditional NLP pipelines — beyond what a general multimodal model gives you. | You need specialized perception or language tooling a general model can’t do well. |
| Reinforcement learning | Agents that learn from reward through trial and error — games, robotics, control, and the basis of RLHF. | Behaviour must be learned from feedback rather than prompted or retrieved. |
| MLOps & AI infrastructure | Model serving, GPUs, scaling, deployment, and monitoring model drift — the infra beneath production models (this course covered agent ops, not model-serving infra). | You operate models — not just agents — at scale. |
| Data engineering for ML | Pipelines, labeling, feature stores, synthetic data, and data quality — 🐿️ Nutty’s deeper world. | Your models are only as good as the data feeding them. |
None of these are prerequisites for what you learned here — you can build real, useful agentic AI without them. But they’re the natural next mountains to climb. The Further Reading library and the wider landscape are good on-ramps.
A closing word
You started thinking these assistants were autocomplete. You’re ending able to build, ship, and operate an autonomous AI system. The single most important idea to carry forward is the one we opened with: everything is a point on the autonomy spectrum, and the engineering skill is choosing how much to hand off and how to stay safely in the loop. Completions hand off a line. The cloud agent hands off a task. A multi-agent system hands off a workflow. Your job — as the human — is never going away; it’s moving up the ladder from writing every line to directing, reviewing, and operating the systems that do.