Estimated reading time: 12 minutes

Introduction: The Terminal Just Got a Lot Smarter — Even for Low-Code Developers

On February 25, 2026, GitHub announced the general availability of GitHub Copilot CLI for all paid Copilot subscribers — marking the graduation of what started as a terminal assistant into a full-blown autonomous coding agent. It plans, builds, reviews code, and remembers context across sessions, all without you ever leaving your terminal window.

But here’s the question most Power Platform developers are probably asking: “I build Canvas Apps, Model-Driven Apps, and Copilot Studio solutions — why would a terminal tool matter to me?”

The answer is: more than you think.

Power Platform development has quietly grown a significant CLI surface area. The Power Platform CLI (PAC CLI) is the backbone of ALM pipelines, solution packaging, environment management, and PCF control deployment. If you use GitHub Actions for your Power Platform CI/CD pipelines, you’re already living in the terminal — you just haven’t had an AI agent helping you there yet. Beyond that, Microsoft has officially published a Power Platform Skills plugin for GitHub Copilot CLI (microsoft/power-platform-skills), with support for Power Pages today and Power Apps generative pages coming soon. This means the ecosystem is already converging.

Whether you’re a senior architect managing multi-environment Dataverse pipelines, a PCF developer scaffolding TypeScript controls, or a consultant automating solution deployments for enterprise clients — GitHub Copilot CLI GA is a milestone worth understanding deeply.

Before you read on — quick question: Where does most of your Power Platform work happen today?

• Mostly in the browser (Power Apps Studio, make.powerapps.com)
• Mixed — browser for low-code, terminal for ALM and CI/CD
• Heavily in the terminal — PAC CLI, GitHub Actions, PCF dev

Drop your answer in the comments. It’ll be interesting to see how the community splits — and it shapes what I cover next on AIDevMe.

What Is GitHub Copilot CLI?

GitHub Copilot CLI is a terminal-native AI coding agent that brings the full power of GitHub Copilot directly to your command line. It went into public preview in September 2025 and has received hundreds of updates since then. As of February 25, 2026, it is production-ready and available across all paid tiers: Copilot Pro ($10/mo), Pro+ ($39/mo), Business ($19/user/mo), and Enterprise ($39/user/mo).

Unlike the older gh copilot suggest command (which gave you a single command suggestion), the new Copilot CLI is an autonomous agent capable of:

• Planning multi-step tasks before execution.
• Editing files, running commands, and iterating on results.
• Delegating to specialized sub-agents in parallel.
• Remembering your codebase across sessions.
• Connecting to external services via MCP servers

It is not just a chatbot in a terminal. It is closer to having a senior developer pair-programming with you at the command line.

Key Features of GitHub Copilot CLI GA

Agentic Plan Mode and Autopilot Mode

Copilot CLI ships with two complementary execution modes that give you full control over how autonomous the agent operates.

Plan Mode (activated with Shift+Tab) turns the agent into a thoughtful collaborator. Before writing a single line of code or running a single command, it analyzes your request, asks clarifying questions, and produces a structured implementation plan for your review. You approve the plan, then it executes.

Autopilot Mode goes hands-free. For well-defined, trust-worthy tasks — writing unit tests, refactoring files, fixing CI failures — you hand the wheel over entirely. The agent executes tools, runs shell commands, and iterates until the job is done.

Specialized Built-In Agents

Rather than a monolithic assistant, Copilot CLI delegates to specialized sub-agents automatically:

• Explore — Fast codebase analysis without polluting your main context.
• Task — Runs builds, tests, and shell commands.
• Code Review — Analyzes staged or unstaged changes before you commit.
• Plan — Dedicated implementation planning agent

Multiple agents can run in parallel, dramatically shortening feedback loops on complex tasks.

Background Delegation with & Prefix

Prefix any prompt with & to delegate work to the cloud-based Copilot coding agent while you keep your terminal free for other tasks. Use /resume to switch between local and remote sessions. This is particularly powerful for long-running Power Platform solution exports or deployment pipelines.

MCP Extensibility: The Game Changer

Copilot CLI ships with GitHub’s own MCP server built in and supports any custom MCP server. This is where the story for Power Platform professionals gets genuinely exciting — we’ll cover the specifics in a dedicated scenario section below.

Multi-Model Choice

You can choose your AI engine mid-session with the /model command:

For quick scaffolding tasks, Claude Haiku 4.5 or GPT-5 mini will burn almost no premium request budget. For architectural deep-dives, Claude Sonnet 4.6 hits the sweet spot of capability and cost.

Infinite Sessions with Auto-Compaction and Repository Memory

When your session approaches 95% of the context window, Copilot automatically compresses history in the background. Sessions can run as long as your task requires. Across sessions, the agent builds repository memory — learning your codebase conventions, naming patterns, and preferences so future sessions are immediately productive.

/diff, /review, and Undo

• /diff — Review all file changes made during the session with syntax-highlighted inline diffs, add line-level comments, toggle between session changes and branch diffs.
• /review — Quick sanity check on staged or unstaged changes before committing.
• Esc+Esc — Rewind all file changes back to any previous snapshot in the session

How to Install GitHub Copilot CLI

npm install -g @github/copilot   # or: brew install github/tap/copilot  |  winget install GitHub.Copilot
copilot                           # authenticate and launch
/init                             # initialize for your repo

npm install -g @github/copilot   # or: brew install github/tap/copilot  |  winget install GitHub.Copilot
copilot                           # authenticate and launch
/init                             # initialize for your repo

Homebrew and WinGet both auto-update. Copilot CLI is also included in the default GitHub Codespaces image. For full install options, prerequisites, and first-launch walkthrough, see the in GitHub Copilot CLI: Complete Developer Guide for Power Platform, .NET, and TypeScript.

Power Platform Skills Plugin — Microsoft’s Official Integration

One of the most significant discoveries for Power Platform developers is the microsoft/power-platform-skills repository — an officially maintained plugin marketplace for GitHub Copilot CLI (and Claude Code) that provides Power Platform development plugins.

Installing the Power Platform Skills Plugin

# Quick install via curl (Mac/Linux/Windows cmd)
curl -fsSL https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js | node

# Or install manually inside a Copilot CLI session
/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills

# Quick install via curl (Mac/Linux/Windows cmd)
curl -fsSL https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js | node

# Or install manually inside a Copilot CLI session
/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills

What’s Available Today

Power Pages Plugin supports creating and deploying Power Pages Code Sites (Single Page Applications) using modern frontend stacks: React, Angular, Vue, or Astro — deployed via PAC CLI.

Power Apps Plugin (coming soon) will support building and deploying Power Apps generative pages for model-driven apps using React + TypeScript + Fluent UI.

This is Microsoft signaling clearly: the future of Power Platform professional development runs through the terminal and agentic AI.

5 Real-World Scenarios for Power Platform Developers

Scenario 1: Scaffolding a PAC CLI Power Platform Project

You’re starting a new Power Platform solution repository from scratch. Instead of manually creating the folder structure, environment configuration, and GitHub Actions workflow, you describe the intent to Copilot CLI:

copilot
> Set up a Power Platform ALM repository for a Dataverse solution named "CustomerPortal". 
> Include PAC CLI commands for solution export/import, a GitHub Actions workflow for CI/CD, 
> and a .env.example file with environment variables for dev, test, and prod.

copilot
> Set up a Power Platform ALM repository for a Dataverse solution named "CustomerPortal". 
> Include PAC CLI commands for solution export/import, a GitHub Actions workflow for CI/CD, 
> and a .env.example file with environment variables for dev, test, and prod.

Copilot CLI switches to Plan Mode, proposes the full structure for your review, then executes — creating the folder hierarchy, scaffolding the workflow YAML, and writing the PAC CLI helper scripts.

Sample generated GitHub Actions workflow snippet:

# .github/workflows/export-solution.yml
name: Export Power Platform Solution

on:
  workflow_dispatch:
    inputs:
      solution_name:
        description: 'Solution unique name'
        required: true
        default: 'CustomerPortal'

jobs:
  export-solution:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install PAC CLI
        run: |
          npm install -g @microsoft/powerplatform-cli

      - name: Authenticate to Power Platform
        run: |
          pac auth create \
            --url ${{ secrets.DATAVERSE_URL }} \
            --applicationId ${{ secrets.CLIENT_ID }} \
            --clientSecret ${{ secrets.CLIENT_SECRET }} \
            --tenant ${{ secrets.TENANT_ID }}

      - name: Export solution (unmanaged)
        run: |
          pac solution export \
            --name ${{ github.event.inputs.solution_name }} \
            --path ./solutions/${{ github.event.inputs.solution_name }}.zip \
            --managed false \
            --overwrite true

      - name: Unpack solution
        run: |
          pac solution unpack \
            --zipfile ./solutions/${{ github.event.inputs.solution_name }}.zip \
            --folder ./solutions/${{ github.event.inputs.solution_name }} \
            --processCanvasApps true

      - name: Commit unpacked solution
        run: |
          git config user.name "GitHub Actions"
          git config user.email "actions@github.com"
          git add ./solutions/
          git commit -m "chore: export ${{ github.event.inputs.solution_name }}" || echo "No changes"
          git push

# .github/workflows/export-solution.yml
name: Export Power Platform Solution

on:
  workflow_dispatch:
    inputs:
      solution_name:
        description: 'Solution unique name'
        required: true
        default: 'CustomerPortal'

jobs:
  export-solution:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install PAC CLI
        run: |
          npm install -g @microsoft/powerplatform-cli

      - name: Authenticate to Power Platform
        run: |
          pac auth create \
            --url ${{ secrets.DATAVERSE_URL }} \
            --applicationId ${{ secrets.CLIENT_ID }} \
            --clientSecret ${{ secrets.CLIENT_SECRET }} \
            --tenant ${{ secrets.TENANT_ID }}

      - name: Export solution (unmanaged)
        run: |
          pac solution export \
            --name ${{ github.event.inputs.solution_name }} \
            --path ./solutions/${{ github.event.inputs.solution_name }}.zip \
            --managed false \
            --overwrite true

      - name: Unpack solution
        run: |
          pac solution unpack \
            --zipfile ./solutions/${{ github.event.inputs.solution_name }}.zip \
            --folder ./solutions/${{ github.event.inputs.solution_name }} \
            --processCanvasApps true

      - name: Commit unpacked solution
        run: |
          git config user.name "GitHub Actions"
          git config user.email "actions@github.com"
          git add ./solutions/
          git commit -m "chore: export ${{ github.event.inputs.solution_name }}" || echo "No changes"
          git push

Scenario 2: PCF Control Development — Scaffolding and TypeScript Assistance

You’re building a new PCF control — say, a Stakeholder Map visualization for Model-Driven Apps. Copilot CLI can scaffold the entire control, write the TypeScript manifest, and help you debug TypeScript compilation errors iteratively.

copilot --allow-tool 'shell(pac *)' --allow-tool 'shell(npm *)'
> Scaffold a new PCF control named "StakeholderMap" using pac pcf init. 
> It should be a TypeScript field control targeting Dataverse. 
> After scaffolding, install dependencies and confirm it builds cleanly.

copilot --allow-tool 'shell(pac *)' --allow-tool 'shell(npm *)'
> Scaffold a new PCF control named "StakeholderMap" using pac pcf init. 
> It should be a TypeScript field control targeting Dataverse. 
> After scaffolding, install dependencies and confirm it builds cleanly.

Copilot CLI runs the PAC CLI commands, installs dependencies, runs npm run build, interprets the output, and iterates if there are TypeScript errors.

Sample PCF manifest snippet the agent would produce:

<!-- ControlManifest.Input.xml -->
<?xml version="1.0" encoding="utf-8"?>
<manifest>
  <control namespace="AIDevMe" constructor="StakeholderMap" 
           version="1.0.0" display-name-key="StakeholderMap_DisplayName" 
           description-key="StakeholderMap_Desc" control-type="standard">
    
    <property name="stakeholderData" display-name-key="stakeholderData_Display_Name" 
              description-key="stakeholderData_Desc" of-type="Multiple" usage="bound" required="true"/>
    
    <property name="selectedColor" display-name-key="selectedColor_Display_Name"
              description-key="selectedColor_Desc" of-type="SingleLine.Text" usage="input" required="false"/>

    <resources>
      <code path="index.ts" order="1"/>
      <css path="css/StakeholderMap.css" order="1"/>
    </resources>
  </control>
</manifest>

<!-- ControlManifest.Input.xml -->
<?xml version="1.0" encoding="utf-8"?>
<manifest>
  <control namespace="AIDevMe" constructor="StakeholderMap" 
           version="1.0.0" display-name-key="StakeholderMap_DisplayName" 
           description-key="StakeholderMap_Desc" control-type="standard">
    
    <property name="stakeholderData" display-name-key="stakeholderData_Display_Name" 
              description-key="stakeholderData_Desc" of-type="Multiple" usage="bound" required="true"/>
    
    <property name="selectedColor" display-name-key="selectedColor_Display_Name"
              description-key="selectedColor_Desc" of-type="SingleLine.Text" usage="input" required="false"/>

    <resources>
      <code path="index.ts" order="1"/>
      <css path="css/StakeholderMap.css" order="1"/>
    </resources>
  </control>
</manifest>

// index.ts — generated by Copilot CLI
import { IInputs, IOutputs } from "./generated/ManifestTypes";

export class StakeholderMap implements ComponentFramework.StandardControl<IInputs, IOutputs> {
  private container: HTMLDivElement;
  private context: ComponentFramework.Context<IInputs>;

  public init(
    context: ComponentFramework.Context<IInputs>,
    notifyOutputChanged: () => void,
    state: ComponentFramework.Dictionary,
    container: HTMLDivElement
  ): void {
    this.container = container;
    this.context = context;
    this.renderMap();
  }

  private renderMap(): void {
    const data = this.context.parameters.stakeholderData.raw ?? "";
    // Render 2D quadrant visualization
    this.container.innerHTML = `
      <div class="stakeholder-map">
        <div class="quadrant high-influence high-interest">Champions</div>
        <div class="quadrant high-influence low-interest">Keep Satisfied</div>
        <div class="quadrant low-influence high-interest">Keep Informed</div>
        <div class="quadrant low-influence low-interest">Monitor</div>
      </div>
    `;
  }

  public updateView(context: ComponentFramework.Context<IInputs>): void {
    this.context = context;
    this.renderMap();
  }

  public getOutputs(): IOutputs {
    return {};
  }

  public destroy(): void {
    this.container.innerHTML = "";
  }
}

// index.ts — generated by Copilot CLI
import { IInputs, IOutputs } from "./generated/ManifestTypes";

export class StakeholderMap implements ComponentFramework.StandardControl<IInputs, IOutputs> {
  private container: HTMLDivElement;
  private context: ComponentFramework.Context<IInputs>;

  public init(
    context: ComponentFramework.Context<IInputs>,
    notifyOutputChanged: () => void,
    state: ComponentFramework.Dictionary,
    container: HTMLDivElement
  ): void {
    this.container = container;
    this.context = context;
    this.renderMap();
  }

  private renderMap(): void {
    const data = this.context.parameters.stakeholderData.raw ?? "";
    // Render 2D quadrant visualization
    this.container.innerHTML = `
      <div class="stakeholder-map">
        <div class="quadrant high-influence high-interest">Champions</div>
        <div class="quadrant high-influence low-interest">Keep Satisfied</div>
        <div class="quadrant low-influence high-interest">Keep Informed</div>
        <div class="quadrant low-influence low-interest">Monitor</div>
      </div>
    `;
  }

  public updateView(context: ComponentFramework.Context<IInputs>): void {
    this.context = context;
    this.renderMap();
  }

  public getOutputs(): IOutputs {
    return {};
  }

  public destroy(): void {
    this.container.innerHTML = "";
  }
}

Scenario 3: Debugging a Failing GitHub Actions Power Platform Pipeline

Your Power Platform solution export pipeline is failing with a cryptic PAC CLI error. Instead of digging through logs manually, you paste the error into Copilot CLI:

copilot
> My GitHub Actions workflow is failing with this error on the 'pac solution export' step:
> "Error: Solution with name 'MyApp' was not found in the target environment."
> The solution definitely exists in our dev environment. The workflow uses a Service Principal. 
> Here's the workflow file: [paste or /add-file workflow.yml]

copilot
> My GitHub Actions workflow is failing with this error on the 'pac solution export' step:
> "Error: Solution with name 'MyApp' was not found in the target environment."
> The solution definitely exists in our dev environment. The workflow uses a Service Principal. 
> Here's the workflow file: [paste or /add-file workflow.yml]

Copilot CLI reads the workflow, identifies that the pac auth create step is pointing at the wrong environment URL (a common mistake where DATAVERSE_URL resolves to the production environment secret instead of dev), proposes a fix, and shows you a /diff before applying it.

Key PAC CLI environment variable pattern to always verify:

# Common pitfall: wrong secret scope
# ❌ This might resolve to PROD if secret names overlap
- run: pac auth create --url ${{ secrets.DATAVERSE_URL }}

# ✅ Use environment-scoped secrets
- run: pac auth create --url ${{ secrets.DEV_DATAVERSE_URL }}

# ✅ Or use environment deployments in GitHub Actions
environment: development
env:
  DATAVERSE_URL: ${{ secrets.DATAVERSE_URL }}  # Scoped to 'development' environment

# Common pitfall: wrong secret scope
# ❌ This might resolve to PROD if secret names overlap
- run: pac auth create --url ${{ secrets.DATAVERSE_URL }}

# ✅ Use environment-scoped secrets
- run: pac auth create --url ${{ secrets.DEV_DATAVERSE_URL }}

# ✅ Or use environment deployments in GitHub Actions
environment: development
env:
  DATAVERSE_URL: ${{ secrets.DATAVERSE_URL }}  # Scoped to 'development' environment

Scenario 4: Using a Custom MCP Server for Dataverse Operations

One of the most powerful capabilities for Power Platform architects is combining Copilot CLI with a custom Dataverse MCP server. This allows the agent to query your actual Dataverse environment — reading entity metadata, checking solution components, or validating data — as part of its planning and execution.

Here’s how you configure a local Dataverse MCP server inside Copilot CLI:

// ~/.copilot/config.json
{
  "mcpServers": {
    "dataverse": {
      "command": "node",
      "args": ["/path/to/dataverse-mcp-server/dist/index.js"],
      "env": {
        "DATAVERSE_URL": "https://yourorg.crm.dynamics.com",
        "CLIENT_ID": "<your-app-registration-client-id>",
        "TENANT_ID": "<your-tenant-id>",
        "CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }
}

// ~/.copilot/config.json
{
  "mcpServers": {
    "dataverse": {
      "command": "node",
      "args": ["/path/to/dataverse-mcp-server/dist/index.js"],
      "env": {
        "DATAVERSE_URL": "https://yourorg.crm.dynamics.com",
        "CLIENT_ID": "<your-app-registration-client-id>",
        "TENANT_ID": "<your-tenant-id>",
        "CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }
}

Once configured, you can prompt Copilot CLI with natural language against your live Dataverse:

copilot
> Check the 'Contact' entity in our Dataverse environment and list all custom fields 
> added in the last 30 days. Then generate a PAC CLI command to export only 
> the solution containing those components.

copilot
> Check the 'Contact' entity in our Dataverse environment and list all custom fields 
> added in the last 30 days. Then generate a PAC CLI command to export only 
> the solution containing those components.

The agent calls the Dataverse MCP server, retrieves metadata, synthesizes the component list, and generates the scoped pac solution export command — all in one session.

Scenario 5: Writing and Running Integration Tests for Power Automate Flows

Power Automate flows are notoriously hard to test automatically. Using Copilot CLI with the background delegation (&) pattern, you can ask the agent to generate a test harness while you continue working:

copilot
& Write a Node.js integration test suite using Jest for our 'LeadQualification' Power Automate 
flow. The flow accepts a JSON body with {firstName, lastName, email, company} and 
calls an HTTP trigger. Use the endpoint from our .env file. Mock the external CRM call 
but actually invoke the flow via HTTP. Include happy path, missing field, and invalid email tests.

copilot
& Write a Node.js integration test suite using Jest for our 'LeadQualification' Power Automate 
flow. The flow accepts a JSON body with {firstName, lastName, email, company} and 
calls an HTTP trigger. Use the endpoint from our .env file. Mock the external CRM call 
but actually invoke the flow via HTTP. Include happy path, missing field, and invalid email tests.

While the test suite is being written in the background, you switch to another terminal. Later:

/resume

/resume

The agent has finished. You review the generated test file with /diff, approve it, and run it:

// Generated: lead-qualification.test.js
const axios = require("axios");
require("dotenv").config();

const FLOW_URL = process.env.LEAD_QUALIFICATION_FLOW_URL;

describe("LeadQualification Power Automate Flow", () => {
  
  test("Happy path: valid lead submits successfully", async () => {
    const response = await axios.post(FLOW_URL, {
      firstName: "Anna",
      lastName: "Kovacs",
      email: "anna.kovacs@example.com",
      company: "Contoso Ltd"
    });
    expect(response.status).toBe(202);
    expect(response.data).toHaveProperty("leadId");
  });

  test("Missing required field returns 400", async () => {
    await expect(
      axios.post(FLOW_URL, {
        firstName: "Anna",
        // lastName missing
        email: "anna.kovacs@example.com",
        company: "Contoso Ltd"
      })
    ).rejects.toMatchObject({ response: { status: 400 } });
  });

  test("Invalid email format returns 400", async () => {
    await expect(
      axios.post(FLOW_URL, {
        firstName: "Anna",
        lastName: "Kovacs",
        email: "not-an-email",
        company: "Contoso Ltd"
      })
    ).rejects.toMatchObject({ response: { status: 400 } });
  });
});

// Generated: lead-qualification.test.js
const axios = require("axios");
require("dotenv").config();

const FLOW_URL = process.env.LEAD_QUALIFICATION_FLOW_URL;

describe("LeadQualification Power Automate Flow", () => {
  
  test("Happy path: valid lead submits successfully", async () => {
    const response = await axios.post(FLOW_URL, {
      firstName: "Anna",
      lastName: "Kovacs",
      email: "anna.kovacs@example.com",
      company: "Contoso Ltd"
    });
    expect(response.status).toBe(202);
    expect(response.data).toHaveProperty("leadId");
  });

  test("Missing required field returns 400", async () => {
    await expect(
      axios.post(FLOW_URL, {
        firstName: "Anna",
        // lastName missing
        email: "anna.kovacs@example.com",
        company: "Contoso Ltd"
      })
    ).rejects.toMatchObject({ response: { status: 400 } });
  });

  test("Invalid email format returns 400", async () => {
    await expect(
      axios.post(FLOW_URL, {
        firstName: "Anna",
        lastName: "Kovacs",
        email: "not-an-email",
        company: "Contoso Ltd"
      })
    ).rejects.toMatchObject({ response: { status: 400 } });
  });
});

Have you tried any of these scenarios yet? These five workflows cover the most common entry points for Power Platform developers. But everyone’s stack is different — maybe you’re deep in Dataverse plugins, or you’re managing a 50-solution tenant, or you’re building PCF controls with React 18 and Fluent UI v9.

Which scenario is most relevant to your work right now? And is there one we didn’t cover that you’d like to see? Tell us in the comments — the most-requested scenario becomes the next deep-dive article on AIDevMe.

Extending with Agent Skills

One of the most powerful customization mechanisms is Agent Skills — markdown files committed to .github/skills/ that teach the agent your team’s specific workflows. A Power Platform skill might encode your deployment checklist, environment naming conventions, and PAC CLI authentication patterns — so every team member’s Copilot session has that institutional knowledge baked in automatically.

<!-- .github/skills/pac-cli-deploy/SKILL.md -->
---
name: pac-cli-deploy
description: Deploy Power Platform solutions using PAC CLI. Use when the user asks to
  export, import, or publish a Dataverse solution, or manage PAC CLI authentication.
---
Always authenticate via Service Principal. Run `pac solution check` before import.
Use `--async` for solutions > 50MB. Environments: DEV / TEST / PROD.

<!-- .github/skills/pac-cli-deploy/SKILL.md -->
---
name: pac-cli-deploy
description: Deploy Power Platform solutions using PAC CLI. Use when the user asks to
  export, import, or publish a Dataverse solution, or manage PAC CLI authentication.
---
Always authenticate via Service Principal. Run `pac solution check` before import.
Use `--async` for solutions > 50MB. Environments: DEV / TEST / PROD.

Skills work across Copilot CLI, Claude Code, and VS Code agent mode — write once, use everywhere. For a complete guide to writing, structuring, and sharing skills, see GitHub Copilot CLI: Complete Developer Guide for Power Platform, .NET, and TypeScript.

GitHub Copilot CLI vs Claude Code: A Quick Comparison

Both tools are terminal-native AI coding agents. Here’s how they compare for Power Platform professionals:

If your workflow is deeply embedded in GitHub — Issues, PRs, GitHub Actions, Codespaces — Copilot CLI’s native context is a significant productivity advantage. If you prefer maximum context window and direct model access, Claude Code retains an edge on raw capability.

For most Power Platform enterprise architects: both tools are worth keeping in your toolkit. The Microsoft Power Platform Skills plugin explicitly supports both.

The Skills Ecosystem: What’s Available by Developer Profile

The Agent Skills standard (agentskills.io) is supported across GitHub Copilot CLI, Claude Code, and VS Code agent mode. Four major repositories cover the Power Platform space:

Quick install:

/plugin marketplace add microsoft/power-platform-skills
/plugin marketplace add github/awesome-copilot
/plugin install power-pages@power-platform-skills

/plugin marketplace add microsoft/power-platform-skills
/plugin marketplace add github/awesome-copilot
/plugin install power-pages@power-platform-skills

No PCF plugin exists in microsoft/power-platform-skills today. PCF coverage comes from github/awesome-copilot as the pcf-api-reference instruction and the PCF Development collection (17 items) — not a standalone Agent Skill.

For the full curated breakdown by developer profile — Power Platform, .NET, React/TypeScript, Azure/DevOps, MCP builders, and cross-role productivity — see GitHub Copilot CLI: Complete Developer Guide for Power Platform, .NET, and TypeScript.

Quick Start for Power Platform Developers

Five minutes to your first agentic PAC CLI session:

npm install -g @github/copilot                          # 1. Install
copilot && /init                                        # 2. Authenticate and initialize repo
/plugin marketplace add microsoft/power-platform-skills # 3. Add Power Platform Skills
/plugin install power-pages@power-platform-skills       # 4. Install the plugin
> List all solutions in my Dataverse dev environment    # 5. First prompt

npm install -g @github/copilot                          # 1. Install
copilot && /init                                        # 2. Authenticate and initialize repo
/plugin marketplace add microsoft/power-platform-skills # 3. Add Power Platform Skills
/plugin install power-pages@power-platform-skills       # 4. Install the plugin
> List all solutions in my Dataverse dev environment    # 5. First prompt

For a complete 7-step walkthrough including AGENTS.md configuration, Dataverse MCP setup, and recommended skill selection, see GitHub Copilot CLI: Complete Developer Guide for Power Platform, .NET, and TypeScript

Join the Conversation

GitHub Copilot CLI GA is one of those releases that looks incremental on the surface but quietly shifts how professional Power Platform development works. The combination of agentic autonomy, PAC CLI native support, Agent Skills extensibility, and the official microsoft/power-platform-skills plugin means the gap between “low-code developer” and “terminal-native architect” just got a lot narrower.

A few things I’d love to hear from you:

• Have you migrated any manual PAC CLI steps to Copilot CLI yet? What did you automate first?
• Are you building custom Agent Skills for your team? Share what problem you’re solving — or drop a link to your repo if it’s public.
• Copilot CLI or Claude Code — or both? Where do you see each one fitting in your workflow?
• What’s missing? Is there a Power Platform workflow you wish Copilot CLI could handle that it can’t yet?

Leave a comment below, or find me on LinkedIn — I read and respond to everything. If this article was useful, sharing it with one other Power Platform developer in your network makes a real difference for the AIDevMe community.

Not subscribed yet? The AIDevMe newsletter covers exactly this kind of deep-dive, practical content — Power Platform architecture, agentic AI patterns, and the tools that are actually changing how we build. Subscribe here and get the next article directly in your inbox.

References and Further Reading

• GitHub Changelog: Copilot CLI is now generally available — Official GA announcement, February 25, 2026.
• GitHub Copilot CLI Documentation — Full reference documentation.
• Copilot CLI Best Practices Guide — GitHub’s official recommendations.
• microsoft/power-platform-skills — Official Microsoft plugin for Copilot CLI and Claude Code.
• GitHub Copilot CLI Changelog: Enhanced agents and context management — January 2026 update notes.
• Enterprise AI Controls & Agent Control Plane GA — Enterprise governance capabilities.
• PAC CLI Reference — Microsoft Learn.
• Copilot CLI Public Repository — Release notes and community discussions

Related Reading

If this article gave you a solid overview and you want to go deeper, the companion Developer Guide covers the same ecosystem as a progressive, hands-on reference — starting from installation through to enterprise configuration, with a full command reference, AGENTS.md templates, and step-by-step Power Platform integration walkthrough.

GitHub Copilot CLI: Developer Guide — Structured learning path with practical examples for Power Platform, .NET, and TypeScript developers.