# Cómo usar GitHub Copilot CLI: guía paso a paso

URL: https://agentvera.dev/es/blog/how-to-use-copilot-cli/ · Publicado: 2026-10-27

Cómo usar GitHub Copilot CLI: instálalo, inicia sesión, elige un plan, úsalo en modo interactivo o con -p, fija permisos, elige modelos y añade MCP y reglas.

**En resumen:**

- Instala Copilot CLI con npm, Homebrew, WinGet o el script de instalación, ejecuta copilot en la carpeta de un proyecto, marca la carpeta como de confianza e inicia sesión con /login.
- Copilot pregunta antes de ejecutar herramientas; los patrones de --allow-tool y --deny-tool, como shell(git:*), fijan los permisos, y copilot -p ejecuta un solo prompt para scripts y CI.
- /model cambia de modelo, copilot mcp add conecta servidores MCP, y AGENTS.md o .github/copilot-instructions.md guardan las reglas de tu proyecto.

Para usar GitHub Copilot CLI, instálalo (`npm install -g @github/copilot`, Homebrew, WinGet o el script de instalación), ejecuta `copilot` en la carpeta de un proyecto, confirma que confías en la carpeta, inicia sesión con `/login` y describe la tarea en lenguaje natural. Copilot lee tu código, propone ediciones y comandos, y pregunta antes de ejecutar nada.

Ese es el ciclo básico. Esta guía cubre lo que necesitas después de la primera sesión: qué plan te hace falta, el uso interactivo y programático, los permisos de herramientas, los comandos slash que conviene conocer, los modelos, los servidores MCP y las instrucciones personalizadas. Todo sigue la documentación oficial de GitHub en docs.github.com a octubre de 2026. Si todavía estás eligiendo agente, [Copilot CLI vs Claude Code](/es/blog/copilot-cli-vs-claude-code/ "Copilot CLI vs Claude Code") compara los dos en detalle; este artículo es la guía práctica.

## Qué es Copilot CLI

Copilot CLI es el [agente de programación](/es/glossary/coding-agent/ "Qué es un agente de programación") de GitHub para la terminal. Trabaja sobre la carpeta desde la que lo lanzas: puede leer y cambiar archivos, ejecutar comandos de shell y hablar con GitHub a través de un servidor MCP de GitHub integrado, así que también puede consultar issues y pull requests. Funciona en Linux, macOS y Windows (PowerShell y WSL).

## Paso 1: comprueba tu plan

A octubre de 2026, la página de planes de GitHub indica que todos los planes de Copilot incluyen Copilot CLI. El uso se cuenta en GitHub AI Credits, y lo rápido que los gastes depende del modelo y de la cantidad de trabajo.

| Plan | Precio | Notas |
| --- | --- | --- |
| Copilot Free | Gratis | Asignación limitada de AI Credits |
| Copilot Student | Gratis | Para estudiantes verificados |
| Copilot Pro | 10 $/mes | Más créditos |
| Copilot Pro+ | 39 $/mes | Más créditos |
| Copilot Max | 100 $/mes | La mayor asignación personal |
| Business / Enterprise | 19 $ / 39 $ por puesto | Gestionado por una organización |

Si tu Copilot viene de una organización, un administrador puede desactivar la CLI, así que compruébalo primero si se niega a arrancar. El [artículo comparativo](/es/blog/copilot-cli-vs-claude-code/ "Copilot CLI vs Claude Code") profundiza en los créditos y los precios.

## Paso 2: instala Copilot CLI

| Método | Comando |
| --- | --- |
| npm (Node.js 22 o posterior) | `npm install -g @github/copilot` |
| Homebrew (macOS, Linux) | `brew install --cask copilot-cli` |
| WinGet (Windows) | `winget install GitHub.Copilot` |
| Script de instalación (macOS, Linux) | `curl -fsSL https://gh.io/copilot-install \| bash` |

En Windows necesitas PowerShell 6 o posterior. Si tu configuración de npm tiene activado `ignore-scripts`, instala con `npm_config_ignore_scripts=false npm install -g @github/copilot`. Dentro de una sesión, `/update` actualiza la CLI.

## Paso 3: arráncalo e inicia sesión

```bash
cd ~/code/my-project
copilot
```

La primera vez que arrancas Copilot en una carpeta, te pregunta si confías en los archivos que contiene. Puedes confiar solo para esta sesión, confiar y recordar la elección, o decir que no. Los directorios de confianza son donde Copilot puede leer, cambiar y ejecutar cosas, así que arráncalo en la carpeta del proyecto, no en tu carpeta de inicio.

Si no has iniciado sesión, escribe `/login` y sigue el flujo del navegador. Desde una shell normal, `copilot login` hace lo mismo, con `--device-code` para máquinas sin navegador. Para automatizar, Copilot lee un token de `COPILOT_GITHUB_TOKEN`, luego de `GH_TOKEN` y luego de `GITHUB_TOKEN`; un personal access token fine-grained necesita el permiso “Copilot Requests”. `/user` muestra o cambia la cuenta con la que has iniciado sesión y `/logout` cierra la sesión.

## Paso 4: trabaja en modo interactivo

Escribe lo que quieres:

```text
Busca dónde validamos las direcciones de email, añade un test para direcciones
con un signo más y ejecuta la batería de tests.
```

Algunos trucos para la entrada:

- `@ruta/al/archivo` mete un archivo en el prompt.
- `!comando` ejecuta un comando de shell directamente, sin enviarlo al modelo.
- **Shift+Tab** recorre los modos. En el modo plan, Copilot hace preguntas para aclarar dudas y prepara un plan antes de escribir código. `/plan` hace lo mismo desde el prompt.
- `/autopilot` deja que Copilot siga trabajando por su cuenta hasta terminar la tarea, y `/ask` (o `/btw`) hace una pregunta aparte sin desviar la tarea.

Para todo lo que toque más de un par de archivos, planifica primero:

```text
/plan Divide el OrderService de 900 líneas en servicios más pequeños. Mantén
igual la API pública y enumera todos los archivos que vas a tocar.
```

## Paso 5: aprobaciones y permisos de herramientas

Cuando Copilot quiere ejecutar una herramienta que puede cambiar algo (un comando de shell, la escritura de un archivo, la descarga de una URL), pregunta. Puedes aprobar una vez, aprobar esa herramienta para el resto de la sesión, o decir que no y explicarle qué hacer en su lugar.

Para decidirlo de antemano, usa patrones de permiso con la forma `Tipo(argumento)`:

| Patrón | Coincide con |
| --- | --- |
| `shell(git:*)` | Cualquier comando `git` (`git status`, `git log`…) |
| `shell(git push)` | Exactamente `git push` |
| `write` o `write(src/*.ts)` | Escritura de archivos, opcionalmente limitada a una ruta |
| `read(.env)` | Lectura de un archivo concreto |
| `url(github.com)` | Descargas desde un dominio |
| `MyMCP(create_issue)` | Una herramienta de un servidor MCP |

```bash
# git is fine, pushing is not
copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

# allow everything except deleting files and pushing
copilot --allow-all-tools --deny-tool='shell(rm)' --deny-tool='shell(git push)'
```

Las reglas deny siempre ganan, incluso frente a `--allow-all`. Dentro de una sesión, `/permissions` cambia entre los modos de permiso (`default`, `assisted`, `allow-all`) y `/permissions show` muestra el modo actual; `/sandbox enable` activa el sandbox. `--allow-all` (alias `--yolo`) quita todas las preguntas, así que resérvalo para contenedores desechables. [Seguridad de los agentes de programación con IA](/es/blog/ai-coding-agent-security/ "Seguridad de los agentes de programación con IA") explica por qué.

## Paso 6: uso programático con -p

Para scripts y CI, `-p` ejecuta un prompt y termina. `-s` imprime solo la respuesta, y como no hay nadie para aprobar, permites las herramientas de antemano:

```bash
copilot -p 'Write a commit message in plain text for the staged changes' \
  -s --allow-tool='shell(git:*)'

copilot -p 'Write unit tests for src/utils/validators.ts' \
  --allow-tool='write, shell(npm:*), shell(npx:*)'
```

También puedes pasarle un prompt por una tubería: `echo "Explain this file: ./complex.ts" | copilot`. Extras útiles: `--no-ask-user` impide que Copilot haga preguntas, `--output-format=json` emite líneas JSON y `--share=PATH` guarda la sesión como Markdown. Al final de una ejecución, Copilot imprime una pista `copilot --resume=SESSION-ID` para que puedas continuar en modo interactivo.

En GitHub Actions, pon en `COPILOT_GITHUB_TOKEN` un token con el permiso Copilot Requests:

```yaml
- name: Coverage summary
  env:
    COPILOT_GITHUB_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
  run: copilot -p "Run the test suite and produce a coverage summary" -s --allow-tool='shell(npm:*), write' --no-ask-user
```

## Paso 7: los comandos slash que conviene conocer

| Comando | Qué hace |
| --- | --- |
| `/model` | Elige un modelo, o `auto` |
| `/plan`, `/autopilot` | Planifica primero, o deja que llegue hasta el final |
| `/review` | Revisa los cambios actuales |
| `/diff` | Muestra qué ha cambiado |
| `/undo` (`/rewind`) | Vuelve a un punto anterior |
| `/compact` | Resume la conversación para liberar contexto |
| `/context`, `/usage` | Muestra el uso del contexto y de los créditos |
| `/clear` (`/new`) | Empieza una conversación nueva |
| `/resume` | Continúa una sesión anterior |
| `/pr` | Ve, crea o corrige un pull request |
| `/delegate` | Pasa la tarea a Copilot en GitHub, que abre un pull request |
| `/mcp` | Lista, añade y gestiona servidores MCP |
| `/init` | Crea un archivo de instrucciones personalizadas |
| `/permissions` | Cambia las reglas de aprobación |

Desde la shell, `copilot --resume` (o `--continue` para la sesión más reciente) retoma donde lo dejaste, y `-n NAME` le pone nombre a una sesión para poder retomarla por su nombre.

## Paso 8: elige un modelo

`/model` abre el selector de modelos; `--model=NAME` o la variable de entorno `COPILOT_MODEL` lo fijan al arrancar, y `auto` deja que Copilot elija. `--effort` (o `--reasoning-effort`) fija `low`, `medium`, `high`, `xhigh` o `max` en los modelos que lo admiten. Cada modelo gasta AI Credits a un ritmo distinto, y los contextos largos y el razonamiento más alto cuestan más, así que conviene mirar `/usage` de vez en cuando.

También puedes traer tu propio proveedor de modelos. Fija `COPILOT_PROVIDER_BASE_URL`, `COPILOT_PROVIDER_TYPE` (`openai`, `azure` o `anthropic`), `COPILOT_PROVIDER_API_KEY` y `COPILOT_MODEL`. Funciona con Ollama para modelos locales, siempre que el modelo admita llamadas a herramientas y streaming; GitHub recomienda una ventana de contexto de 128k tokens o más. `copilot help providers` da los detalles.

## Paso 9: añade servidores MCP

El servidor MCP de GitHub ya viene configurado. Para añadir otros, usa la CLI o `/mcp add` en una sesión:

```bash
# a local server started with a command
copilot mcp add my-server -- npx -y @example/mcp-server

# a remote server over HTTP
copilot mcp add --transport http my-remote https://mcp.example.com/mcp
```

Los servidores se guardan en `~/.copilot/mcp-config.json`, y un `.mcp.json` en el repositorio añade servidores para ese proyecto:

```json
{
  "mcpServers": {
    "my-internal-server": {
      "command": "npx",
      "args": ["-y", "@example/mcp-server"],
      "tools": ["*"]
    }
  }
}
```

`tools` decide qué herramientas del servidor puede llamar Copilot; `["*"]` significa todas. `copilot mcp list` muestra lo que está configurado, y `--additional-mcp-config` añade servidores para una sola sesión. ¿Nuevo en MCP? Empieza por [qué es un servidor MCP](/es/blog/what-is-mcp-server/ "Qué es un servidor MCP").

## Paso 10: instrucciones personalizadas

Copilot CLI combina instrucciones de varios sitios:

- `AGENTS.md`, `CLAUDE.md` y `GEMINI.md` en la raíz del repositorio y en la carpeta actual
- `.github/copilot-instructions.md`
- `.github/instructions/**/*.instructions.md`, que se pueden limitar a ciertas rutas con el frontmatter `applyTo:`
- `~/.copilot/copilot-instructions.md` para reglas personales en todos los proyectos

`/init` (o `copilot init`) escribe un `.github/copilot-instructions.md` inicial basado en tu repositorio. Mantenlo corto: comandos de compilación y tests, convenciones y lo que el agente no debe hacer. Si ya tienes un `AGENTS.md` para otros agentes, Copilot lo usará tal cual. [CLAUDE.md y AGENTS.md](/es/blog/claude-md-agents-md/ "CLAUDE.md y AGENTS.md") da consejos para escribir reglas que los agentes de verdad sigan. Para arrancar una sesión sin ninguno de estos archivos, pasa `--no-custom-instructions`.

## Errores habituales

- **Arrancar en tu carpeta de inicio.** Confía solo en el directorio del proyecto; el acceso de Copilot a los archivos sigue a los directorios de confianza.
- **Permitir demasiado en CI.** `--allow-all` en un pipeline con secretos es buscarse problemas. Permite solo las herramientas que necesita el trabajo y deniega `git push` salvo que el trabajo haga push.
- **Olvidar el permiso del token.** Un personal access token sin “Copilot Requests” no se autentica, y los tokens propiedad de una organización no están admitidos.
- **Una sesión interminable.** Las conversaciones largas gastan más créditos. Usa `/compact` o `/clear` entre tareas sin relación.
- **Esperar herramientas MCP sin `tools`.** Una entrada de servidor necesita una lista `tools`; usa `["*"]` para exponerlo todo.

## Copilot CLI en AgentVera

AgentVera es una app de escritorio para macOS, Windows y Linux que ejecuta agentes CLI uno al lado de otro en terminales reales, con tus propias instalaciones e inicios de sesión. Copilot CLI es uno de los agentes que admite; la página de [Copilot CLI en AgentVera](/es/agents/copilot-cli/ "Copilot CLI en AgentVera") tiene los detalles:

- **Tu inicio de sesión de GitHub.** Copilot usa su propio inicio de sesión. Si la sesión está cerrada, ejecuta `/login` en la terminal del agente; basta con una suscripción a Copilot que ya tengas.
- **Modelo y esfuerzo por agente.** El modelo se pasa con `--model`, y el esfuerzo, de minimal a max, con `--reasoning-effort`.
- **Sesiones que vuelven.** Cada agente recibe su propio ID de sesión, y una sesión guardada se vuelve a abrir con `--resume` tras reiniciar. `/compact` funciona como siempre.
- **MCP sin editar la configuración.** Los servidores del [gestor de MCP](/es/features/mcp-manager/ "Gestor de MCP") de AgentVera y de su explorador se añaden con `--additional-mcp-config` en cada arranque, así que tu `mcp-config.json` queda intacto. El rol del agente se añade como una carpeta de instrucciones adicional.
- **Paneles, worktrees y revisión.** Ejecuta Copilot en la cuadrícula del [workspace](/es/features/workspace/ "Workspace") junto a Claude Code o Aider, dale a cada agente su propio worktree desde el [panel Git](/es/features/git-and-github/ "Git y GitHub") y recibe [revisión de código automática](/es/features/code-review/ "Revisión de código") al final de cada turno. Los agentes Copilot también funcionan en flujos (Pro y Team), envíos a varios agentes y tareas programadas.

La cuadrícula, los worktrees, la revisión de código y el gestor de MCP están en el plan gratuito. [Descarga AgentVera](/es/download/ "Descargar AgentVera") para probarlo.

## Conclusión

Instala Copilot CLI, ejecuta `copilot` en tu proyecto, marca la carpeta como de confianza e inicia sesión con `/login`. Planifica los cambios grandes con Shift+Tab o `/plan`, permite solo las herramientas con las que te sientas cómodo y usa `copilot -p` con reglas `--allow-tool` explícitas para scripts y CI. Pon tus reglas en `AGENTS.md` o `.github/copilot-instructions.md` y añade servidores MCP cuando los necesites. Si además quieres un agente centrado en git que funcione con cualquier modelo, lee [cómo usar Aider](/es/blog/how-to-use-aider/ "Cómo usar Aider").

## Preguntas frecuentes

**¿Necesito un plan de pago para usar Copilot CLI?** No. A octubre de 2026, GitHub indica que todos los planes de Copilot incluyen Copilot CLI, también Copilot Free y Copilot Student. Free trae una asignación limitada de GitHub AI Credits; Pro, Pro+, Max, Business y Enterprise incluyen más. Si tienes Copilot a través de una organización, un administrador puede desactivar la CLI.

**¿Cómo inicio sesión en Copilot CLI?** Ejecuta copilot y escribe /login, o ejecuta copilot login desde tu shell. Se abre un inicio de sesión en el navegador con tu cuenta de GitHub. Para scripts y CI puedes poner en COPILOT_GITHUB_TOKEN un personal access token fine-grained con el permiso Copilot Requests.

**¿Cómo evito que Copilot CLI pida aprobación cada vez?** Cuando pregunte, elige “Yes, and approve for the rest of the session”, o permite herramientas concretas de antemano con --allow-tool, por ejemplo --allow-tool='shell(git:*)'. --allow-all quita todas las preguntas, lo cual es arriesgado fuera de un sandbox o un contenedor. Una regla --deny-tool siempre gana a una regla allow.

**¿Copilot CLI puede usar modelos que no sean de GitHub?** Sí. Además de los modelos de /model, Copilot CLI admite proveedores con tu propia key. Fija COPILOT_PROVIDER_BASE_URL, COPILOT_PROVIDER_TYPE, COPILOT_PROVIDER_API_KEY y COPILOT_MODEL para usar un endpoint compatible con OpenAI, Azure o Anthropic, incluido un modelo local a través de Ollama.

**¿Dónde pongo las instrucciones del proyecto para Copilot CLI?** En .github/copilot-instructions.md o en AGENTS.md en la raíz del repositorio. Copilot CLI también lee CLAUDE.md, GEMINI.md y los archivos de .github/instructions/. Las reglas personales van en ~/.copilot/copilot-instructions.md. Ejecuta /init para generar un archivo inicial.

---

**Sobre AgentVera.** AgentVera es una app de escritorio para macOS, Windows y Linux, desarrollada por Solviera Teknoloji. Ejecuta 18 agentes de programación con IA (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) en paralelo, por proyecto, en terminales reales con las instalaciones y sesiones de CLI del propio usuario. El plan gratuito tiene agentes ilimitados. Descargar: https://agentvera.dev/es/download/ · Precios: https://agentvera.dev/es/pricing/