Si pasas horas peleándote con errores, mensajes crípticos y salidas que no cuadran, GitHub Copilot puede convertirse en tu compañero de depuración de confianza. No solo sugiere código, también te ayuda a entender qué falla, dónde y cómo arreglarlo, tanto en proyectos sencillos como en soluciones complejas.
A lo largo de este artículo verás cómo crear y depurar scripts con Copilot en distintos entornos (Visual Studio, VS Code, Edge DevTools y Copilot Studio), qué tipos de errores puede detectar, cómo hablarle con buenos prompts y qué trucos prácticos puedes aplicar para sacarle todo el jugo sin perder el control sobre tu código.
Qué es Copilot y por qué es tan útil para crear y depurar scripts
GitHub Copilot es un asistente de programación basado en inteligencia artificial desarrollado por GitHub y OpenAI, pensado para trabajar embebido en tu IDE o editor: Visual Studio, VS Code, JetBrains, Vim/Neovim e incluso el navegador a través de Edge y GitHub Codespaces.
La gracia de Copilot no es solo autocompletar trozos de código: entiende el contexto de tu proyecto, la pila de llamadas, las variables y los errores. Gracias a Copilot Chat y a comandos específicos como /fix, /explain o /tests, puedes pedirle que:
- Genere nuevos scripts desde cero (por ejemplo, una API con FastAPI, un script de automatización en Python o Office Scripts en Excel Web).
- Explique código heredado o de librerías externas que no conoces bien.
- Depure excepciones y salidas erróneas, proponiendo correcciones concretas sobre el archivo afectado.
- Refactorice y añada pruebas para que tu base de código sea más robusta y mantenible.
Además, Microsoft ofrece un plan gratuito de GitHub Copilot que incluye miles de sugerencias de código y mensajes de chat al mes, soporte para diferentes modelos (como GPT-4o o Claude 3.5 Sonnet) y compatibilidad con el ecosistema de extensiones de Copilot, lo que facilita empezar a usarlo sin coste inicial.
Primeros pasos: instalar y arrancar Copilot en tu entorno
Antes de ponerte a crear y depurar scripts con ayuda de la IA, necesitas tener Copilot correctamente instalado e integrado en tu editor. El proceso varía un poco según la herramienta, pero la idea general es similar.
Configurar GitHub Copilot en Visual Studio Code
En VS Code, Copilot funciona como una extensión más. Para dejarlo listo, abre VS Code y ve a la vista de extensiones (icono de bloques en la barra lateral o atajo Ctrl+Shift+X / Cmd+Shift+X en macOS).
En el buscador escribe «GitHub Copilot» y selecciona la extensión oficial de GitHub. Haz clic en Instalar, espera a que se complete y reinicia el editor para que se activen todas las funcionalidades del complemento.
Una vez de vuelta en el editor, verás que Copilot empieza a sugerir código en gris claro mientras escribes, y podrás abrir Copilot Chat desde la barra lateral para lanzar prompts, explicar errores o pedir refactorizaciones completas de tus scripts.
Activar Copilot en Visual Studio
En Visual Studio (a partir de la versión 17.8) Copilot se integra aún más con el depurador clásico. Nada más abrir el IDE, localiza la insignia de GitHub Copilot en la esquina superior derecha de la ventana.
Si todavía no lo tienes instalado, el propio menú te mostrará la opción Instalar Copilot. Al hacer clic se abrirá el instalador de Visual Studio para añadir la extensión y, tras unos minutos, podrás iniciar sesión con tu cuenta de GitHub o registrarte en la capa gratuita directamente desde la ventana de chat.
Cuando hayas iniciado sesión, Copilot se activa en varios frentes: finalizaciones inline dentro del editor, ventana de Copilot Chat, acciones contextuales en menús (como “Preguntar a Copilot” sobre una línea o una excepción) y sugerencias integradas en la lista de errores y otras zonas del IDE.
Otros entornos: Edge DevTools, Codespaces y JetBrains
Copilot también aparece en otros sitios menos evidentes pero muy útiles para depuración:
- En Microsoft Edge DevTools puedes pedirle que explique el código fuente JavaScript que estás inspeccionando, directamente desde la pestaña Orígenes.
- En GitHub Codespaces dispones de una experiencia similar a VS Code en el navegador, con Copilot generando y corrigiendo scripts sin necesidad de instalar nada localmente.
- En los IDE de JetBrains (IntelliJ, PyCharm, WebStorm, etc.) Copilot se integra como plugin y ofrece sugerencias de código parecidas a las de VS Code, además de chat contextual.
En todos los casos, la lógica es la misma: inicias sesión con GitHub, autorizas Copilot y a partir de ahí puedes usarlo para escribir y depurar código con distintos niveles de integración según el entorno.
Depurar scripts con Copilot en Visual Studio
Donde más brilla la integración de Copilot con el depurador clásico es en Visual Studio. Aquí la IA entiende la pila de llamadas, los marcos de ejecución y los valores actuales de las variables, por lo que puede darte respuestas muy específicas sobre el error que estás viendo.
Ejemplo: depurar un script C# paso a paso
Imagina que creas una aplicación de consola en C# muy simple en Visual Studio. Desde la pantalla inicial eliges “Crear un proyecto nuevo”, seleccionas Aplicación de consola para .NET, indicas el nombre (por ejemplo, ConsoleApp_Copilot) y dejas el marco de destino recomendado.
En el archivo Program.cs pegas un código como este, donde intencionadamente hay errores de ejecución:
using System;
using System.Collections.Generic;
public class Example
{
public static void Main(string[] args)
{
int value = Int32.Parse(args);
List<string> names = null;
if (value > 0)
names = new List<string>();
names.Add("Major Major Major");
}
}Lo primero es poner un punto de interrupción en la línea que parsea los argumentos (Int32.Parse(args)). Ejecutas el script con F5, la aplicación se detiene en el breakpoint y ves en la ventana Autos que args es un array vacío (string), lo que sugiere un fallo de uso del programa.
En lugar de ponerte a probar a mano, haces clic derecho sobre el código y eliges “Preguntar a Copilot”. En el chat inline puedes escribir una pregunta del estilo: Why does the args variable have a value of string?. Copilot responde basándose en el contexto actual: sabe qué línea está ejecutándose, ve el valor de args y entiende que no se han pasado argumentos en la línea de comandos.
Además de explicarte el motivo del error, Copilot puede sugerir modificaciones concretas al script, por ejemplo añadiendo una validación previa que compruebe la longitud de args antes de intentar acceder a args, o proponiendo valores por defecto.
Gestión de excepciones con ayuda de la IA
Siguiendo con el mismo ejemplo, si pulsas F11 para ejecutar paso a paso, llegará el momento en que se produce una IndexOutOfRangeException o una NullReferenceException (dependiendo de cómo ejecutes el programa y qué valor se le haya asignado a names).
Cuando Visual Studio se detiene en la excepción, aparece un botón específico de “Preguntar a Copilot” en la tarjeta de error. Al pulsarlo, se abre la ventana de chat con una explicación detallada: por qué se ha lanzado la excepción, en qué línea exacta y qué cambios sugiere Copilot para evitarla en futuras ejecuciones.
En muchos casos Copilot añadirá una corrección preliminar de código que puedes previsualizar con un botón de Vista previa. Si revisas la propuesta y te encaja, solo tienes que hacer clic en Aceptar para aplicar el cambio directamente en el archivo.
Tras esto, reinicias el depurador y compruebas que, con los argumentos adecuados y las comprobaciones añadidas, la excepción ya no se produce y el script funciona como esperabas.
Copilot y puntos de interrupción condicionales / puntos de seguimiento
Otro aspecto interesante es que Copilot puede sugerir condiciones inteligentes para tus breakpoints, algo especialmente útil cuando trabajas con bucles y listas.
Siguiendo el ejemplo anterior, modifica la parte final del código C# para que recorra los argumentos y construya la lista de nombres:
// names.Add("Major Major Major");
foreach (var item in args)
{
names.Add("Name: " + item);
}Ahora, al hacer clic derecho en el margen junto a la línea names.Add("Name: " + item), eliges “Insertar punto de interrupción condicional”. En cuanto el cursor entra en el cuadro de expresión, Copilot empieza a proponer condiciones como item == "John".
Puedes aceptar una sugerencia y adaptarla a tu caso, por ejemplo cambiando el valor a "Fred". Cuando ejecutas la aplicación pasando argumentos como 5 Fred Joe desde la configuración de depuración, el depurador se detendrá solo cuando el valor de item sea «Fred», justo la situación que quieres inspeccionar.
Depuración de scripts en VS Code con Copilot: errores visibles y salidas incorrectas
En VS Code, Copilot también es muy potente a la hora de depurar scripts, especialmente en lenguajes como Python o JavaScript, donde los errores de tipo y lógica son frecuentes. Aquí es clave distinguir entre dos escenarios: errores con traza clara y errores “silenciosos” donde la salida no coincide con lo esperado.
Cuando el script se rompe: mensajes de error y excepciones
Supón que trabajas con un repositorio de ejemplo (por ejemplo, new2code/debug-with-copilot) que contiene un archivo bugged_dice_battle.py, un pequeño juego de dados. Tras clonar el repo en VS Code y abrirlo, ejecutas el archivo desde la terminal integrada.
Al lanzar el script, la ejecución termina con un error similar a: TypeError: solo puede concatenar str (no «int») a str. Es decir, en algún punto se está intentando concatenar números enteros a cadenas sin convertirlos antes.
Para no perder tiempo buscando a mano, abres Copilot Chat en VS Code, copias el mensaje de error o el fragmento de código sospechoso y le planteas una pregunta directa, por ejemplo: “¿Por qué se produce este TypeError en este script y cómo lo soluciono?”.
Copilot revisa el contexto (el archivo abierto, la línea donde se lanza la excepción) y responde señalando que se están concatenando los enteros die_1 y die_2 directamente a una cadena. Te propone una versión corregida del código, donde envuelve esos enteros con str() antes de concatenarlos.
Aplicando la sugerencia y volviendo a ejecutar el script, el error desaparece y la batalla de dados funciona correctamente. Has usado Copilot como un “traductor” del mensaje de error a causa concreta y solución práctica.
Cuando el script no falla pero la salida es absurda
El segundo gran escenario de depuración es cuando tu script se ejecuta sin lanzar errores, pero el resultado no se parece en nada a lo que esperabas. Es lo típico en algoritmos mal planteados o cálculos lógicos.
En el mismo repositorio de ejemplo encuentras bugged_factorial_finder.py, que supuestamente calcula el factorial de un número. Lo ejecutas desde la terminal con un valor como 6 y, en lugar de 720, devuelve un número astronómico.
Abres Copilot Chat y planteas una pregunta muy concreta, incluyendo el archivo completo o las líneas relevantes: “Analiza este script factorial y dime por qué el resultado para 6 es incorrecto y cómo corregirlo”.
Copilot te explica que el problema está en el uso de un operador como *= mezclado con la variable factorial dentro del bucle. En la práctica, el código está multiplicando por factorial de más en cada iteración, de ahí el valor disparado.
La IA propone una implementación correcta del bucle, ya sea quitando el segundo factorial de la expresión o cambiando el operador a = con una fórmula correcta. Una vez cambias el código y vuelves a ejecutar, obtienes 720, confirmando que la lógica ya es la adecuada.
Tipos de errores que Copilot te ayuda a localizar y corregir
Uno de los puntos fuertes de Copilot es que puedes usarlo como asistente genérico de depuración para diferentes tipos de fallos, no solo sintaxis rota. Entender esa clasificación te ayuda a formular mejores prompts y aprovechar mejor sus respuestas.
Errores léxicos: caracteres y tokens imposibles
Los errores léxicos son los más básicos: el compilador o intérprete ni siquiera reconoce lo que has escrito. Puede ser un símbolo extraño, una palabra clave mal tecleada o una cadena sin cerrar.
Un ejemplo típico sería algo como: prin en lugar de print.
def saludo():
prin("Hola mundo") # 'prin' no está definidoSi seleccionas la línea problemática y lanzas en Copilot Chat un comando como /fix, la IA detectará que prin probablemente es un typo de print y sugerirá la corrección directamente sobre el fragmento.
Errores sintácticos: la gramática del lenguaje está rota
Aquí el problema no son los caracteres en sí, sino la estructura del código: paréntesis sin cerrar, bloques mal indentados, funciones definidas de forma incorrecta, etc. El intérprete te da un error de sintaxis, pero no siempre es obvio qué sobra o qué falta.
Copilot es útil si acompañas el código con comentarios claros sobre lo que quieres que haga. Por ejemplo, puedes escribir encima de una función “# Calcula el área de un círculo” y luego pedirle a Copilot, con /fix o con un prompt natural, que reescriba la función con la sintaxis correcta.
Errores semánticos: el código compila pero piensa mal
Son los más traicioneros: el código se ejecuta, pero la lógica no hace lo que debería. Por ejemplo, una función que debería calcular una media y en realidad multiplica en lugar de dividir.
def calcular_promedio(lista):
return sum(lista) * len(lista)
# Debería dividir entre len(lista), no multiplicarAquí Copilot te puede ayudar si le explicas tu intención: “Esta función debería devolver el promedio de una lista de números, ¿qué está mal?”. El modelo analiza el comentario, compara con la lógica implementada y propone una versión corregida con sum(lista) / len(lista), además de sugerir casos de prueba.
Errores en tiempo de ejecución: índices fuera de rango, divisiones por cero y compañía
Finalmente están los errores que solo aparecen al ejecutar el script: IndexError, ZeroDivisionError, NullReferenceException y similares. Copilot es especialmente útil aquí porque puedes pegarle directamente el mensaje de error y el bloque de código asociado.
Por ejemplo: casos sencillos que provocan IndexError
def obtener_elemento(lista):
return lista
obtener_elemento() # Provocará IndexErrorSi copias la traza y el fragmento en Copilot Chat y le pides “Haz que esta función no falle si el índice está fuera de rango”, te sugerirá envolver la operación en un try/except, comprobar la longitud de la lista antes de acceder o devolver un valor por defecto cuando el índice no exista.
Prompts efectivos para que Copilot depure de verdad (y no adivine)
Para que Copilot sea realmente útil al depurar scripts, no basta con pegar errores sin más. La calidad del contexto que le des marca la diferencia entre una respuesta genérica y una corrección prácticamente lista para aceptar.
Dar contexto de intención y comportamiento esperado
En lugar de limitarte a escribir “Arregla esto”, intenta explicar qué se supone que debe ocurrir. Comentarios como “Esta función debería devolver el factorial de un entero positivo” o “Este endpoint debe responder con código 200 y un JSON con la lista de productos” ayudan muchísimo al modelo.
Combinado con archivos añadidos como contexto (en VS Code puedes usar el botón “Add Context…” en Copilot Chat), la IA entiende mejor la arquitectura de tu script y propone cambios coherentes con el resto del proyecto.
Usar comandos /fix, /explain, /tests y /edit
En entornos como VS Code y Codespaces dispones de slash commands que predisponen a Copilot a cierta tarea:
- /fix para que busque y solucione errores en el código seleccionado.
- /explain si lo que quieres es comprender primero qué hace un script o por qué falla.
- /tests para generar casos de prueba unitarios o de integración basados en un fragmento concreto.
- /edit cuando necesitas que reescriba o refactorice un bloque siguiendo una instrucción clara.
Estos comandos, combinados con un prompt bien pensado, permiten que Copilot pase de ser un autocompletado glorificado a un verdadero compañero de depuración.
Crear y depurar un script de chatbot con FastAPI y la API de OpenAI usando Copilot
Veamos un ejemplo algo más completo, donde Copilot nos ayuda tanto a crear como a depurar un script real: un endpoint de chat usando FastAPI y la API de OpenAI. Es un caso muy típico cuando quieres montar un backend que hable con modelos de lenguaje.
Generar el esqueleto del script con Copilot
En un proyecto de Python, creas un archivo, por ejemplo main.py, y añades un comentario en la parte superior que describa lo que quieres hacer, algo como: «# Developing a simple chatbot using the OpenAI API and FastAPI».
Con solo empezar a escribir los primeros import, Copilot suele proponer el esqueleto completo del script, algo del estilo:
import os
from openai import OpenAI
from fastapi import FastAPI, HTTPException
from fastapi.params import Body
from dotenv import load_dotenv
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
app = FastAPI()
@app.post("/chat")
async def chat(user_message: str = Body(..., embed=True)):
try:
response = client.chat.completions.create(
model="gpt-4",
messages=,
temperature=0.7,
max_tokens=100,
)
return {"response": response.choices.message.content}
except Exception as e:
raise HTTPException(status_code=500, detail=str(e))Si algo de la sintaxis no te cuadra, puedes seleccionar el bloque y pedir a Copilot con /explain que te detalle qué hace cada parte: carga de variables de entorno, inicialización del cliente de OpenAI, definición del endpoint y manejo de errores.
Depurar errores de configuración y de ejecución en el endpoint
Lo normal es que la primera vez que ejecutes este script aparezcan problemas: variables de entorno sin definir, versiones de librerías incompatibles, o errores en la llamada a la API de OpenAI.
Cuando veas un traceback en la terminal del estilo “openai.error.AuthenticationError” o errores de importación, copia la traza junto con la función chat y plantea una pregunta del tipo: “Esta ruta FastAPI lanza este error de autenticación con OpenAI, ¿qué me falta configurar?”.
Copilot suele detectar rápidamente que la variable OPENAI_API_KEY no está definida o no se carga correctamente desde el archivo .env, y te sugiere crear ese archivo, añadir la clave y comprobar que load_dotenv() se está llamando al inicio del script.
Si más adelante quieres mejorar el manejo de errores, puedes pedirle: “Refactoriza este endpoint para capturar mejor los errores de red y devolver mensajes más claros al cliente”. La IA propondrá bloques try/except más específicos, uso de códigos HTTP adecuados y quizá la extracción de la llamada a OpenAI a una función auxiliar para facilitar las pruebas.
Depurar agentes de Microsoft 365 Copilot con Copilot Studio
Más allá del código clásico, también puedes usar Copilot para probar y depurar agentes declarativos en Microsoft 365 mediante Copilot Studio. Aquí la clave está en el llamado modo de desarrollador.
Cuando escribes -developer on dentro de una sesión de Copilot, se activa un modo especial en el que el orquestador muestra tarjetas de información de depuración cada vez que tiene que decidir qué conocimiento o acciones de tu agente utilizar para responder.
En esas tarjetas verás varios bloques:
- Metadatos del agente: identificadores y versión del agente, id de conversación y de solicitud.
- Funcionalidades y acciones configuradas: qué fuentes de conocimiento y qué acciones están disponibles.
- Funciones coincidentes y seleccionadas: qué acciones detecta el orquestador como relevantes para el prompt y cuáles decide ejecutar.
- Detalles de ejecución: resultados, tiempos de respuesta, errores de mapping de parámetros o timeouts de tus APIs.
Con esta información puedes identificar, por ejemplo, que ninguna función coincide con la intención del usuario porque la descripción del comando no es clara, o que una acción falla sistemáticamente porque el endpoint HTTP está mal configurado.
Cuando hayas terminado de depurar, puedes desactivar este modo con -developer off para volver a una experiencia de usuario más limpia sin tarjetas de depuración en cada mensaje.
Depurar JavaScript en el navegador: DevTools y Copilot en Edge
Otro escenario muy práctico es cuando quieres depurar scripts JavaScript directamente en el navegador. Microsoft Edge, combinado con DevTools y Copilot, ofrece algunas comodidades interesantes.
Desde la pestaña Orígenes puedes abrir los archivos JS de tu web, modificarlos al vuelo y ver los cambios sin tener que reempaquetar y desplegar. Para entender mejor ciertas secciones, cuentas con la función “Explicar estas líneas de código” integrada con Copilot en Edge, que te devuelve una explicación en lenguaje natural del bloque seleccionado.
Además, DevTools te deja:
- Formatear archivos minificados con el botón de “bonito” para hacerlos legibles.
- Definir puntos de interrupción de línea, de evento, condicionales, etc., para pausar la ejecución justo donde te interesa.
- Recorrer el código paso a paso (step over, step into, step out) mientras inspeccionas variables y ámbitos.
- Editar propiedades y expresiones de inspección para probar hipótesis de depuración sin cambiar aún el código fuente.
Si combinas todo esto con Copilot (pidiéndole que te explique funciones complicadas o sugerencias de manejo de errores), tienes un entorno muy completo para depurar scripts del lado cliente sin abandonar el navegador.
Buenas prácticas, calidad del código y propiedad intelectual al trabajar con Copilot
Copilot puede acelerar muchísimo tu flujo de trabajo, pero no deja de ser una herramienta estadística que a veces se equivoca o propone soluciones subóptimas. Conviene usarlo con ciertos criterios para no bajar el listón de calidad.
Por un lado, es recomendable mantener tus propias normas de revisión de código. Aunque Copilot genere una función entera o una batería de pruebas, sigue siendo tu responsabilidad revisarlas, pasar linters, ejecutar tests y asegurarte de que el resultado encaja con la arquitectura del proyecto.
Por otro, existe la cuestión de la propiedad intelectual. El modelo está entrenado sobre grandes cantidades de código público, y aunque normalmente sintetiza soluciones originales, en raras ocasiones puede producir fragmentos muy parecidos a código existente. GitHub ofrece opciones para controlar las sugerencias que coinciden con código público y detallar posibles orígenes cuando las aceptas, pero la decisión final sobre uso y atribución recae en ti o en tu organización.
La forma más sensata de usar Copilot es tratarlo como un compañero de pares muy rápido y versátil: genera propuestas, ayuda a depurar, sugiere pruebas y refactorizaciones, pero siempre con una capa de criterio humano por encima que decide qué entra en el repositorio.
Con todos estos recursos sobre la mesa, Copilot se convierte en algo más que un simple autocompletado: es una herramienta transversal que te acompaña desde la creación del primer script hasta la depuración de errores sutiles en producción, tanto en escritorio como en la nube. Si aprovechas bien el contexto, usas prompts claros y mantienes tus estándares de revisión, podrás escribir y depurar scripts más rápido, con menos frustración y con una sensación muy agradable de tener “un senior” ayudándote a un par de teclas de distancia.
