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

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 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 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.

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 profundiza en los créditos y los precios.

Paso 2: instala Copilot CLI

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

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:

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:

/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):

# 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 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:

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:

- 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

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:

# 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:

{
  "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.

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 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 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 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 junto a Claude Code o Aider, dale a cada agente su propio worktree desde el panel Git y recibe revisión de código automática 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 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.