A few weeks ago I sat the GH-600: Agentic AI Developer exam, and I’m glad to say I passed. It’s one of the more interesting Microsoft certification exams I’ve done, and I wanted to share my honest reflections, what the exam actually tests, and the labs I built along the way that you can use for free to prepare.
I’ve been spending a lot of time recently working with agentic AI systems, both professionally and as a personal interest, so the GH-600 felt like a natural next step. After going through the course material, building my own labs, and sitting the exam, I think there’s a gap in the community around how to prepare well for this one. Hopefully this post helps fill that gap a bit.
What the Exam Looks Like
Before anything else, the structure:
- Total questions: 52
- Question types: Multiple choice, drag and drop, drop-down selections, code fill-in
- Case study: 1 case study with 10 questions
- Time allowed: 140 minutes
- Focus: Heavily practical, implementation-oriented
The most important thing to understand upfront is that this is not a theory exam. Yes, there are conceptual questions, but a large portion of the exam asks you to reason through real implementation scenarios, fill in CI workflow YAML, troubleshoot from log files, and make decisions about permissions, tokens, and agent design patterns. If you go in having only read the theory, you will find it harder than expected.
Do Not Skip the Foundational Exams
This is probably the single most important piece of advice I can give: do not go straight to GH-600.
The exam draws on knowledge from multiple GitHub certification areas. I found that having done GH-300 (GitHub Foundations / Copilot) helped enormously, and I also had prior knowledge from GitHub Enterprise Advanced Security. That background context made a lot of the questions feel familiar and grounded rather than abstract.
If you’re planning your learning path, I’d suggest:
- Start with GH-300 (GitHub Copilot)
- Consider GH-500 and other GitHub certification tracks
- Then tackle GH-600
The exam expects you to combine GitHub Copilot knowledge, Actions/workflow expertise, and agentic system design fluency all at once.
What the Exam Actually Tests
These are some of the top-of-mind areas I remember being tested on. It’s not an exhaustive list, but these are the themes that stood out most to me.
CI Workflow Files — A Lot of Them
A significant portion of the exam revolves around GitHub Actions workflow YAML. You need to be comfortable reading and writing workflow files, understanding job structure, permissions blocks, and how agents are wired into CI pipelines.
There were questions on both deterministic workflows (traditional, predictable pipelines) and agentic/probabilistic workflows where AI agents are part of the execution. Understanding the distinction and knowing when to use each approach matters.
Permissions and Token Management
This was a recurring theme throughout. You need to know:
- What permissions the
GITHUB_TOKENhas by default and how to scope them at workflow and job level - How to securely pass tokens to agentic steps
- When to use
id-token: writefor OIDC-based authentication - How to limit blast radius when agents are operating in a CI context
A typical permissions block you should be very comfortable with looks something like this:
1 | permissions: |
Knowing why each permission exists and when you’d add or remove it is more important than memorising the list.
Hooks — Stopping Agents from Doing the Wrong Thing
There were questions around using Git hooks and GitHub-level controls to prevent agents from accidentally executing destructive or unintended commands. If you haven’t looked into how hooks can act as guardrails for agentic workflows, add that to your study list.
Troubleshooting — Logs, Session History, and PR Chats
The exam tests your ability to diagnose agentic workflow failures. That means reading agent logs, session history, and the conversation trail in pull requests and merge request discussions. Being methodical about where to look when something goes wrong is a real skill that the exam checks.
GitHub Copilot Memory
Copilot Memory is a relatively new feature and it made an appearance in the exam. Know what it is, how it works at a conceptual level, and how it affects agent behaviour across sessions.
MCP — Tooling and Consistency
Managing Model Context Protocol (MCP) servers consistently across local development and cloud/production deployments came up. You should understand:
- How to restrict which MCP tools an agent can call
- Permission levels for tool access
- The difference between what an agent can call vs. what it should be allowed to call in a given context
Getting this right is part of building safe and auditable agentic systems.
The Case Study
The case study had 10 questions built around a single scenario. Personally, I don’t read the full case study up front, because that takes a lot of time and I think it’s a bit of a waste. My approach is to read each question first, then go back into the case study and find only the relevant sections that help answer it. You’re not expected to absorb every detail before you start, you just need to know where to look. The context is always there when you need it, and this way you spend your time much more efficiently.
Why I Built Labs, and Why Learning by Doing Matters
I spent a lot of time building hands-on labs while preparing for this exam, and I genuinely believe that’s what made the difference. The concepts around agentic AI, CI integration, permissions, and MCP are the kind of things that only truly click when you’ve been through the failure modes yourself.
Reading that a token needs id-token: write permission for OIDC auth is one thing. Watching your pipeline fail with a 401 because you forgot it, then fixing it, and understanding exactly why it worked after, that’s a completely different level of understanding.
The exam checked that second level. Not “do you know the term” but “can you reason through what happens when this is misconfigured.”
I built some labs specifically to cover the practical concepts from the GH-600 curriculum, and I’ve made them publicly available so others can use them too.
Lab Starter Repo (your working environment):
github.com/sameeraman/gh-600-lab-starter
The starter includes a React and Vite frontend, an ASP.NET Core 8 Web API with Entity Framework Core, Bicep templates for Azure provisioning, and configuration for Azure Static Web Apps, App Service, managed identity, and Azure SQL Database.
Lab Instructions Repo (the exercises):
github.com/sameeraman/gh-600-lab-instructions
The instructions walk you through building up the CI pipeline incrementally, adding agentic jobs step by step, and working through the kinds of integration challenges you’ll be tested on in the exam. Unit tests and Playwright end-to-end tests are included.
These labs helped me a lot. I hope they do the same for whoever is preparing next.
Study Resources Worth Your Time
A few links I found useful during preparation:
- The official Microsoft Learn path for GH-600 is the right starting point
- Foundations of Agentic AI — Microsoft Learn
- My lab instructions repo (free, hands-on): gh-600-lab-instructions
Key Takeaways for Anyone Preparing
1. Build the foundations first. GH-300 is not optional groundwork, it’s directly relevant. Prior GitHub security knowledge also carries over.
2. Hands-on practice beats reading. The exam tests implementation reasoning, not just recall. Actually build something with GitHub Actions and Copilot agents.
3. Know your YAML. Workflow files are everywhere in this exam. Be comfortable reading and writing them, including permissions blocks.
4. Understand the agent safety patterns. Hooks, permissions scoping, MCP tool restrictions, and token handling are recurring themes for a reason. These are the guardrails that make agentic systems trustworthy.
5. Troubleshoot like an engineer. Practice working through failure scenarios from log output and session history. That skill is explicitly tested.
6. Budget time for the case study. With 10 questions in the scenario block, you want to be reading it with enough time left to think carefully.
7. Copilot Memory and MCP are fair game. They’re newer features but the exam covers them. Don’t skip them in your prep.
Final Thoughts
The GH-600 is one of the more genuinely relevant certifications I’ve done, because it tests knowledge that actually matters for anyone building or operating agentic AI systems on GitHub today. The concepts around secure CI integration, agent guardrails, permissions, and workflow design are not theoretical, they’re the real patterns you need to get right when you put AI agents in your pipelines.
If you’re preparing for it, invest the time in hands-on practice. Read the concepts, then go build something that breaks in the ways the concepts warned you about. That’s what makes it stick.
Good luck with your preparation. The labs are there for you to use, and I hope they make the journey a bit smoother.
Lab repos: gh-600-lab-starter and gh-600-lab-instructions