Merge pull request #49610 from a-a-ron/NEW-github-copilot-agent-mode3

New Module: GitHub Copilot Agent Mode

Author: PMEds28

learn-pr/github/github-copilot-agent-mode/1-introduction.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.introduction
+title: Introduction
+metadata:
+  title: Introduction
+  description: GitHub Copilot Agent Mode is an AI-powered coding assistant that autonomously manages complex, multi-step tasks within your codebase.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 1
+content: |
+  [!include[](includes/1-introduction.md)]

learn-pr/github/github-copilot-agent-mode/2-what-is-agent-mode.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.what-is-agent-mode
+title: What is GitHub Copilot Agent Mode?
+metadata:
+  title: What is GitHub Copilot Agent Mode?
+  description: GitHub Copilot Agent Mode is an advanced, autonomous AI coding assistant that dynamically analyzes entire projects, autonomously manages complex multi-step tasks, iteratively improves its output, and serves as a proactive collaborator in software development.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 3
+content: |
+  [!include[](includes/2-what-is-agent-mode.md)]

learn-pr/github/github-copilot-agent-mode/3-explore-the-power.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.explore-the-power
+title: Explore the power of autonomous development assistance
+metadata:
+  title: Explore the power of autonomous development assistance
+  description: GitHub Copilot Agent Mode is an autonomous AI coding assistant that dynamically analyzes entire projects, manages complex coding tasks, iteratively improves solutions, and collaboratively streamlines software development workflows.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 5
+content: |
+  [!include[](includes/3-explore-the-power.md)]

learn-pr/github/github-copilot-agent-mode/4-exercise.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.exercise
+title: GitHub skills exercise
+metadata:
+  title: GitHub skills exercise
+  description: Apply your knowledge with a hands-on GitHub Skills exercise.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 3
+content: |
+  [!include[](includes/4-exercise.md)]

learn-pr/github/github-copilot-agent-mode/5-knowledge-check.yml

@@ -0,0 +1,91 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.knowledge-check
+title: Knowledge check
+metadata:
+  title: Knowledge check
+  description: Evaluate your understanding of GitHub Copilot Agent Mode.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 5
+content: |
+quiz:
+  title: Check your knowledge
+  questions:
+    - content: "In what key way does GitHub Copilot Agent Mode differ from traditional AI-assisted coding tools?"
+      choices:
+        - content: "It exclusively relies on user-provided step-by-step instructions to generate code."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously analyzes and executes complex tasks without needing explicit step-by-step instructions."
+        - content: "It dynamically analyzes entire projects, autonomously performs multi-step tasks, and iteratively refines its outputs."
+          isCorrect: true
+          explanation: "Correct. GitHub Copilot Agent Mode goes beyond traditional assistants by autonomously managing comprehensive tasks and continuously improving its own solutions."
+        - content: "It primarily suggests code snippets based on the immediate context of a single open file."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode analyzes the broader context of the entire workspace, not just single-file context."
+        - content: "It provides real-time inline suggestions but cannot autonomously refactor or execute code."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode can autonomously refactor and execute code across multiple files."
+
+    - content: "Which approach describes how GitHub Copilot Agent Mode iteratively improves its generated solutions?"
+      choices:
+        - content: "It suggests initial solutions, then requires manual developer intervention to run tests and debug."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously runs tests, identifies issues, and iterates without requiring manual debugging."
+        - content: "It automatically identifies issues through testing, autonomously corrects errors, and repeats the cycle to refine the solution."
+          isCorrect: true
+          explanation: "Correct. Agent Mode employs an iterative, autonomous process to diagnose and correct errors, continuously improving its solutions."
+        - content: "It only generates code once per task and relies on manual review to make improvements."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously iterates multiple times to refine and improve the code solutions."
+        - content: "It delegates all code improvements entirely to external testing frameworks and does not autonomously address failures."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode internally diagnoses test failures and autonomously corrects issues without relying solely on external frameworks."
+
+    - content: "You instruct GitHub Copilot Agent Mode to migrate a legacy JavaScript application to a modern framework. What actions would Agent Mode likely perform autonomously?"
+      choices:
+        - content: "Provide inline code completions only for individual files without modifying dependencies or project structure."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode would autonomously modify dependencies, project structure, and files as needed for migration."
+        - content: "Identify relevant files, update dependencies, refactor existing code across multiple files, and iteratively verify changes by running tests."
+          isCorrect: true
+          explanation: "Correct. Agent Mode autonomously handles comprehensive migration tasks, including dependencies, refactoring, and testing."
+        - content: "Generate new documentation explaining why the migration should occur, but leave the actual code implementation to the developer."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode actively performs code refactoring and migration tasks rather than focusing solely on documentation."
+        - content: "Prompt the developer for manual inputs at each step of code modification without autonomously running any tests."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously manages tasks without requiring frequent manual inputs, including running tests to validate code."
+
+    - content: "What is the role of project documentation files (such as README.md) when working with GitHub Copilot Agent Mode?"
+      choices:
+        - content: "They serve exclusively as reference documents for developers and have no influence on Agent Mode's behavior."
+          isCorrect: false
+          explanation: "Incorrect. Documentation files can guide Agent Mode’s behavior by providing context and instructions for tasks."
+        - content: "They help Agent Mode understand the project's intended behavior, influencing how it autonomously executes tasks."
+          isCorrect: true
+          explanation: "Correct. Documentation files provide context and guidance that Agent Mode can leverage to perform tasks more accurately."
+        - content: "They restrict Agent Mode's access to code files, preventing unwanted modifications."
+          isCorrect: false
+          explanation: "Incorrect. Documentation does not restrict file access, but it can help direct Agent Mode’s autonomous operations."
+        - content: "Agent Mode completely ignores documentation files and relies solely on the file structure and source code."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode leverages documentation files to better understand tasks and execute actions appropriately."
+
+    - content: "What is an important limitation developers should consider when using GitHub Copilot Agent Mode?"
+      choices:
+        - content: "It requires manual configuration after every code generation to be effective."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously handles configurations based on existing project context."
+        - content: "It may struggle with highly specialized domain knowledge or nuanced business logic that lacks clear patterns."
+          isCorrect: true
+          explanation: "Correct. Agent Mode performs best with clear patterns and complete context and may struggle when domain-specific logic is unclear or undocumented."
+        - content: "It only supports generating code snippets and cannot autonomously refactor or run tests."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode fully supports autonomous refactoring, test creation, and execution."
+        - content: "It cannot analyze project structure and dependencies, relying solely on explicit developer-provided context."
+          isCorrect: false
+          explanation: "Incorrect. Agent Mode autonomously analyzes project structure and dependencies to perform tasks effectively."

learn-pr/github/github-copilot-agent-mode/6-summary.yml

@@ -0,0 +1,15 @@
+### YamlMime:ModuleUnit
+uid: learn.github.github-copilot-agent-mode.summary
+title: Summary
+metadata:
+  title: Summary
+  description: Summary of the module.
+  author: a-a-ron
+  ms.author: aastewar
+  ms.date: 03/17/2025
+  ms.topic: unit
+  ms.collection:
+    - ce-skilling-ai-copilot
+durationInMinutes: 3
+content: |
+  [!include[](includes/6-summary.md)]

learn-pr/github/github-copilot-agent-mode/includes/1-introduction.md

@@ -0,0 +1,18 @@
+In this module, you learn how to build an application using GitHub Copilot Agent Mode within a GitHub Codespace and the VS Code IDE. You explore how to effectively prompt Agent Mode to autonomously create new applications, use documentation files to clearly guide its behavior, and harness its powerful iteration capabilities. Specifically, you see firsthand how Copilot Agent Mode intelligently interacts with your code base to detect and fix errors, refactor existing code for better maintainability, and autonomously develop new features that allow you to focus more on innovation and less on repetitive coding tasks.
+
+## Learning objectives  
+
+By the end of this module, you are able to:  
+
+- Understand how to develop with VS Code IDE in a GitHub Codespace
+- Prompt GitHub Copilot agent mode to create an application
+- Use documentation files to instruct GitHub Copilot agent mode
+- Understand how GitHub Copilot agent mode iterates over a code base to:
+  - Fix errors
+  - Refactor code
+  - Develop new features
+  
+## Prerequisites  
+
+- A GitHub account and a fundamental understanding of GitHub Copilot  
+- Include any concepts or skills that will help learners succeed  

learn-pr/github/github-copilot-agent-mode/includes/2-what-is-agent-mode.md

@@ -0,0 +1,36 @@
+:::image type="content" source="../media/agent-mode.png" alt-text="Screenshot of the GitHub Copilot icon with the words agent mode at the top." border="false":::
+
+GitHub Copilot Agent Mode represents a major advancement in AI-assisted software development. Unlike traditional coding assistants that provide simple autocomplete-style suggestions, Agent Mode functions as an autonomous peer programmer that helps developers accomplish more with less effort. It doesn’t just suggest code, it understands your entire workspace, processes tasks dynamically, and iterates on its own output to improve solutions.
+
+With Agent Mode, GitHub Copilot can create applications from scratch, refactor code across multiple files, write and run tests, and migrate legacy code to modern frameworks. It can also generate documentation, integrate new libraries, and answer complex questions about a codebase. This allows you to focus on higher-level problem-solving while Copilot handles many of the repetitive or time-consuming aspects of software development.
+
+## How GitHub Copilot agent mode works
+
+One of the most powerful aspects of Agent Mode is its ability to analyze an entire codebase and determine relevant files and dependencies before making changes. Instead of relying solely on the immediate context of a single file, Agent Mode evaluates the broader structure of a project, ensuring that modifications are consistent and align with best practices. This deeper level of understanding makes Copilot capable of assisting with tasks that require a project-wide perspective, such as refactoring across multiple files or updating an entire application to use a new framework.
+
+Unlike traditional AI-powered code completion, which provides static suggestions, Agent Mode works dynamically by processing requests in iterative cycles. When given a task, it:
+
+- Determines the relevant files and dependencies before making edits.
+- Suggests and executes code changes while ensuring they align with the project structure.
+- Runs terminal commands as needed, such as compiling code, installing dependencies, and running tests.
+- Monitors and refines its output, iterating multiple times to remediate issues and improve accuracy.
+
+This iterative process enables Copilot to function as a truly collaborative AI, continuously improving its own suggestions while keeping the developer in full control.
+
+## Interact with GitHub Copilot
+
+GitHub Copilot offers multiple ways to assist you in your development workflow, each designed to support different levels of engagement and automation.
+
+- **Inline Suggestions** function similarly to traditional autocomplete tools but with more advanced capabilities, offering real-time code completions as you type.
+
+- **Copilot Chat** provides a dedicated chat panel where you can ask coding-related questions, and unlike generic AI chat assistants, it tailors responses based on the context of your project files and dependencies.
+
+- If you need broader, more structured modifications, **Copilot Edits** allows you to apply changes across multiple files to align with specific goals, making it easier to implement large-scale updates efficiently.
+
+- Lastly, **Agent Mode** takes automation to the next level by orchestrating development tasks dynamically—it not only refines its own outputs but also iterates multiple times to improve accuracy, making it a powerful AI collaborator that can handle complex workflows. Understanding how to leverage these different modes effectively can help you integrate Copilot seamlessly into your development process.
+
+## Benefits of Agent Mode
+
+By integrating GitHub Copilot Agent Mode into development workflows, developers can significantly increase productivity while maintaining full control over their projects. Since Copilot handles many of the tedious aspects of coding—such as repetitive edits, dependency management, and testing—it reduces cognitive load and allows developers to focus on higher-level design and problem-solving. Additionally, because Agent Mode iterates on its own outputs, it helps ensure code quality by catching errors and refining solutions before they require manual review.
+
+Ultimately, GitHub Copilot Agent Mode acts as more than just an AI assistant—it serves as an intelligent, proactive collaborator that adapts to a developer’s workflow and enhances their ability to build, maintain, and optimize software efficiently.

learn-pr/github/github-copilot-agent-mode/includes/3-explore-the-power.md

@@ -0,0 +1,101 @@
+GitHub Copilot Agent Mode significantly enhances traditional AI-assisted coding by autonomously handling complex, multi-step tasks and continuously iterating on its solutions. Understanding this capability allows developers to streamline workflows, optimize productivity, and effectively balance automation with human oversight.
+
+## Autonomous operation
+
+Copilot Agent Mode independently analyzes coding requests, dynamically identifies relevant files, determines appropriate terminal commands, and implements comprehensive solutions without explicit step-by-step instructions.
+
+### Example
+
+**Task:** Create a new REST API endpoint.
+
+**Agent Mode autonomously:**
+
+- Creates API routes (`routes/api.js`)
+- Updates main application (`app.js`)
+- Installs necessary dependencies (`npm install express`)
+- Generates test cases (`tests/api.test.js`)
+
+Although highly autonomous, Agent Mode provides developers with complete transparency and control over each proposed change.
+
+## Handling complex, multi-step tasks
+
+Going beyond simple code suggestions, Agent Mode excels in breaking down complex tasks into structured, sequential actions. This capability significantly reduces manual workload and speeds up complex project operations.
+
+### Example
+
+**Task:** Integrate a new database into an existing application.
+
+**Agent Mode performs the following autonomously:**
+
+1. Updates dependencies (`npm install mongoose`)
+2. Generates database connection logic (`database.js`)
+3. Modifies environment configuration (`.env`)
+4. Creates relevant data model definitions (`models/userModel.js`)
+5. Writes associated automated tests (`tests/userModel.test.js`)
+
+This systematic approach streamlines intricate development tasks.
+
+## Using intelligent tools and context awareness
+
+To effectively complete tasks, Agent Mode uses context from your project's files, dependencies, and prior actions. By analyzing existing project structure and context, it offers accurate and contextually relevant outputs.
+
+### Example
+
+**Scenario:** Deploying a React application.
+
+**Agent Mode intelligently:**
+
+- Recognizes project type via `package.json`
+- Runs suitable build scripts (`npm run build`)
+- Prepares deployment scripts aligned with existing workflow contexts
+
+Providing clear and complete context ensures better, more precise results.
+
+## Iterative improvement and self-healing
+
+One of Copilot Agent Mode's core strengths is its iterative problem-solving capability. If an error occurs, Agent Mode autonomously detects, corrects, and revalidates its solutions, significantly minimizing manual debugging effort.
+
+### Example
+
+**Issue:** Generated unit tests initially fail due to a syntax error.
+
+**Agent Mode autonomously:**
+
+- Detects the cause of failure
+- Applies a corrective solution
+- Re-runs the tests until they pass successfully
+
+This iterative process enhances code reliability and accelerates issue resolution.
+
+## Ensuring user control and oversight
+
+Despite its autonomy, Agent Mode keeps developers fully in control. Every action proposed by Agent Mode can be reviewed, adjusted, or reverted at any time, ensuring alignment with project standards.
+
+### Example
+
+**Situation:** Agent Mode proposes extensive changes to authentication logic.
+
+**Developer can:**
+
+- Review summarized changes in a pull request
+- Request specific modifications or revisions
+- Easily undo or adjust changes as required
+
+This ensures a productive balance between AI-driven efficiency and human judgment.
+
+## Limitations and practical considerations
+
+While powerful, Agent Mode does have limitations. It may struggle with specialized domain logic, nuanced business rules, or when critical project context is missing.
+
+### Example
+
+**Limitation:** Poorly documented custom business logic.
+
+**Possible outcomes:**
+
+- Less accurate or incomplete solutions
+- Increased need for manual review and intervention
+
+Understanding these limitations helps developers set realistic expectations and provide clearer context to maximize results.
+
+GitHub Copilot Agent Mode represents a significant advancement in AI-assisted software development, combining autonomous operations with intelligent iteration and robust oversight capabilities. By understanding its capabilities, proactively managing limitations, and effectively using its built-in tools, developers can significantly enhance productivity, maintain high-quality code standards, and accelerate their overall development workflow.