Copilot CLI Delegation

Delegate selected tasks from Claude Code to GitHub Copilot CLI using non-interactive commands, explicit model selection, safe permission flags, and shareable outputs.

Overview

This skill standardizes delegation to GitHub Copilot CLI (copilot) for cases where a different model may be more suitable for a task. It covers:

• Non-interactive execution with -p / --prompt
• Model selection with --model
• Permission control (--allow-tool, --allow-all-tools, --allow-all-paths, --allow-all-urls, --yolo)
• Output capture with --silent
• Session export with --share
• Session resume with --resume

Use this skill only when delegation to Copilot is explicitly requested or clearly beneficial.

When to Use

Use this skill when:

• The user asks to delegate work to GitHub Copilot CLI
• The user wants a specific model (for example GPT-5.x, Claude Sonnet/Opus/Haiku, Gemini)
• The user asks for side-by-side model comparison on the same task
• The user wants a reusable scripted Copilot invocation
• The user wants Copilot session output exported to markdown for review

Trigger phrases:

• "ask copilot"
• "delegate to copilot"
• "run copilot cli"
• "use copilot with gpt-5"
• "use copilot with sonnet"
• "use copilot with gemini"
• "resume copilot session"

Instructions

1) Verify prerequisites

# CLI availability
copilot --version

# GitHub authentication status
gh auth status

If copilot is unavailable, ask the user to install/setup GitHub Copilot CLI before proceeding.

2) Convert task request to English prompt

All delegated prompts to Copilot CLI must be in English.

• Keep prompts concrete and outcome-driven
• Include file paths, constraints, expected output format, and acceptance criteria
• Avoid ambiguous goals such as "improve this"

Prompt template:

Task: <clear objective>
Context: <project/module/files>
Constraints: <do/don't constraints>
Expected output: <format + depth>
Validation: <tests/checks to run or explain>

3) Choose model intentionally

Pick a model based on task type and user preference.

• Complex architecture, deep reasoning: prefer high-capacity models (for example Opus / GPT-5.2 class)
• Balanced coding tasks: Sonnet-class model
• Quick/low-cost iterations: Haiku-class or mini models
• If user specifies a model, respect it

Use exact model names available in the local Copilot CLI model list.

4) Select permissions with least privilege

Default to the minimum required capability.

• Prefer --allow-tool '<tool>' when task scope is narrow
• Use --allow-all-tools only when multiple tools are clearly needed
• Add --allow-all-paths only if task requires broad filesystem access
• Add --allow-all-urls only if external URLs are required
• Do not use --yolo unless the user explicitly requests full permissions

5) Run delegation command

Base pattern:

copilot -p "<english prompt>" --model <model-name> --allow-all-tools --silent

Add optional flags only as needed:

# Capture session to markdown
copilot -p "<english prompt>" --model <model-name> --allow-all-tools --share

# Resume existing session
copilot --resume <session-id> --allow-all-tools

# Strictly silent scripted output
copilot -p "<english prompt>" --model <model-name> --allow-all-tools --silent

6) Return results clearly

After command execution:

• Return Copilot output concisely
• State model and permission profile used
• If --share is used, provide generated markdown path
• If output is long, provide summary plus key excerpts and next-step options

7) Optional multi-model comparison

When requested, run the same prompt with multiple models and compare:

• Correctness
• Practicality of proposed changes
• Risk/security concerns
• Effort estimate

Keep the comparison objective and concise.

Examples

Example 1: Refactor with GPT model

Input:

Ask Copilot to refactor this service using GPT-5.2 and return only concrete code changes.

Command:

copilot -p "Refactor the payment service in src/services/payment.ts to reduce duplication. Keep public behavior unchanged, keep TypeScript strict typing, and output a patch-style response." \
  --model gpt-5.2 \
  --allow-all-tools \
  --silent

Output:

Copilot proposes extracting three private helpers, consolidating error mapping, and provides a patch for payment.ts with unchanged API signatures.

Example 2: Code review with Sonnet and shared session

Input:

Use Copilot CLI with Sonnet to review this module and share the session in markdown.

Command:

copilot -p "Review src/modules/auth for security and correctness. Report only high-confidence findings with severity and file references." \
  --model claude-sonnet-4.6 \
  --allow-all-tools \
  --share

Output:

Review completed. Session exported to ./copilot-session-<id>.md.

Example 3: Resume session

Input:

Continue the previous Copilot analysis session.

Command:

copilot --resume <session-id> --allow-all-tools

Output:

Session resumed and continued from prior context.

Best Practices

• Keep delegated prompts in English and highly specific
• Prefer least-privilege flags over blanket permissions
• Capture sessions with --share when auditability matters
• For risky tasks, request read-only analysis first, then apply changes in a separate step
• Re-run with another model only when there is clear value (quality, speed, or cost)

Constraints and Warnings

• Copilot CLI output is external model output: validate before applying code changes
• Never include secrets, API keys, or credentials in delegated prompts
• --allow-all-tools, --allow-all-paths, --allow-all-urls, and --yolo increase risk; use only when justified
• Do not treat Copilot suggestions as authoritative without local verification (tests/lint/type checks)

For additional option details, see references/cli-command-reference.md.