Claude GitHub Copilot Skill

ide-switching

Use when moving between VS Code and Copilot CLI in the same session — transfers context between environments so you don't lose state when switching from editor to terminal.

LLM Mart · 0 points · 1 views 0 listing impressions 0 install-command copies
Download drvoss-everything-copilot-cli-plugins_copilot-native-workflows_skills_ide-switching-1ca2355.zip · 2 KB

Install

skills CLI npx skills add https://github.com/drvoss/everything-copilot-cli/tree/main/plugins/copilot-native-workflows/skills/ide-switching
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install drvoss-everything-copilot-cli@llmmart
Git git clone https://github.com/drvoss/everything-copilot-cli.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole drvoss/everything-copilot-cli collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

IDE ↔ CLI Switching

Why This is Copilot-Exclusive

GitHub Copilot exists in both VS Code and the terminal under a single subscription and unified platform. You can start a conversation in VS Code's Copilot Chat, switch to the CLI for batch automation, and return to VS Code for visual debugging — all with the same model access, same MCP servers, and same GitHub integration. Claude Code can connect to an IDE from the terminal, but Copilot is one product with native chat in both VS Code and the CLI.

When to Use

  • Visual tasks (diffing, debugging UI, extension-based tooling) → VS Code
  • Batch operations, automation, scripting → CLI
  • Large refactors that benefit from both visual review and automated execution
  • When VS Code's Copilot Chat lacks a tool you need (SQL, fleet agents, MCP)
  • Pair programming where one person uses IDE, another uses CLI

Workflow

Know Your Strengths: When to Use Each

Task VS Code Copilot Copilot CLI
Visual code review ✅ Side-by-side diffing ❌
Breakpoint debugging ✅ Debug panel ❌
Single-file inline edits ✅ Inline suggestions ✅ Edit tool
Multi-file refactoring ⚠️ Limited ✅ Fleet mode
CI/CD debugging ❌ ✅ Actions MCP tools
PR review & management ⚠️ Basic ✅ Full GitHub MCP
Batch test execution ⚠️ Manual ✅ Background agents
SQL-based task tracking ❌ ✅ Session database
Multi-model selection ⚠️ Limited ✅ 20+ models available
Terminal automation ⚠️ Integrated terminal ✅ Native

Switching Patterns

Pattern 1: CLI-First, Visual Verify

  1. Use Copilot CLI to make sweeping changes across many files
  2. Open VS Code: code .
  3. Use VS Code's Source Control panel to review all changes visually
  4. Use VS Code's Copilot Chat to ask questions about specific diffs
  5. Return to CLI for any follow-up batch operations

Pattern 2: VS Code Debug, CLI Fix

  1. Hit a bug while coding in VS Code
  2. Use VS Code debugger to identify the root cause
  3. Switch to CLI for the fix — especially if it spans multiple files
  4. CLI makes the edits, runs the tests, confirms the fix
  5. Back to VS Code for continued development

Pattern 3: Aligned MCP Configuration

Keep the CLI workspace config in .mcp.json, and mirror the same server definitions into any editor-specific config you standardize on:

// .mcp.json
{
  "mcpServers": {
    "my-api": {
      "command": "npx",
      "args": ["my-api-mcp-server"],
      "tools": ["*"],
      "env": { "API_KEY": "${MY_API_KEY}" }
    }
  }
}

Treat the workspace config as the CLI-facing source of truth, then keep editor integrations aligned with the same server definitions.

Examples

Large Refactor Workflow

# Step 1: CLI - Rename across the codebase
# "Rename the UserService class to AuthService in all files under src/"
# Copilot uses fleet agents to process files in parallel

# Step 2: VS Code - Visual review
code .
# Review changes in Source Control panel, check diff views

# Step 3: CLI - Run tests and fix issues
# "Run the full test suite and fix any failures from the rename"

Morning Developer Workflow

# Start in CLI for triage
# "List my open PRs, check CI status, and summarize review comments"

# Switch to VS Code for focused coding
code src/feature.ts
# Use Copilot Chat inline for suggestions

# Back to CLI for PR creation
# "Create a PR for this branch with a description based on my commits"

Tips

  • MCP config sharing: Keep workspace MCP configs in .mcp.json, then mirror the same server definitions into any editor-specific config your team uses.
  • Use CLI for what VS Code can't do: Fleet mode, background agents, session SQL, and Actions debugging are CLI-exclusive features.
  • Quick switch: Keep a terminal open alongside VS Code. Use code <file> from CLI to open specific files for visual inspection.
  • Context handoff: When switching from VS Code to CLI, paste relevant code snippets or error messages to give CLI the context it needs.
  • Same subscription: Both tools use the same GitHub Copilot license — no extra cost for using both. Maximize your subscription value.
Files (everything-copilot-cli)
  • SKILL.md 4.9 KB
    ---
    name: ide-switching
    license: MIT
    description: Use when moving between VS Code and Copilot CLI in the same session — transfers context between environments so you don't lose state when switching from editor to terminal.
    metadata:
      category: copilot-exclusive
      copilot_feature: "VS Code integration, shared Copilot subscription, unified context model"
    ---
    
    # IDE ↔ CLI Switching
    
    ## Why This is Copilot-Exclusive
    
    GitHub Copilot exists in **both VS Code and the terminal** under a single subscription and
    unified platform. You can start a conversation in VS Code's Copilot Chat, switch to the CLI
    for batch automation, and return to VS Code for visual debugging — all with the same model
    access, same MCP servers, and same GitHub integration. Claude Code can connect to an IDE from the terminal, but Copilot is one product with native chat in both VS Code and the CLI.
    
    ## When to Use
    
    - Visual tasks (diffing, debugging UI, extension-based tooling) → VS Code
    - Batch operations, automation, scripting → CLI
    - Large refactors that benefit from both visual review and automated execution
    - When VS Code's Copilot Chat lacks a tool you need (SQL, fleet agents, MCP)
    - Pair programming where one person uses IDE, another uses CLI
    
    ## Workflow
    
    ### Know Your Strengths: When to Use Each
    
    | Task                        | VS Code Copilot          | Copilot CLI              |
    |-----------------------------|--------------------------|--------------------------|
    | Visual code review          | ✅ Side-by-side diffing  | ❌                       |
    | Breakpoint debugging        | ✅ Debug panel            | ❌                       |
    | Single-file inline edits    | ✅ Inline suggestions     | ✅ Edit tool             |
    | Multi-file refactoring      | ⚠️ Limited               | ✅ Fleet mode            |
    | CI/CD debugging             | ❌                        | ✅ Actions MCP tools     |
    | PR review & management      | ⚠️ Basic                 | ✅ Full GitHub MCP       |
    | Batch test execution        | ⚠️ Manual                | ✅ Background agents     |
    | SQL-based task tracking     | ❌                        | ✅ Session database      |
    | Multi-model selection       | ⚠️ Limited               | ✅ 20+ models available  |
    | Terminal automation         | ⚠️ Integrated terminal   | ✅ Native                |
    
    ### Switching Patterns
    
    #### Pattern 1: CLI-First, Visual Verify
    
    1. Use Copilot CLI to make sweeping changes across many files
    2. Open VS Code: `code .`
    3. Use VS Code's Source Control panel to review all changes visually
    4. Use VS Code's Copilot Chat to ask questions about specific diffs
    5. Return to CLI for any follow-up batch operations
    
    #### Pattern 2: VS Code Debug, CLI Fix
    
    1. Hit a bug while coding in VS Code
    2. Use VS Code debugger to identify the root cause
    3. Switch to CLI for the fix — especially if it spans multiple files
    4. CLI makes the edits, runs the tests, confirms the fix
    5. Back to VS Code for continued development
    
    #### Pattern 3: Aligned MCP Configuration
    
    Keep the CLI workspace config in `.mcp.json`, and mirror the same server definitions into any
    editor-specific config you standardize on:
    
    ```json
    // .mcp.json
    {
      "mcpServers": {
        "my-api": {
          "command": "npx",
          "args": ["my-api-mcp-server"],
          "tools": ["*"],
          "env": { "API_KEY": "${MY_API_KEY}" }
        }
      }
    }
    ```
    
    Treat the workspace config as the CLI-facing source of truth, then keep editor integrations aligned
    with the same server definitions.
    
    ## Examples
    
    ### Large Refactor Workflow
    
    ```bash
    # Step 1: CLI - Rename across the codebase
    # "Rename the UserService class to AuthService in all files under src/"
    # Copilot uses fleet agents to process files in parallel
    
    # Step 2: VS Code - Visual review
    code .
    # Review changes in Source Control panel, check diff views
    
    # Step 3: CLI - Run tests and fix issues
    # "Run the full test suite and fix any failures from the rename"
    ```
    
    ### Morning Developer Workflow
    
    ```bash
    # Start in CLI for triage
    # "List my open PRs, check CI status, and summarize review comments"
    
    # Switch to VS Code for focused coding
    code src/feature.ts
    # Use Copilot Chat inline for suggestions
    
    # Back to CLI for PR creation
    # "Create a PR for this branch with a description based on my commits"
    ```
    
    ## Tips
    
    - **MCP config sharing**: Keep workspace MCP configs in `.mcp.json`, then mirror the
      same server definitions into any editor-specific config your team uses.
    - **Use CLI for what VS Code can't do**: Fleet mode, background agents, session SQL,
      and Actions debugging are CLI-exclusive features.
    - **Quick switch**: Keep a terminal open alongside VS Code. Use `code <file>` from CLI
      to open specific files for visual inspection.
    - **Context handoff**: When switching from VS Code to CLI, paste relevant code snippets
      or error messages to give CLI the context it needs.
    - **Same subscription**: Both tools use the same GitHub Copilot license — no extra cost
      for using both. Maximize your subscription value.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.