🧠 GH-600 - GitHub Certified: Agentic AI Developer
GH-600 is GitHub's certification for engineers who don't just chat with AI, but actually run agents inside a real software development lifecycle - wiring up tools, managing state, evaluating output, orchestrating multiple agents, and putting guardrails around all of it, with GitHub as the control plane.
If GH-300 was about using GitHub Copilot, GH-600 is about operating and governing the agents that come after it.
This page is the home for a new video series on agentic AI, built on Microsoft Learn's GH-600 material and shown through real work on a real repository rather than slides. Episodes are added here as they're published - bookmark it and check back.
Start with the GitHub Copilot series (GH-300) for the fundamentals, then come back here for the agentic layer.
📋 Exam at a Glance
| Exam code | GH-600 |
| Certification | GitHub Certified: Agentic AI Developer |
| Level | Intermediate |
| Duration | 120 minutes |
| Passing score | 700 / 1000 |
| Delivery | Proctored, via Pearson VUE |
| Prerequisites | None formally required |
Assumed experience: the SDLC, GitHub workflows and repository controls, code quality/security/review practices, and real hands-on time with coding agents - GitHub Copilot, MCP servers, and agent customisation such as custom instructions.
Exam details can change, especially while a certification is new. Always confirm against the official Microsoft Learn certification page and its study guide before you book.
🎯 Skills Measured
The exam is organised into six domains:
| # | Domain | Weight |
|---|---|---|
| 1 | Prepare agent architecture and SDLC processes | 15-20% |
| 2 | Implement tool use and environment interaction | 20-25% |
| 3 | Manage memory, state and execution | 10-15% |
| 4 | Perform evaluation, error analysis and tuning | 15-20% |
| 5 | Orchestrate multi-agent coordination | 15-20% |
| 6 | Implement guardrails and accountability | 10-15% |
Domain 2 - tool use, MCP servers and environment interaction - carries the heaviest weighting, so that's where the deepest hands-on practice pays off.
🎬 Video Series
1. Chatbots vs Agentic Systems
What changes when AI can act on a task instead of just explaining it? This opener contrasts text-only chatbot responses with goal-directed agent workflows, using a recipe book vs chef analogy that makes the distinction stick: a recipe book hands you instructions, a chef goes and cooks - checking, tasting and adjusting along the way.
From there it gets practical - prompts, tasks, tools, permissions and retries - and ends with a real demo rather than a diagram. I ask a GitHub agent to add a video to this website, correct the title while it's still working, then review the pull request it produced, merge it myself, and check the change live.
Chapters
| Time | Topic |
|---|---|
| 00:00 | Series introduction and GH-600 learning resources |
| 01:08 | Three topics in the series |
| 02:03 | Chatbots vs agentic systems |
| 04:45 | Text-only chatbot demonstration |
| 05:38 | Comparing the ChatGPT response |
| 06:26 | Recipe book vs chef analogy |
| 07:43 | Prompts, tasks, tools, and retries |
| 10:05 | Dependency-update example |
| 10:51 | GitHub demo: asking an agent to update my website |
| 12:36 | Goals, tool calls, permissions, and iteration |
| 13:34 | Why human review still matters |
| 15:06 | Reviewing the PR and correcting the video title |
| 16:27 | Human merge and deployment |
| 17:39 | Checking the live website update |
The most important stretch is 13:34 onwards - why human review still matters. The agent did the work, but a person read the diff, caught a wrong title, and made the call to merge. That review gate is exactly what Domain 6 (guardrails and accountability) is asking about.
2. The Agentic AI Lifecycle - Plan to Pull Request
An agent makes a plan. Then what? This episode follows the agentic lifecycle end to end - how an agent forms a plan, why that plan changes mid-flight, and how it checks whether it actually hit the result you asked for. The Google Maps rerouting analogy carries the idea: the destination stays fixed, the route gets recalculated every time the road conditions change, and the system keeps evaluating rather than committing blindly to step one.
The second half turns the concept into something you can put in a repository today. Instead of letting an agent's plan evaporate the moment the work is done, it gets captured in a .github/pull_request_template.md so the reasoning lands in the pull request alongside the diff - goal and plan, scope, success criteria, rollback plan, agent context, validation results, and the human review.
What the PR template captures
| Section | Why it's there |
|---|---|
| Goal / Plan | The intent behind the change, in writing, before the diff |
| Scope | What the agent was and wasn't allowed to touch |
| Success criteria | How anyone reviewing can tell it worked |
| Rollback plan | The way out when it didn't |
| Agent context | Which agent, which instructions, which tools |
| Validation / Results | Evidence, not assertion |
| Human review | The named person who accepted it |
Files from the video
.github/copilot-instructions.md- the custom instructions steering the agent.github/pull_request_template.md- the template that makes the plan reviewable
Don't just let an agent make changes - make the plan behind those changes visible and reviewable. That single habit covers a surprising amount of Domain 1 (agent architecture and SDLC) and Domain 6 (guardrails and accountability) at once.
3. How to Control AI Agents in GitHub
An agent that writes the plan, does the work, then quietly updates the plan to match is grading its own homework. This episode is about the guardrails that stop that - letting agents move fast while you stay accountable for what they ship.
It starts with the three plan types and how much confidence each deserves, contrasts human-in-the-loop with fully agentic mode, and shows how to pre-commit the plan so you can prove it wasn't changed afterwards. Then it moves into the GitHub controls themselves - rulesets, CODEOWNERS, read-only token permissions, and environments with required reviewers - tied together with a CCTV analogy: recording what an agent did is not the same as controlling what it's allowed to do.
Chapters
| Time | Topic |
|---|---|
| 00:00 | Agents as your team: who is accountable? |
| 00:39 | GH-600 series and where this fits |
| 01:16 | Recap: plan template and Copilot instructions |
| 01:46 | 3 plan types and their confidence levels |
| 02:43 | Problem: the agent rewrites its own plan |
| 03:16 | Human-in-the-loop vs agentic mode |
| 04:28 | When you actually need a plan |
| 04:49 | Issue template: scope and out-of-scope |
| 05:23 | Pre-commit the plan (tamper check) |
| 06:46 | 6 controls to keep agents in line |
| 07:49 | Demo: GitHub rulesets |
| 09:00 | CODEOWNERS file for protected paths |
| 09:44 | Read-only token permissions in YAML |
| 10:04 | Environments, reviewers and secrets |
| 10:52 | Record vs control: the CCTV analogy |
| 12:14 | Summary: how the controls work together |
Controls covered
| Control | What it stops |
|---|---|
| Rulesets | Direct pushes and force pushes - changes must go through a PR, and new pushes need re-review |
| CODEOWNERS | Changes to protected paths without the right owner's approval |
Token permissions (contents: read) | Workflows doing more than they need to |
| Environments | Deployments and secrets used without a required reviewer |
Demo repo: gauravkhuraana/gh600 - clone it and follow along.
Logs and PR history record what an agent did - rulesets, CODEOWNERS, scoped tokens and environments control what it can do. You need both, and this is the heart of Domain 6 (guardrails and accountability).
This series is in progress - more episodes, including agent loops, are up next.
Subscribe on YouTube to get each episode as it drops.
A question to sit with while you wait: what task would you hand to an AI agent, and what would you personally review before approving it? That second half is the one people skip.
🧭 How to Prepare
- Get the distinction straight - chatbot vs agent, as covered in episode 1 above. Most exam scenarios hinge on it.
- Use agents for real work. Run GitHub Copilot's agent mode on an actual repository, not a toy project. The exam is scenario-based and rewards people who've hit the real failure modes.
- Go deep on MCP. It's the highest-weighted domain. Connect a server, give an agent tools, then watch what happens when a tool call fails.
- Practise custom instructions and other agent customisation in a repository you control.
- Think about governance, not just capability - permissions, audit trails, review gates, and what an agent should not be allowed to do.
- Read the official study guide on Microsoft Learn and map each bullet to something you've actually done.
🔗 Related Reading
- GitHub Copilot & GH-300 Certification - the foundation series
- Agentic AI - autonomous agents and what they mean for testing
- AI Roadmap for SDETs - where agents fit into a tester's skill path
- Prompt Library - ready-to-use prompts for testing and automation work
🤝 Connect & Learn More
- 📺 YouTube: Subscribe for the full GH-600 series
- 💼 LinkedIn: Follow for AI testing insights
- 📝 Medium: Read in-depth articles
- 💬 Topmate: 1:1 mentoring sessions
- 🐙 GitHub: Explore automation projects
GH-600 is where AI stops being an autocomplete and starts being a teammate you're accountable for. This series works through what that actually takes.