Si passes hores barallant-te amb errors, missatges críptics i sortides que no quadren, GitHub Copilot es pot convertir en el teu company de depuració de confiança. No només suggereix codi, també us ajuda a entendre què falla, on i com arreglar-lo, tant en projectes senzills com en solucions complexes.
Durant aquest article veuràs com crear i depurar scripts amb Copilot a diferents entorns (Visual Studio, VS Code, Edge DevTools i Copilot Studio), quins tipus d'errors pot detectar, com parlar-li amb bons prompts i quins trucs pràctics pots aplicar per treure-li tot el suc sense perdre el control sobre el teu codi.
Què és Copilot i per què és tan útil per crear i depurar scripts
GitHub Copilot és un assistent de programació basat en intel·ligència artificial desenvolupat per GitHub i OpenAI, pensat per treballar embegut al teu IDE o editor: Visual Studio, VS Code, JetBrains, Vim/Neovim i fins i tot el navegador a través d'Edge i GitHub Codespaces.
La gràcia de Copilot no és només autocompletar trossos de codi: entén el context del teu projecte, la pila de trucades, les variables i els errors. Gràcies a Copilot Xat ia ordres específiques com / arreglar, /explicar o /proves, pots demanar-li que:
- Genereu nous scripts des de zero (per exemple, una API amb FastAPI, un script d'automatització a Python o Office Scripts a Excel Web).
- Expliqueu codi heretat o de llibreries externes que no coneixes bé.
- Depure excepcions i sortides errònies, proposant correccions concretes sobre el fitxer afectat.
- Refactoritzi i afegeixi proves perquè la teva base de codi sigui més robusta i mantenible.
A més, Microsoft ofereix un pla gratuït de GitHub Copilot que inclou milers de suggeriments de codi i missatges de xat al mes, suport per a diferents models (com GPT-4o o Claude 3.5 Sonnet) i compatibilitat amb l'ecosistema d'extensions de Copilot, cosa que facilita començar a fer-lo servir sense cost inicial.
Primers passos: instal·lar i arrencar Copilot al teu entorn
Abans de posar-te a crear i depurar scripts amb ajuda de la IA, necessites tenir Copilot correctament instal·lat i integrat al teu editor. El procés varia una mica segons l'eina, però la idea general és semblant.
Configurar GitHub Copilot al Visual Studio Code
A VS Code, Copilot funciona com una extensió més. Per deixar-ho llest, obre VS Code i vés a la vista d'extensions (icona de blocs a la barra lateral o drecera Ctrl+Shift+X / Cmd+Shift+X a macOS).
Al cercador escriu GitHub Copilot i seleccioneu l'extensió oficial de GitHub. Fes clic a instal·lar, espera que es completi i reiniciï l'editor perquè s'activin totes les funcionalitats del complement.
Un cop de tornada a l'editor, veuràs que Copilot comença a suggerir codi en gris clar mentre escrius, i podràs obrir Copilot Xat des de la barra lateral per llançar prompts, explicar errors o demanar refactoritzacions completes dels teus scripts.
Activar Copilot al Visual Studio
A Visual Studio (a partir de la versió 17.8) Copilot s'integra encara més amb el depurador clàssic. Només obrir l'IDE, localitza la insígnia de GitHub Copilot a la cantonada superior dreta de la finestra.
Si encara no el teniu instal·lat, el mateix menú us mostrarà l'opció Instal·lar Copilot. En fer clic s'obrirà l'instal·lador de Visual Studio per afegir l'extensió i, després d'uns minuts, podreu iniciar sessió amb el vostre compte de GitHub o registrar-vos a la capa gratuïta directament des de la finestra de xat.
Quan hagis iniciat sessió, Copilot s'activa en diversos fronts: finalitzacions inline dins de l'editor, finestra de Copilot Chat, accions contextuals a menús (com “Preguntar a Copilot” sobre una línia o una excepció) i suggeriments integrats a la llista d'errors i altres zones de l'IDE.
Altres entorns: Edge DevTools, Codespaces i JetBrains
Copilot també apareix a altres llocs menys evidents però molt útils per a depuració:
- En Microsoft Edge DevTools pots demanar-li que expliqui el codi font JavaScript que estàs inspeccionant, directament des de la pestanya Orígens.
- En Espais de codi de GitHub disposes d'una experiència similar a VS Code al navegador, amb Copilot generant i corregint scripts sense necessitat d'instal·lar res localment.
- Als IDE de JetBrains (IntelliJ, PyCharm, WebStorm, etc.) Copilot s'integra com a plugin i ofereix suggeriments de codi semblants als de VS Code, a més de xat contextual.
En tots els casos, la lògica és la mateixa: inicies sessió amb GitHub, autoritzes Copilot ia partir d'aquí pots fer-lo servir per escriure i depurar codi amb diferents nivells dintegració segons lentorn.
Depurar scripts amb Copilot al Visual Studio
On més brilla la integració de Copilot amb el depurador clàssic és a Visual Studio. Aquí la IA entén la pila de trucades, els marcs d'execució i els valors actuals de les variables, de manera que pot donar respostes molt específiques sobre l'error que estàs veient.
Exemple: depurar un script C# pas a pas
Imagina que en crees una aplicació de consola a C# molt simple a Visual Studio. Des de la pantalla inicial tries “Crear un projecte nou”, selecciones Aplicació de consola per a .NET, indiqueu el nom (per exemple, ConsoleApp_Copilot) i deixeu el marc de destinació recomanat.
A l'arxiu Program.cs pegues un codi com aquest, on intencionadament hi ha errors d'execució:
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");
}
}El primer és posar un punt d'interrupció a la línia que parseja els arguments (Int32.Parar-se(args)). Executes l'script amb F5, l'aplicació s'atura al breakpoint i veus a la finestra Autos que args és un array buit (string), el que suggereix una fallada dús del programa.
En lloc de posar-te a provar a mà, fes clic dret sobre el codi i tries “Preguntar a Copilot”. Al xat inline pots escriure una pregunta de l'estil: Why does the args variable have a value of string?. Copilot respon basant-se en el context actual: sap quina línia s'està executant, veu el valor de args i entén que no s'han passat arguments a la línia d'ordres.
A més d'explicar-te el motiu de l'error, Copilot pot suggerir modificacions concretes a l'script, per exemple afegint una validació prèvia que comprovi la longitud de args abans d'intentar accedir a args, o proposant valors per defecte.
Gestió d'excepcions amb ajut de la IA
Seguint amb el mateix exemple, si prems F11 per executar pas a pas, arribarà el moment en què es produeix una IndexOutOfRangeException o una NullReferenceException (depenent de com executis el programa i quin valor se li hagi assignat a names).
Quan Visual Studio s'atura a l'excepció, apareix un botó específic de “Preguntar a Copilot” a la targeta derror. En prémer-ho, s'obre la finestra de xat amb una explicació detallada: per què s'ha llançat l'excepció, a quina línia exacta i quins canvis suggereix Copilot per evitar-la en futures execucions.
En molts casos Copilot afegirà una correcció preliminar de codi que podeu previsualitzar amb un botó de Vista prèvia. Si revises la proposta i t'encaixa, només has de fer clic a Acceptar per aplicar el canvi directament al fitxer.
Després d'això, reinicieu el depurador i comproveu que, amb els arguments adequats i les comprovacions afegides, l'excepció ja no es produeix i l'script funciona com esperaves.
Copilot i punts d'interrupció condicionals/punts de seguiment
Un altre aspecte interessant és que Copilot pot suggerir condicions intel·ligents per als teus breakpoints, una cosa especialment útil quan treballes amb bucles i llistes.
Seguint l'exemple anterior, modifica la part final del codi C# perquè recorri els arguments i construïu la llista de noms:
// names.Add("Major Major Major");
foreach (var item in args)
{
names.Add("Name: " + item);
}Ara, en fer clic dret al marge al costat de la línia names.Add("Name: " + item), tries Inserir punt d'interrupció condicional. Quan el cursor entra al quadre d'expressió, Copilot comença a proposar condicions com a item == "John".
Pots acceptar un suggeriment i adaptar-lo al teu cas, per exemple canviant el valor a "Fred". Quan executes l'aplicació passant arguments com 5 Fred Joe des de la configuració de depuració, el depurador s'aturarà només quan el valor d'item sigui Fred, just la situació que vols inspeccionar.
Depuració de scripts a VS Code amb Copilot: errors visibles i sortides incorrectes
A VS Code, Copilot també és molt potent a l'hora de depurar scripts, especialment en llenguatges com Python o JavaScript, on els errors de tipus i lògica són freqüents. Aquí és clau distingir entre dos escenaris: errors amb traça clara y errors “silenciosos” on la sortida no coincideix amb allò esperat.
Quan es trenca l'script: missatges d'error i excepcions
Suposa que treballes amb un repositori d'exemple (per exemple, new2code/debug-with-copilot) que conté un fitxer bugged_dice_battle.py, un petit joc de daus. Després de clonar el repo a VS Code i obrir-lo, executes el fitxer des de la terminal integrada.
En llançar l'script, l'execució acaba amb un error semblant a: TypeError: només pot concatenar str (no int) a str. És a dir, en algun punt s'està intentant concatenar números sencers a cadenes sense convertir-los abans.
Per no perdre temps buscant a mà, obres Copilot Xat a VS Code, copieu el missatge d'error o el fragment de codi sospitós i us plantegeu una pregunta directa, per exemple: “Per què es produeix aquest TypeError en aquest script i com ho soluciono?".
Copilot revisa el context (l'arxiu obert, la línia on es llença l'excepció) i respon assenyalant que s'estan concatenant els sencers die_1 y die_2 directament a una cadena. Et proposa una versió corregida del codi, on envolta aquests sencers amb str() abans de concatenar-los.
Aplicant el suggeriment i tornant a executar l'script, l'error desapareix i la batalla de daus funciona correctament. Has fet servir Copilot com un “traductor” del missatge d'error a causa concreta i solució pràctica.
Quan l'script no falla però la sortida és absurda
El segon gran escenari de depuració és quan el teu script sexecuta sense llançar errors, però el resultat no s'assembla gens al que esperaves. És el típic en algoritmes mal plantejats o càlculs lògics.
Al mateix repositori d'exemple trobes bugged_factorial_finder.py, que suposadament calcula el factorial d'un nombre. L'executes des de la terminal amb un valor com a 6 i, en lloc de 720, torna un nombre astronòmic.
Obres Copilot Xat i planteges una pregunta molt concreta, incloent-hi l'arxiu complet o les línies rellevants: “Analitza aquest script factorial i digues-me per què el resultat per a 6 és incorrecte i com corregir-ho".
Copilot t'explica que el problema està en l'ús d'un operador com *= barrejat amb la variable factorial dins del bucle. A la pràctica, el codi està multiplicant per factorial de més en cada iteració, per això el valor disparat.
La IA proposa una implementació correcta del bucle, ja sigui traient el segon factorial de l'expressió o canviant l'operador a = amb una fórmula correcta. Un cop canvies el codi i tornes a executar-ne, obtens 720, confirmant que la lògica ja és l'adequada.
Tipus d'errors que Copilot us ajuda a localitzar i corregir
Un dels punts forts de Copilot és que pots fer-lo servir com assistent genèric de depuració per a diferents tipus de fallades, no només sintaxi trencada. Entendre aquesta classificació t'ajuda a formular millors prompts i aprofitar-ne millor les respostes.
Errors lèxics: caràcters i tokens impossibles
Els errors lèxics són els més bàsics: el compilador o intèrpret ni tan sols reconeix el que has escrit. Pot ser un símbol estrany, una paraula clau mal teclejada o una cadena sense tancar.
Un exemple típic seria una cosa com: a través en lloc de print.
def saludo():
prin("Hola mundo") # 'prin' no está definidoSi selecciones la línia problemàtica i llances a Copilot Xat una ordre com / arreglar, la IA detectarà que prin probablement és un typ de print i suggerirà la correcció directament sobre el fragment.
Errors sintàctics: la gramàtica del llenguatge està trencada
Aquí el problema no són els caràcters en si, sinó l'estructura del codi: parèntesis sense tancar, blocs mal indentats, funcions definides de forma incorrecta, etc. L'intèrpret et fa un error de sintaxi, però no sempre és obvi què sobra o què falta.
Copilot és útil si acompanyes el codi amb comentaris clars sobre el que vols que faci. Per exemple, podeu escriure sobre una funció “# Calcula l'àrea d'un cercle” i després demanar-li a Copilot, amb /fix o amb un prompt natural, que reescriviu la funció amb la sintaxi correcta.
Errors semàntics: el codi compila però pensa malament
Són els més traïdors: el codi s'executa, però la lògica no fa el que hauria de fer. Per exemple, una funció que hauria de calcular una mitjana i en realitat multiplica en lloc de dividir.
def calcular_promedio(lista):
return sum(lista) * len(lista)
# Debería dividir entre len(lista), no multiplicarAquí Copilot et pot ajudar si li expliques la teva intenció: “Aquesta funció hauria de tornar la mitjana d'una llista de números, què està malament?” El model analitza el comentari, compara amb la lògica implementada i proposa una versió corregida amb sum(lista) / len(lista), a més de suggerir casos de prova.
Errors en temps d'execució: índexs fora de rang, divisions per zero i companyia
Finalment hi ha els errors que només apareixen en executar l'script: IndexError, ZeroDivisionError, NullReferenceException i similars. Copilot és especialment útil aquí perquè li pots enganxar directament el missatge d'error i el bloc de codi associat.
Per exemple: casos senzills que provoquen IndexError
def obtener_elemento(lista):
return lista
obtener_elemento() # Provocará IndexErrorSi copies la traça i el fragment a Copilot Chat i li demanes “Feu que aquesta funció no falli si l'índex està fora de rang”, us suggerirà embolicar l'operació en un try/except, comprovar la longitud de la llista abans d'accedir o tornar un valor per defecte quan l'índex no existeixi.
Prompts efectius perquè Copilot depuri de veritat (i no endevini)
Perquè Copilot sigui realment útil en depurar scripts, no n'hi ha prou amb enganxar errors sense més ni més. La qualitat del context que li donis marca la diferència entre una resposta genèrica i una correcció pràcticament llesta per acceptar.
Donar context d'intenció i comportament esperat
En lloc de limitar-te a escriure “Arregla això", intenta explicar què se suposa que ha de passar. Comentaris com "Aquesta funció hauria de tornar el factorial d'un enter positiu"O"Aquest endpoint ha de respondre amb codi 200 i un JSON amb la llista de productes” ajuden moltíssim el model.
Combinat amb arxius afegits com a context (a VS Code pots fer servir el botó “Add Context…” a Copilot Chat), la IA entén millor l'arquitectura del teu script i proposa canvis coherents amb la resta del projecte.
Usar ordres /fix, /explain, /tests i /edit
En entorns com VS Code i Codespaces disposes de slash commands que predisposen Copilot a certa tasca:
- / arreglar perquè cerqueu i solucioneu errors en el codi seleccionat.
- /explicar si el que vols és comprendre primer què fa un script o per què falla.
- /proves per generar casos de prova unitaris o dintegració basats en un fragment concret.
- / editar quan necessites que reescrigui o refactoritzi un bloc seguint una instrucció clara.
Aquestes ordres, combinades amb un prompt ben pensat, permeten que Copilot passi de ser un autocompletat glorificat a un veritable company de depuració.
Crear i depurar un script de chatbot amb FastAPI i l'API d'OpenAI usant Copilot
Vegem-ne un exemple una mica més complet, on Copilot ens ajuda tant a crear com a depurar un script real: un endpoint de xat usant FastAPI i l'API d'OpenAI. És un cas molt típic quan vols muntar un backend que parli amb models de llenguatge.
Genereu l'esquelet de l'script amb Copilot
En un projecte de Python, creeu un fitxer, per exemple main.py, i afegeixes un comentari a la part superior que descrigui el que vols fer, alguna cosa com: «# Developing a simple xatbot amb OpenAI API and FastAPI».
Només començar a escriure els primers imports, Copilot sol proposar l'esquelet complet de l'script, una mica de l'estil:
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 alguna cosa de la sintaxi no et quadra, pots seleccionar el bloc i demanar a Copilot amb /explicar que us detalli què fa cada part: càrrega de variables d'entorn, inicialització del client d'OpenAI, definició de l'endpoint i maneig d'errors.
Depurar errors de configuració i d'execució a l'endpoint
El més normal és que la primera vegada que executis aquest script apareguin problemes: variables d'entorn sense definir, versions de llibreries incompatibles, o errors a la crida a l'API d'OpenAI.
Quan vegis un traceback a la terminal de l'estil “openai.error.AuthenticationError” o errors d'importació, copia la traça juntament amb la funció chat i planteja una pregunta del tipus: “Aquesta ruta FastAPI llança aquest error d'autenticació amb OpenAI, què em manca configurar?".
Copilot sol detectar ràpidament que la variable OPENAI_API_KEY no està definida o no es carrega correctament des del fitxer .env, i et suggereix crear aquest fitxer, afegir la clau i comprovar que load_dotenv() s'està trucant a l'inici de l'script.
Si més endavant voleu millorar el maneig d'errors, podeu demanar-li: “Refactoritza aquest endpoint per capturar millor els errors de xarxa i tornar missatges més clars al client”.La IA proposarà blocs try/except més específics, ús de codis HTTP adequats i potser lextracció de la crida a OpenAI a una funció auxiliar per facilitar les proves.
Depurar agents de Microsoft 365 Copilot amb Copilot Studio
Més enllà del codi clàssic, també pots fer servir Copilot per provar i depurar agents declaratius a Microsoft 365 mitjançant Copilot Studio. Aquí la clau és a l'anomenat mode de desenvolupador.
quan escrius -developer on dins d'una sessió de Copilot, s'activa una manera especial en què l'orquestrador mostra targetes d'informació de depuració cada vegada que heu de decidir quin coneixement o accions del vostre agent utilitzar per respondre.
En aquestes targetes veuràs diversos blocs:
- Metadades de l'agent: identificadors i versió de l'agent, aneu de conversa i de sol·licitud.
- Funcionalitats i accions configurades: quines fonts de coneixement i quines accions estan disponibles.
- Funcions coincidents i seleccionades: quines accions detecta l'orquestrador com a rellevants per al prompt i quines decideix executar.
- Detalls d'execució: resultats, temps de resposta, errors de mapping de paràmetres o timeouts dels teus APIs.
Amb aquesta informació pots identificar, per exemple, que cap funció coincideix amb la intenció de l'usuari perquè la descripció de l'ordre no és clara, o que una acció falla sistemàticament perquè l'endpoint HTTP està mal configurat.
Quan hagis acabat de depurar, pots desactivar aquesta manera amb -developer off per tornar a una experiència dusuari més neta sense targetes de depuració en cada missatge.
Depurar JavaScript al navegador: DevTools i Copilot a Edge
Un altre escenari molt pràctic és quan vols depurar scripts JavaScript directament al navegador. Microsoft Edge, combinat amb DevTools i Copilot, ofereix algunes comoditats interessants.
Des de la pestanya Orígens pots obrir els fitxers JS de la teva web, modificar-los al vol i veure els canvis sense haver de reempaquetar i desplegar. Per entendre millor certes seccions, comptes amb la funció “Explicar aquestes línies de codi” integrada amb Copilot a Edge, que et torna una explicació en llenguatge natural del bloc seleccionat.
A més, DevTools et deixa:
- Formatar fitxers minificats amb el botó de “bonic” per fer-los llegibles.
- Definir punts d'interrupció de línia, desdeveniment, condicionals, etc., per pausar lexecució just on tinteressa.
- Recórrer el codi pas a pas (step over, step into, step out) mentre inspecciones variables i àmbits.
- Edita propietats i expressions d'inspecció per provar hipòtesis de depuració sense canviar encara el codi font.
Si combines tot això amb Copilot (demanant-li que t'expliqui funcions complicades o suggeriments de maneig d'errors), tens un entorn molt complet per depurar scripts del costat client sense abandonar el navegador.
Bones pràctiques, qualitat del codi i propietat intel·lectual en treballar amb Copilot
Copilot pot accelerar molt el teu flux de treball, però no deixa de ser una eina estadística que de vegades s'equivoca o proposa solucions subòptimes. Convé fer-lo servir amb certs criteris per no baixar el llistó de qualitat.
D'una banda, és recomanable mantenir les teves pròpies normes de revisió de codi. Tot i que Copilot generi una funció sencera o una bateria de proves, segueix sent la teva responsabilitat revisar-les, passar linters, executar tests i assegurar-te que el resultat encaixa amb l'arquitectura del projecte.
De l'altra, hi ha la qüestió de la propietat intel·lectual. El model està entrenat sobre grans quantitats de codi públic, i encara que normalment sintetitza solucions originals, en poques ocasions pot produir fragments molt semblants a codi existent. GitHub ofereix opcions per controlar els suggeriments que coincideixen amb codi públic i detallar possibles orígens quan els acceptes, però la decisió final sobre ús i atribució recau en tu oa la teva organització.
La forma més assenyada de fer servir Copilot és tractar-lo com un company de parells molt ràpid i versàtil: genera propostes, ajuda a depurar, suggereix proves i refactoritzacions, però sempre amb una capa de criteri humà per sobre que decideix què entra al repositori.
Amb tots aquests recursos sobre la taula, Copilot es converteix en alguna cosa més que un simple autocompletat: és una eina transversal que us acompanya des de la creació del primer script fins a la depuració d'errors subtils en producció, tant en escriptori com en el núvol. Si aprofites bé el context, fas servir prompts clars i mantens els teus estàndards de revisió, podràs escriure i depurar scripts més ràpid, amb menys frustració i amb una sensació molt agradable de tenir “un sènior” ajudant-te a un parell de tecles de distància.
