Agentic Software Engineering using GitHub Copilot (DGHCI)

 

Course Overview

A four-day journey into agentic software engineering with GitHub Copilot, and how AI-powered tools reshape coding productivity and architectural decisions. Software engineers, architects, and technical leaders get the hands-on experience to leverage AI in modern software development.

Your journey begins with Fundamentals and Agent Mode Basics: prompting, inline suggestions, slash commands, context variables, and code review on pull requests. You configure models from hosted frontier to bring-your-own-key endpoints, and Copilot Vision brings images and PDFs into chat. Agent Mode arrives early, driving a local agent through multi-step work and the terminal.

You then assemble the GitHub Copilot Harness: instructions, prompt files, and the Model Context Protocol, with the MCP Registry as your discovery surface. It adds custom agents, skills, memory, and hooks, optimizes the context window with prompt caching, and installs Agent Plugins 1.0 packages that work across CLI and editor from one install.

In Implementing Agentic Coding you put agents to work: local agents in agent mode, large jobs delegated to cloud agents, and expert subagents coordinated by an orchestrator running independent work in parallel. Browser tools let agents open pages, read console errors, and verify their own web changes; an agent-led modernization from Semantic Kernel to the Microsoft Agent Framework closes the module.

Agent Sessions covers the infrastructure underneath those runs. You run agents across projects in a companion window, see how the Agent Host Protocol keeps session state authoritative on a long-lived host, and drive remote sessions over SSH and dev tunnels. Groups, background sends, and one-click banners fix failing CI checks at scale, and dedicated agents return cited research, recover stalled sessions, and give second opinions.

The GitHub Copilot CLI brings the agent to the command line: an interactive shell with slash commands and natural language, models switched on the fly, and multi-step work handed to Autopilot. An HR document-automation case over Work IQ and SharePoint MCP servers shows the payoff, and GitHub Agentic Workflows turn those jobs into versioned, scheduled runs that open pull requests.

The GitHub Copilot SDK embeds those capabilities into your own applications on the runtime that powers the CLI and the editor's agent host. In Technical Preview for Python, TypeScript, Go, and .NET, you create sessions and custom tools while Copilot plans and executes, build runnable agents, deploy one to Azure, and extend them with MCP Apps rendering interactive UIs in chat.

The GitHub Copilot app is the desktop agents view for macOS, Windows, and Linux. Sessions start from a GitHub issue, a freeform prompt, or an in-flight pull request, each in its own worktree, with a Plan tab and a side chat to steer a run without interrupting it. A validation loop reviews diffs, collects agent-attached screenshots, and merges the pull request, while skills and prompts become scheduled automations. Customize manages the plugins, personal skills, and MCP servers a session inherits, alongside the permission mode and the model it runs on.

Agentic DevOps applies these techniques to cloud automation and infrastructure as code: Azure CLI, Bicep, Terraform, and the Azure Developer CLI in agentic mode, plus CI/CD with GitHub Actions. The quality loop closes here too, with generated tests including end-to-end Playwright suites and Mermaid-diagrammed documentation.

Governance, Cost and Observability is written for architects, team leads, and managers: the permission model from Autopilot and assisted approvals to risk badges, sensitive-prompt interception, and opt-in sandboxing, model choice as a budget decision under usage-based credits, open-source models to cut that cost, enterprise managed settings via MDM, OpenTelemetry traces feeding an Azure Managed Grafana dashboard, and the compliance obligations attaching to the software your agents ship.

The course closes with Spec-Driven Development and Delivery: a constitution, specification, and technical plan, complex requirements decomposed into tasks with GitHub Spec Kit, and a product feature implemented end to end from its specification. You leave able to architect AI-assisted solutions that accelerate delivery and strengthen your team.

Who should attend

  • Software Engineers interested in leveraging AI agents to enhance their coding productivity and capabilities
  • Software Architects looking to understand how to integrate and manage AI agents within software development lifecycles
  • Team Leads and Managers aiming to explore how AI agents can be utilized to optimize team workflows and project outcomes

Prerequisites

  • Experience with software development at a professional level
  • A GitHub Copilot license with a credit allowance, or a configured bring-your-own-key (BYOK) endpoint. Usage-based billing makes this a required setup step, not an optional one.

Course Content

Module 1: GitHub Copilot Fundamentals & Agent Mode Basics
  • Getting Started with Copilot & Vision
  • Selecting & Configuring Models
  • Shaping the Context Window
  • AI-Assisted Coding Essentials
  • Agent Mode Basics
  • Pull Requests & Code Reviews
  • Configuring & Governing Copilot
  • Working in the Terminal
Module 2: GitHub Copilot Harness
  • Copilot Instructions
  • Prompt Files
  • Model Context Protocol & MCP Registry
    • MCP Basics & the MCP Registry
    • Implementing MCP Servers
  • Agent Skills
  • Custom Agents
    • Agents Overview
    • Repository Agents
  • Agent Plugins
  • Copilot Memory
  • GitHub Copilot Hooks
  • Agent Interop
Module 3: Implementing Agentic Coding
  • Using Local Agents and Agent Mode
  • Delegating Tasks to Cloud Agents
  • Multi-Agent Orchestration with Subagents
  • Agentic Browser Automation
  • Upgrading & Modernization
Module 4: Agent Sessions & Agents Window
  • The Agents Window
  • Agent Host Protocol (AHP vs ACP)
  • Remote Agent Sessions over SSH & Dev Tunnels
  • Session Management
  • Session Persistence & /chronicle
  • Deep Research with /research
  • Troubleshooting Agent Sessions
  • A Second Opinion with /rubber-duck
Module 5: GitHub Copilot CLI & SDK
  • Part 1: GitHub Copilot CLI
    • GitHub Copilot CLI
    • Business Case: HR Document Updates Automation
    • GitHub Agentic Workflows
    • Extending the CLI with MCP Servers & Skills
    • Codebase Q&A and Onboarding
  • Part 2: GitHub Copilot SDK
    • GitHub Copilot SDK
    • Copilot SDK Demos
    • Implementing & Using MCP Apps
    • Deploying an SDK Agent to Azure
    • Building a Multi-Agent System
Module 6: GitHub Copilot App
  • Meet the Desktop Agents App
  • Sessions from Issues, Prompts & Pull Requests
  • The Validation Loop
  • Scheduled Automations
  • Syncing Skills & MCP Servers
  • Configuring the App: Customize, Permissions & Models
Module 7: Agentic DevOps
  • IaC & Configuration (Azure CLI, SSH, Bicep & Terraform
  • CI/CD with GitHub Actions
  • Testing using Copilot
  • Documentation using Copilot
Module 8: Governance, Cost & Observability
  • Trust, Safety & the Permission Model
  • Cost Model & AI Credits
  • Enterprise Policy & Managed Settings
  • Observability with OpenTelemetry
  • Cutting Token Cost with Open-Source Models(
    • Using Open-Source Models in VS Code
    • Using Open-Source Models in the Copilot CLI
  • EU AI Act, GDPR & Accessibility Compliance
Module 9: Spec-Driven Development & Delivery
  • Why Spec-Driven Development
  • The Spec-Driven Workflow
  • Sample Case: Implement a Product Feature

Prices & Delivery methods

Online Training

Duration
1 day

Price
  • 690.— €
Classroom Training

Duration
1 day

Price
  • Sweden: 690.— €

Currently there are no training dates scheduled for this course.