GitHub Copilot Agentic Coding in Practice: Custom Skills, Agent Collaboration, and MCP Integration

From Autocomplete to Autonomous Programming: Copilot's Paradigm Shift

GitHub Copilot is no longer just a "code completion tool." With the introduction of Agent Skills, Subagents, and the Model Context Protocol (MCP), it's evolving toward true Agentic Coding. Recently, instructor Mehmet Özkaya released a hands-on course that systematically covers this new paradigm—how to use GitHub Copilot CLI with custom instructions, task-specific skills, and custom AI agents to achieve an autonomous development loop from planning to coding to testing.

This article, based on the core content of that course, breaks down the key concepts of Agentic Coding, the toolchain composition, and how it's implemented in a real project (a distributed eShop e-commerce application).

What Is Agentic Coding?

Traditional AI-assisted programming is essentially "human writes a line, AI completes a block"—the developer always remains in control. The core difference with Agentic Coding is that developers shift from being "code writers" to "AI architects," defining rules, context, and agent roles to let AI agents autonomously complete entire development task chains.

The concept of Agentic Coding originates from "Agent" theory in artificial intelligence. In AI research, an agent is defined as an autonomous entity capable of perceiving its environment, making decisions, and executing actions. Unlike traditional large language model (LLM) single-turn Q&A, agents possess capabilities including goal decomposition, multi-step reasoning, tool invocation, and self-correction. Since 2024, as companies like OpenAI and Anthropic have made breakthroughs in Function Calling and Tool Use capabilities, the agent paradigm has rapidly moved from academic concept to engineering practice. GitHub Copilot's agentic evolution is a product of this trend—it's no longer limited to probabilistic completion based on code context, but completes complex end-to-end development workflows through goal planning, task decomposition, and tool orchestration.

The course emphasizes an aggressive goal—building a production-ready distributed e-commerce system with "zero manual coding." This means the human role is redefined: no more typing code, but rather designing management strategies, planning context, writing skill files, and crafting agent personas.

Four Course Modules and Complete Toolchain Analysis

The course is divided into four parts, progressively building a complete agentic coding capability framework.

Part 1: Agent Collaboration Fundamentals and Context Management

The first part focuses on collaboration and communication mechanisms between code agents in the eShop application scenario. Core topics include how agents manage context and memory, how responsibilities are distributed within task flows, and best practices for orchestration, iteration, and budget control.

Context management is the most easily overlooked yet most critical aspect of agentic coding. When AI needs to autonomously complete multi-step tasks, how precisely the context window is maintained—avoiding information loss or redundancy—directly determines output quality and token cost. The Context Window is the maximum text length a large language model can process simultaneously, measured in tokens—one token roughly corresponds to 4 English characters or 1-2 Chinese characters. Current mainstream models have context windows ranging from 128K to 200K tokens, but in agentic coding scenarios, multi-turn conversations, code file contents, and tool call results quickly consume context space. More critically, token usage directly correlates with API call costs—GPT-4 level model token pricing means unmanaged agent workflows can generate substantial expenses. Therefore, context management is not only a technical issue but also a cost control issue, which is why the course treats it as a throughline.

Part 2: .NET Aspire Orchestration and Copilot CLI Environment Setup

The second part introduces .NET Aspire as the orchestration foundation for distributed applications. Aspire is a cloud-native application orchestration framework released by Microsoft in late 2023, designed to simplify building, configuring, and deploying distributed applications. In traditional microservice architecture development, developers must manually handle service discovery, configuration management, health checks, telemetry collection, and other infrastructure code. Aspire unifies these cross-cutting concerns through a declarative AppHost model—developers only need to define dependency relationships between services at the orchestration layer, and the framework automatically injects connection strings, configures environment variables, and provides a unified development dashboard. In this course's eShop scenario, Aspire serves as the microservice skeleton, giving AI agents clear architectural constraints and a service registration mechanism to follow when generating individual service modules, avoiding the configuration chaos common in distributed system development.

The course then moves into GitHub Copilot CLI installation and configuration, including authentication and token integration. GitHub Copilot CLI is the command-line version of Copilot, architecturally distinct from IDE plugins in VS Code or JetBrains. IDE plugins run within the editor process, primarily obtaining context like cursor position and open file contents through editor APIs, with interaction modes centered on inline completion and chat panels. The CLI version runs in a terminal environment and can directly invoke shell commands, read/write the file system, and execute build and test scripts, making it naturally suited to host agent workflows requiring file system operations and command execution. More importantly, CLI can be integrated into CI/CD pipelines, automation scripts, and scheduled tasks for unattended code generation and maintenance operations—something IDE plugins struggle to achieve. Therefore, the CLI version is better suited for hosting "autonomously running" agent workflows.

Part 3: Full-Stack Autonomous Development and Three Operating Modes

The third part is the most essential hands-on section—building a full-stack eShop distributed application with agentic coding. It introduces multiple operating mode switches for Copilot CLI, which are key to the agentic coding experience:

• Interactive Mode: Conversational human-AI collaboration, suitable for exploratory development
• Plan Mode: AI plans before executing, ensuring controllability for complex tasks
• Full-Speed Autopilot Mode: AI runs completely autonomously, maximizing the degree of automation

In this section, AI agents autonomously generate eShop business logic, Minimal API endpoints, and HTTP testing systems. Minimal API is a lightweight HTTP API building approach introduced in .NET 6 that discards the heavyweight abstractions of traditional ASP.NET MVC like controllers and model binders, allowing developers to define routes and handler functions directly with minimal code. A typical Minimal API endpoint requires just one line: app.MapGet("/products", () => db.Products.ToListAsync()). This simplicity makes it particularly suitable for AI code generation—agents don't need to understand complex MVC conventions and file organization structures; they only need to generate functional route mappings to create fully functional API endpoints.

By flexibly switching between different modes, developers can find the balance between "control" and "efficiency"—use interactive mode during exploration, switch to plan mode to review proposals once goals are clear, and finally use autopilot mode for batch completion.

Part 4: Customization Hierarchy and MCP Protocol Integration

The fourth part represents the advanced essence of the entire methodology, centered on the Customization Hierarchy for agents.

Custom Instructions, Agent Skills, and Agent Personas

Customization is organized into a pyramid structure:

1. Custom Instructions: Define project-level coding standards and conventions
2. Agent Skills: Task-specific capability modules encapsulated as skills.md files
3. Custom Agent Personas: At the pyramid's apex, autonomous agents designed for specific responsibilities, such as "NetGuardian"—an agent role with specialized review duties mentioned in the course

Among these, skill files are the key practice for engineering-izing Prompt Engineering in agentic coding. Traditional prompts are typically one-off, temporary text existing within chat conversations, difficult to reuse and version-manage. Skill files persist these instructions as Markdown-formatted files stored in project repositories, subject to Git version control alongside code. A typical skill file includes: task description, input/output formats, constraints, code style requirements, error handling specifications, and more. For example, a file named api-generation.skills.md might define the authentication methods, error response formats, and pagination standards that must be followed when generating REST APIs. The essence of this approach is encoding team engineering knowledge and coding standards into instruction assets that AI can understand, making agent behavior consistent and predictable.

The significance of this layered design is that it upgrades AI behavioral constraints from "one-off prompts" to "reusable, composable engineering assets." Skill files and agent personas can be version-controlled, shared, and iterated like code modules, and new team members can quickly understand the project's AI collaboration norms by reading these files.

MCP (Model Context Protocol): The Key to Connecting the External World

MCP (Model Context Protocol) is another major focus of this course. MCP is a standardized protocol open-sourced by Anthropic in late 2024, designed to establish unified communication specifications between AI models and external data sources and tools. Its architecture adopts a client-server pattern: the AI application (such as Copilot) acts as an MCP client, communicating with MCP servers through standardized JSON-RPC message formats; MCP servers encapsulate access logic to external resources like databases, APIs, and file systems.

MCP defines three core primitives—Resources (providing read-only data), Tools (executing operations with side effects), and Prompts (predefined interaction patterns as prompt templates). Compared to traditional Function Calling, MCP's advantage lies in standardization and composability: an MCP server can be called by any AI client supporting the protocol, just as a REST API can be called by any HTTP client.

Through the Model Context Protocol, Copilot agents can connect to external APIs, databases, and GitHub servers, breaking through the limitation where standard Copilot can only perceive the current codebase. MCP's value lies in providing agents with "interfaces for perception and action." When AI can not only read and write code but also query databases, call external services, and read information from GitHub, it truly possesses the complete context needed to accomplish end-to-end development tasks—this is the technical prerequisite that makes "zero manual coding" feasible.

Key Insight: The Reshaping of the Developer Role

From this course's design, a clear trend emerges: Future senior developers will find their core competitive advantage shifting from "the ability to write code" to "the ability to manage AI agents."

The course repeatedly emphasizes the positioning of "dedicated AI architect"—the developer's primary work becomes planning context, designing skill files, orchestrating agent collaboration, and controlling token budgets. This skill stack overlaps with traditional programming abilities but doesn't completely coincide—it's closer to system design and engineering management.

Of course, the goal of "zero manual coding" must be viewed rationally. In real complex projects, the ideal state of complete non-intervention in code still faces numerous challenges: agents still require human review when handling edge cases, performance optimization, and architectural decisions. However, the methodology demonstrated in the course—layered customization, mode switching, MCP integration, strict context management—indeed represents a relatively mature engineering practice direction in the current agentic coding field.

For developers who want to master the next-generation AI programming paradigm, understanding this complete toolchain from "skills, agents, to MCP" holds more long-term value than simply pursuing "getting AI to write code."

Key Takeaways