Ultimate GitHub Copilot CLI tutorial for beginners

Key Concepts

• GitHub Copilot CLI: An AI-powered command-line interface agent capable of autonomous tasks, code generation, and self-healing.
• MCP (Model Context Protocol): An open standard allowing AI agents to connect to external data sources, tools, and documentation.
• Interactive vs. Non-interactive Mode: Chat-based back-and-forth sessions versus one-shot command-line prompts.
• Slash Commands: Control surface commands (e.g., /plan, /delegate, /re) used to steer the agent.
• Instructions, Skills, and Agents: A framework for defining project-specific patterns, reusable task logic, and specialized AI personas.

---

1. Getting Started and Installation

• Installation: The primary method is via npm install -g @github/copilot. It is also compatible with package managers like winget or homebrew.
• Authentication: Launching copilot requires GitHub credentials to link the client to your Copilot account and the GitHub MCP server.
• Permissions: Users must grant the CLI access to specific folders to allow file exploration and modification. This can be scoped to a single session or saved for future use.

2. Operational Modes

• Interactive Mode: Triggered by typing copilot. It supports multi-turn conversations, allowing users to ask questions, request code, or ask the agent to run local servers.
• Non-interactive (Inline) Mode: Triggered via copilot -p "prompt". This is designed for quick, one-off tasks without leaving the shell context.
• Session Management: Users can resume previous sessions using copilot -resume or the /resume slash command.

3. Slash Commands: The Control Surface

Slash commands provide granular control over the agent's behavior:

• /model: Switches the underlying AI model (e.g., lightweight for refactoring vs. deep reasoning for planning). Includes cost multipliers.
• /context & /compact: Monitors token usage and summarizes conversations to free up context space.
• /diff: Displays pending changes made by the agent.
• /CWD: Changes the working directory to a different repository or scopes the agent to a specific sub-folder.
• /resetallowedtools: Revokes previously granted permissions for file edits.

4. Advanced Workflow: Planning, Delegation, and Review

The video outlines a three-step autonomous loop:

1. Planning (/plan): The agent analyzes the project and creates a step-by-step implementation plan, asking clarifying questions about requirements (e.g., storage methods, UI icons).
2. Delegation (/delegate): Pushes the task to a cloud-based "GitHub Coding Agent." This agent creates a draft Pull Request (PR) in the background, allowing the user to start new tasks while the agent works.
3. Review (/re): Uses a specialized code-review sub-agent to analyze the PR for bugs or vulnerabilities. It can apply fixes directly based on the review findings.

5. Model Context Protocol (MCP)

MCP allows the agent to interact with external resources beyond the local codebase.

• Implementation: Added via /mcp. Servers can be local (e.g., npx commands) or remote (HTTP URLs).
• Examples:
  • Playwright: Allows the agent to perform end-to-end testing and validate UI functionality.
  • Svelte: Exposes documentation and best-practice linting to identify and fix code issues automatically.

6. Customizing Behavior: Instructions, Skills, and Agents

To ensure the AI follows organizational standards, developers can use:

• Instructions Files: Markdown files (copilot-instructions.md) that provide global or file-type-specific context (e.g., "always include docstrings").
• Skills: Defined in .github/skills, these are reusable scripts or logic for specific tasks like creating PRs or following contribution guidelines.
• Custom Agents: Specialized personas (e.g., an "Accessibility Agent") that handle complex, project-wide tasks. These are activated via /agent.

---

Synthesis

GitHub Copilot CLI transforms the terminal from a passive command executor into an active, autonomous development environment. By combining Slash Commands for steering, MCP for external data integration, and Instructions/Skills for organizational compliance, developers can create a highly customized, automated workflow. The ability to delegate complex tasks to cloud-based agents while maintaining local control allows for a more efficient, iterative development cycle.