Foundations of AI Coding Agents with GitHub Copilot CLI

Duration

2 Days

Skills Gained

By the end of this course, participants will be able to:

• Apply prompt engineering and context-management techniques to GitHub Copilot CLI

• Configure GitHub Copilot CLI for terminal and IDE workflows and per-project conventions

• Drive code generation, refactoring, testing, and debugging through GitHub Copilot CLI’s agentic operation

• Integrate Model Context Protocol servers to extend GitHub Copilot CLI’s reach

• Evaluate GitHub Copilot CLI’s output against project quality and security standards

Who Can Benefit

This course is designed for:

• Software Developers

• Data Scientists & Analysts

• Anyone interested in coding agents

Prerequisites

Participants should enter this course with:

• Familiarity using Generative AI

• Practical Python experience

Organizational Objectives

This course assists organizations to:

• Accelerate first-draft code production through agent-driven generation, refactoring, and test scaffolding

• Reduce review cycles by codifying tool conventions in AGENTS.md and shared configuration

• Keep AI tool use inside permission boundaries via MCP server allowlists and reviewed config hierarchies

• Build a team-wide working knowledge of GitHub Copilot CLI in two days

Software

All attendees must have a modern web browser and an Internet connection.

Module 1 - AI Coding Agent Foundations

By the end of this module, you will be able to describe how modern AI coding agents are architected, recognize the plan-execute-iterate loop in action, and apply the permission and review controls that keep autonomous file, terminal, and Git operations safe to delegate.

• AI coding agent architecture and components

• Context windows and token limits

• Agentic operation and the plan-execute-iterate cycle

• Autonomous file, terminal, and Git operations

• Reviewing and accepting proposed changes

• Tool permissions and safety controls

• Hands-on Lab: Walk a coding agent through a small refactor end-to-end, exercising the permission and review controls before any change is committed.

Module 2 - Context Engineering

By the end of this module, you will be able to apply zero-shot, few-shot, and chain-of-thought prompting to a coding agent, attach relevant code and docs through reference systems, and budget extended thinking and persistent memory so the agent stays focused on the task.

• Context management fundamentals

• Prompting techniques (zero-shot, few-shot, chain-of-thought)

• Reference systems for attaching files, codebase context, docs, and web content

• Extended thinking modes and budget allocation

• Memory and cross-session persistence

• Hands-on Lab: Refine a vague coding request into a focused prompt that pulls in the right reference context and budgets extended thinking appropriately.

Module 3 - Configuration Standards

By the end of this module, you will be able to author a project-level configuration file (AGENTS.md or a tool-specific equivalent), organize the configuration hierarchy under version control, and apply exclusion strategies to keep sensitive material out of agent context.

• Configuration file hierarchy and version control

• Universal context configuration (AGENTS.md) and cross-tool compatibility

• AGENTS.md format and conventions

• Tool-specific configuration files

• File exclusion strategies

• Hands-on Lab: Author a project-level AGENTS.md (or repository custom-instructions file) that captures the team’s conventions, exclusions, and review expectations.

Module 4 - Model Context Protocol (MCP)

By the end of this module, you will be able to describe the MCP host, client, and server roles, install and configure an MCP server, recognize the primitives the protocol exposes, and apply permission management appropriate to the tools the server grants access to.

• MCP architecture (hosts, clients, servers)

• MCP primitives (tools, resources, prompts)

• Configuration and server installation

• Security considerations and permission management

• Hands-on Lab: Install one MCP server, exercise its primitives from a coding agent, and audit the permission surface it introduces.

Module 5 - Practical Workflows

By the end of this module, you will be able to drive a coding agent across realistic tasks — generation, review, testing, debugging, refactoring, documentation, and Git operations — and recognize where agentic operation belongs inside an existing development workflow.

• Code generation and multi-file scaffolding

• Automated code review and security scanning

• Test generation and test-driven workflows

• Agent-driven debugging and error diagnosis

• Refactoring patterns (single-file and multi-file)

• Documentation generation and Git integration with automated commit messages

• Hands-on Lab: Run a single feature ticket through generation, review, test, and documentation steps, then have the agent prepare the commit.

Module 6 - GitHub Copilot CLI Features

By the end of this module, you will be able to operate GitHub Copilot CLI from a terminal as a first-class shell-composable agent, configure hooks and custom agents for repeatable team workflows, and integrate it into GitHub for issue and PR review.

• Terminal-first operation, shell integration, and Unix composability

• Configurable reasoning effort and built-in specialized agents (Explore, Task, Code Review, Plan)

• Hooks system (preToolUse, postToolUse) and custom agents (.agent.md files)

• Native GitHub integration: Copilot coding agent for issue and PR workflows and automated PR review

• Copilot CLI as an ACP (Agent Client Protocol) agent for third-party tools and IDEs

• AGENTS.md hierarchy and configuration precedence

• Hands-on Lab: Configure GitHub Copilot CLI with a project-level AGENTS.md, one hook, and one custom agent, then drive a small task through them.