Zum Inhalt springen
L-SYSTEM

empfohlenFortgeschritten

GitHub Copilot for Senior Developers: Visual Studio 2026, VS Code & CLI

A course for senior developers at Big 4 and other professional-services firms who already use GitHub Copilot — or are about to be told to — and want to use it as an engineer rather than as a faster autocomplete. Copilot in 2026 is an agent platform: agent mode and a Plan agent in Visual Studio 2026 and VS Code, specialised agents for debugging, profiling, testing and .NET modernisation, custom agents and skills your team keeps in the repository, MCP servers, cloud agents that return pull requests, and Copilot CLI in the terminal. The course teaches the skills that separate a senior from a passenger: engineering the context, splitting a task into a plan the agent can execute, reviewing an AI diff as critically as a colleague's, encoding team rules once so they work in every IDE, and knowing exactly what leaves the client's perimeter — and what it costs in AI Credits. Every capability is taught the same way: the pain that makes you reach for it, the capability itself, and its cost — including the uncomfortable ones, such as content exclusion not applying in agent mode, or a green test suite that an agent wrote to match its own bug. The mandatory track follows the official GH-300 (GitHub Copilot) exam outline, so the course doubles as certification preparation; optional units go deeper into Copilot CLI automation, hooks, model and cost engineering, and measuring real productivity. Labs use one sample repository — Aldervane Advisory LLP's ENGAGE platform — that opens in Visual Studio 2026, VS Code and the CLI alike; it is a public GitHub template (github.com/AndreyKuralekh/engage), so each learner starts from their own copy. Every lab also has a read-and-answer path for learners without a Copilot Business or Enterprise seat.

Ihre Lektion ist in Ihrer Sprache: Ihr Assistent leitet sie.

  • Material: Englisch
  • Prüfung: Englisch – wird auf der Website abgelegt, nicht übersetzt
So funktioniert’s

Ihr Assistent holt das Kursmaterial von unserem Server und leitet die Lektion in Ihrer Sprache.

Die Prüfung wird auf der Website abgelegt, ohne Assistenten. Prüfungsfragen werden nicht übersetzt: Das ist für jeden Kurs so festgelegt.

So verbinden Sie einen Assistenten

Weg durch den Kurs

· 25 Einheiten

freie Reihenfolge · die Stufen unten sind die vom Autor vorgeschlagene Reihenfolge, keine BedingungAnsicht: Karte · Stufen

  1. Stufe 1

    ~1 Std.

  2. Stufe 2

    ~3 Std.

    A · Foundations · laut Plan des Autors nach „Course map: plans, AI Credits, setting up Visual Studio 2026 and VS Code, the ENGAGE repository“

  3. Stufe 3

    ~3,5 Std.

  4. Stufe 4

    ~6 Std.

  5. Stufe 5

    ~6,5 Std.

  6. Stufe 6

    ~6 Std.

  7. Stufe 7

    ~6 Std.

  8. Stufe 8

    ~1,5 Std.

  9. Stufe 9

    ~1 Std.

  10. Prüfung

    gesperrt · in den Kurs einschreiben

    • Abschluss · im Browser, ohne den Assistenten

      Prüfung

Der Weg in Worten
  • Stufe 1 · Course map: plans, AI Credits, setting up Visual Studio 2026 and VS Code, the ENGAGE repository — ~1 Std.
  • Stufe 2 · How Copilot works: prompt building, context, proxy filtering, post-processing, suggestion lifecycle — laut Plan des Autors nach „Course map: plans, AI Credits, setting up Visual Studio 2026 and VS Code, the ENGAGE repository“; ~1,5 Std.
  • Stufe 2 · Responsible use: risks, hallucinated APIs, insecure patterns, output ownership, verification discipline — laut Plan des Autors nach „Course map: plans, AI Credits, setting up Visual Studio 2026 and VS Code, the ENGAGE repository“; ~1,5 Std.
  • Stufe 3 · Context engineering and prompting: #-references, participants, zero/few-shot, chat history, fresh sessions — laut Plan des Autors nach „How Copilot works: prompt building, context, proxy filtering, post-processing, suggestion lifecycle“; ~1,5 Std.
  • Stufe 3 · Governance: organisation policies, content exclusion and its gaps, public code filter, audit log, REST API for seats, AI Credit budgets — laut Plan des Autors nach „Responsible use: risks, hallucinated APIs, insecure patterns, output ownership, verification discipline“; ~2 Std.
  • Stufe 4 · Visual Studio 2026 basics: inline suggestions, Next Edit Suggestions, Chat, Copilot Actions, commit messages — laut Plan des Autors nach „Context engineering and prompting: #-references, participants, zero/few-shot, chat history, fresh sessions“; ~1 Std.
  • Stufe 4 · VS Code: Chat, Plan, agent sessions, the Agents window, model choice and its price — laut Plan des Autors nach „Context engineering and prompting: #-references, participants, zero/few-shot, chat history, fresh sessions“; ~1,5 Std.
  • Stufe 4 · Aldervane case: the February confidentiality incident — root causes across the whole course — laut Plan des Autors nach „Governance: organisation policies, content exclusion and its gaps, public code filter, audit log, REST API for seats, AI Credit budgets“; ~1,5 Std.
  • Stufe 4 · Copilot CLI essentials: install, interactive sessions, plan and autopilot, permissions, key commands, scripts and files — laut Plan des Autors nach „Context engineering and prompting: #-references, participants, zero/few-shot, chat history, fresh sessions“; ~1 Std.
  • Stufe 4 · Measuring impact and rolling Copilot out to a team: metrics, adoption, avoiding vendor numbers — laut Plan des Autors nach „Governance: organisation policies, content exclusion and its gaps, public code filter, audit log, REST API for seats, AI Credit budgets“; optional; ~1 Std.
  • Stufe 5 · Agent mode in Visual Studio: tools, approvals, the build/test loop, Plan agent → Implement plan — laut Plan des Autors nach „Visual Studio 2026 basics: inline suggestions, Next Edit Suggestions, Chat, Copilot Actions, commit messages“; ~1,5 Std.
  • Stufe 5 · Team rules: copilot-instructions.md, *.instructions.md with applyTo, prompt files, organisation instructions — and what VS and the CLI see — laut Plan des Autors nach „VS Code: Chat, Plan, agent sessions, the Agents window, model choice and its price“; ~1,5 Std.
  • Stufe 5 · Exam rehearsal: GH-300 formats, traps by domain, time management — laut Plan des Autors nach „Aldervane case: the February confidentiality incident — root causes across the whole course“, „Copilot CLI essentials: install, interactive sessions, plan and autopilot, permissions, key commands, scripts and files“; ~1,5 Std.
  • Stufe 5 · Copilot CLI at work: sessions, delegation to the cloud agent, plugins and custom agents — laut Plan des Autors nach „Copilot CLI essentials: install, interactive sessions, plan and autopilot, permissions, key commands, scripts and files“; optional; ~1 Std.
  • Stufe 5 · Models, BYOK and cost engineering under AI Credits — laut Plan des Autors nach „VS Code: Chat, Plan, agent sessions, the Agents window, model choice and its price“; optional; ~1 Std.
  • Stufe 6 · Built-in agents in Visual Studio: @debugger, @profiler, @test, @git review — laut Plan des Autors nach „Agent mode in Visual Studio: tools, approvals, the build/test loop, Plan agent → Implement plan“; ~1,5 Std.
  • Stufe 6 · Custom agents and agent skills: team roles and procedures in the repository — laut Plan des Autors nach „Team rules: copilot-instructions.md, *.instructions.md with applyTo, prompt files, organisation instructions — and what VS and the CLI see“; ~2 Std.
  • Stufe 6 · Testing with Copilot: unit and integration tests, edge cases, assertions — and why an agent's green tests prove little — laut Plan des Autors nach einer beliebigen davon: „Agent mode in Visual Studio: tools, approvals, the build/test loop, Plan agent → Implement plan“, „VS Code: Chat, Plan, agent sessions, the Agents window, model choice and its price“; ~1,5 Std.
  • Stufe 6 · Copilot CLI in automation: non-interactive runs, preToolUse hooks, scripts and CI — laut Plan des Autors nach „Copilot CLI at work: sessions, delegation to the cloud agent, plugins and custom agents“; optional; ~1 Std.
  • Stufe 7 · Lab: modernising Engage.Legacy.Import with @modernize (.NET Framework 4.8 → .NET 10) — laut Plan des Autors nach „Built-in agents in Visual Studio: @debugger, @profiler, @test, @git review“; ~2 Std.
  • Stufe 7 · MCP: connecting servers, trust, allowlists and registry policy, data leakage and prompt injection through tools — laut Plan des Autors nach „Custom agents and agent skills: team roles and procedures in the repository“; ~1,5 Std.
  • Stufe 7 · Security and performance review: Review Selection, Copilot code review on pull requests, and judging AI findings — laut Plan des Autors nach „Testing with Copilot: unit and integration tests, edge cases, assertions — and why an agent's green tests prove little“; ~1,5 Std.
  • Stufe 7 · Hooks and guardrails in VS Code: agent hooks, scoped hooks in custom agents, failure semantics — laut Plan des Autors nach „Custom agents and agent skills: team roles and procedures in the repository“; optional; ~1 Std.
  • Stufe 8 · The cloud agent: from issue to pull request, reviewing an agent's PR, and when delegation pays off — laut Plan des Autors nach „Security and performance review: Review Selection, Copilot code review on pull requests, and judging AI findings“; ~1,5 Std.
  • Stufe 9 · Spaces, PR summaries and review standards in instruction files (and Spark, briefly) — laut Plan des Autors nach „The cloud agent: from issue to pull request, reviewing an agent's PR, and when delegation pays off“; ~1 Std.

Lehrplan · 25 Einheiten

1Course map: plans, AI Credits, setting up Visual Studio 2026 and VS Code, the ENGAGE repository

Tell which Copilot plan and which contract applies to a developer, and why client code needs an organisation seat

~1 Std.
2How Copilot works: prompt building, context, proxy filtering, post-processing, suggestion lifecycle

Trace a Copilot request through context gathering, prompt building, proxy, filters, model and post-processing

~1,5 Std.
3Responsible use: risks, hallucinated APIs, insecure patterns, output ownership, verification discipline

Name the six responsible-AI principles used in GH-300 and apply them to everyday Copilot work

~1,5 Std.
4Context engineering and prompting: #-references, participants, zero/few-shot, chat history, fresh sessions

Name the five layers of context in a chat prompt and say who controls each

~1,5 Std.
5Visual Studio 2026 basics: inline suggestions, Next Edit Suggestions, Chat, Copilot Actions, commit messages

Control completions and Next Edit Suggestions deliberately: partial acceptance, manual invocation, and the review point between the two NES Tabs

~1 Std.
6Agent mode in Visual Studio: tools, approvals, the build/test loop, Plan agent → Implement plan

Choose between Ask, the Plan agent and agent mode for a task, and explain how Copilot Edits and Agent (Preview) relate to them

~1,5 Std.
7Built-in agents in Visual Studio: @debugger, @profiler, @test, @git review

Pick the right built-in agent for a debugging, performance, testing or pre-commit review task

~1,5 Std.
8Lab: modernising Engage.Legacy.Import with @modernize (.NET Framework 4.8 → .NET 10)

Install and start the GitHub Copilot modernization agent in Visual Studio and scope it to one project

~2 Std.
9VS Code: Chat, Plan, agent sessions, the Agents window, model choice and its price

Distinguish the Session Target (harness), agent role, model, permission level and code isolation in the VS Code chat input and predict the effect of changing each

~1,5 Std.
10Team rules: copilot-instructions.md, *.instructions.md with applyTo, prompt files, organisation instructions — and what VS and the CLI see

Write and review a repository instructions file that is short, concrete, conflict-free and free of client data

~1,5 Std.
11Custom agents and agent skills: team roles and procedures in the repository

Choose between repository instructions, path-specific instructions, prompt files, custom agents and agent skills for a given need

~2 Std.
12MCP: connecting servers, trust, allowlists and registry policy, data leakage and prompt injection through tools

Configure an MCP server for VS Code, Visual Studio 2026 and Copilot CLI and review an MCP configuration file for secrets, unpinned versions and excessive scope

~1,5 Std.
13Testing with Copilot: unit and integration tests, edge cases, assertions — and why an agent's green tests prove little

Generate C# tests in Visual Studio 2026 with @Test and Copilot Actions > Generate Tests, and check framework, location and results

~1,5 Std.
14Security and performance review: Review Selection, Copilot code review on pull requests, and judging AI findings

Choose the right review surface: Review Selection, @git and Review changes with Copilot in Visual Studio, Generate Code > Review and Uncommitted Changes in VS Code, /review in the CLI, and Copilot code review on pull requests

~1,5 Std.
15The cloud agent: from issue to pull request, reviewing an agent's PR, and when delegation pays off

Explain how the cloud agent works and its limits: GitHub Actions environment, one repository, one branch, one pull request, 59 minutes

~1,5 Std.
16Spaces, PR summaries and review standards in instruction files (and Spark, briefly)

List the instruction sources Copilot code review uses and scope a file away from the reviewer or cloud agent with excludeAgent

~1 Std.
17Governance: organisation policies, content exclusion and its gaps, public code filter, audit log, REST API for seats, AI Credit budgets

Locate and set Copilot policies at organisation level and predict the effective value for a user with seats from several organisations

~2 Std.
18Aldervane case: the February confidentiality incident — root causes across the whole course

Reconstruct an AI-assisted data-exposure incident as a blameless timeline from local, repository and audit-log evidence

~1,5 Std.
19Copilot CLI essentials: install, interactive sessions, plan and autopilot, permissions, key commands, scripts and files

Install, authenticate and update Copilot CLI on Windows, macOS and Linux, and name the prerequisites and policy that gate it

~1 Std.
20Exam rehearsal: GH-300 formats, traps by domain, time management

State the published facts about GH-300 — duration, scaled passing score, scoring rules, domains and weights — and what is not published

~1,5 Std.
21Copilot CLI at work: sessions, delegation to the cloud agent, plugins and custom agents

Resume, name, compact, fork and roll back CLI sessions, and explain what resuming a stale session costs

~1 Std.
22Copilot CLI in automation: non-interactive runs, preToolUse hooks, scripts and CI

Run Copilot CLI non-interactively with the flags scripts need: -p, -s, --no-ask-user, --output-format, --model and --max-ai-credits

~1 Std.
23Hooks and guardrails in VS Code: agent hooks, scoped hooks in custom agents, failure semantics

Identify which hook implementation runs for a VS Code Session Target and why a shared .github/hooks file can behave differently per harness

~1 Std.
24Models, BYOK and cost engineering under AI Credits

Calculate the AI Credit cost of a turn from per-token model prices, including the effect of cached input

~1 Std.
25Measuring impact and rolling Copilot out to a team: metrics, adoption, avoiding vendor numbers

Name the metrics sources GitHub provides (usage, code generation and impact dashboards, usage metrics API, NDJSON, user management API) and what each is for

~1 Std.