GitHub Copilot se ha convertido en una herramienta indispensable para muchos desarrolladores, pero ¿estás realmente aprovechando todo su potencial? Si bien la creación de prompts efectivos es un buen punto de partida, existe todo un mundo de posibilidades para mejorar la calidad de las sugerencias de código que recibes. En este artículo, exploraremos cómo puedes convertirte en un mejor compañero para tu IA, proporcionándole el contexto necesario para entender tus necesidades y ofrecerte soluciones más precisas.
El contexto lo es todo
Imagina esta situación: le pides a un amigo que te recomiende un restaurante para desayunar. Él te sugiere un lugar que le encanta, pero resulta que has ido allí varias veces últimamente. Le das más información: quieres probar algo nuevo. Él te da otra opción, pero entonces te das cuenta de que lo que realmente quieres son waffles. ¿Suena familiar?
Esta conversación cotidiana ilustra perfectamente cómo funciona la comunicación con herramientas de IA generativa como Copilot. Hacemos preguntas, obtenemos respuestas y, a medida que interactuamos, proporcionamos más contexto para refinar los resultados. Si Copilot no te da las sugerencias que esperas, es probable que no tenga suficiente información sobre lo que necesitas.
¿Cómo funciona GitHub Copilot con tu código?
Para entender cómo Copilot obtiene el contexto, es fundamental saber cómo funciona internamente. A excepción del modo agente, Copilot no ejecuta ni compila el código para generar sugerencias. En cambio, actúa como un compañero de programación: lee el código (y los comentarios) de los archivos que le indicas, tal como lo haría otro desarrollador.
Sin embargo, a diferencia de un colega, Copilot carece de “conocimiento institucional”, es decir, la información de fondo que se adquiere con la experiencia. Esto incluye el historial de por qué las cosas se construyeron de cierta manera, el uso de bibliotecas o frameworks internos específicos, y los patrones que deben seguirse. Toda esta información es crucial para que Copilot pueda generar sugerencias de código relevantes.
Por ejemplo, si estás utilizando una capa de abstracción de datos (DAL), pero Copilot te ofrece código SQL sin formato, las sugerencias no serán muy útiles. El problema no es que el código sea inválido, sino que Copilot no tiene el contexto necesario para generar código en el formato y la estructura correctos. En otras palabras, quieres waffles y te está dando una tortilla.
Comentarios en el código: la clave para un mejor contexto
Existe la creencia común de que el código de calidad no necesita comentarios, y que agregarlos es una señal de que algo podría mejorarse. Si bien es admirable esforzarse por escribir código lo más legible posible, a menudo nos quedamos cortos en nuestro trabajo diario. Incluso cuando lo logramos, debemos recordar que el código legible para un desarrollador puede no serlo para otro. Unos pocos comentarios pueden marcar una gran diferencia.
Lo mismo ocurre con Copilot. Como mencionamos, Copilot no ejecuta ni compila tu código (excepto en situaciones específicas). En cambio, lo “lee” como lo haría un desarrollador. Seguir las pautas para incluir docstrings en funciones y módulos en Python, por ejemplo, puede ayudar a Copilot a comprender mejor qué hace el código y cómo lo hace. Esto le permite generar sugerencias de mayor calidad, utilizando tu código existente para garantizar que cualquier código nuevo siga los mismos patrones y prácticas.
💡 Consejo geek: Cuando abras un archivo, intenta dejarlo en un mejor estado del que lo encontraste. Una pequeña mejora que puedes hacer es agregar comentarios para describir el código. ¡Incluso puedes pedirle a Copilot que genere un borrador de los comentarios y luego agregar los detalles que falten!
Instrucciones personalizadas: define las reglas del juego
Para generar sugerencias de calidad, Copilot necesita contexto sobre lo que estás haciendo y cómo lo estás haciendo. Conocer las tecnologías y frameworks que utilizas, los estándares de codificación que debes seguir e incluso información general sobre lo que estás construyendo, ayuda a Copilot a mejorar la calidad de sus sugerencias. Aquí es donde entran en juego las instrucciones personalizadas.
Las instrucciones personalizadas te permiten proporcionar toda esta información de fondo y establecer reglas básicas, como las APIs que deseas usar, los patrones de nomenclatura que quieres seguir o incluso tus preferencias de estilo. Para empezar, crea un archivo llamado copilot-instructions.md dentro de la carpeta .github de tu proyecto. Este archivo Markdown puede contener secciones como “Estructura del proyecto”, “Tecnologías”, “Estándares de codificación” y cualquier otra nota que quieras que Copilot considere en cada solicitud de chat.
Recuerda que las instrucciones personalizadas se envían a Copilot en cada solicitud de chat, por lo que debes limitarlas a información relevante para todo el proyecto. Demasiados detalles pueden dificultar que Copilot determine qué es importante. En esencia, es como tener un amigo que comparte demasiados detalles al contar una historia, lo que dificulta concentrarse en los puntos principales.
Una buena regla general es tener secciones que destaquen los diversos aspectos de tu proyecto. Por ejemplo, para un monorepo con un cliente y un servidor para una aplicación web, podrías usar una estructura como esta:
# Tailspin Toys Crowd Funding
Sitio web para el crowdfunding de juegos.
## Backend
El backend está escrito utilizando:
- Flask para la API
- SQLAlchemy para el ORM
- SQLite para la base de datos
## Frontend
El frontend está escrito utilizando:
- Astro para el enrutamiento
- Svelte para los componentes y la interactividad
- Tailwind CSS para el estilo
## Estándares de código
- Utilizar nombres de variables descriptivos, evitando abreviaturas y variables de una sola letra
- Utilizar el estándar de mayúsculas y minúsculas para el lenguaje en cuestión (camelCasing para TypeScript, snake_casing para Python, etc.)
- Utilizar sugerencias de tipo en todos los lenguajes que las admitan
## Estructura del proyecto
- `client` contiene el código del frontend
- `docs` contiene la documentación del proyecto
- `scripts` contiene los scripts utilizados para instalar servicios, iniciar la aplicación y ejecutar pruebas
- `server` contiene el código del backend
Este es un ejemplo abreviado, pero ilustra la estructura general. Le estamos informando a Copilot sobre el proyecto, su estructura, las tecnologías utilizadas y algunas pautas sobre cómo queremos que se cree el código. No incluimos nada específico para tareas concretas, como escribir pruebas unitarias, ¡porque tenemos otra forma de indicarle esa información a Copilot!
Instrucciones específicas para tareas específicas
Además del archivo copilot-instructions.md, VS Code y Codespaces también admiten archivos .instructions.md. Estos archivos son similares a los anteriores, pero están diseñados para tareas específicas y se colocan en la carpeta .github/instructions.
Considera un proyecto en el que estás creando Flask Blueprints para las rutas de una API. Podría haber requisitos sobre cómo debe estructurarse el archivo y cómo deben crearse las pruebas unitarias. Puedes crear un archivo de instrucciones personalizado llamado flask-endpoint.instructions.md, colocarlo en .github/instructions y luego agregarlo como contexto al chat cuando le pidas a Copilot que cree un nuevo punto final. Podría verse así:
# Pautas para la creación de endpoints
## Notas sobre los endpoints
- Los endpoints se crean en Flask utilizando blueprints
- Crear una función centralizada para acceder a los datos
- Todos los endpoints requieren pruebas
- Utilizar el módulo `unittest` para las pruebas
- Todas las pruebas deben pasar
- Se proporciona un script para ejecutar las pruebas en `scripts/run-server-tests.sh`
## Notas sobre el proyecto
- El entorno virtual de Python se encuentra en la raíz del proyecto en una carpeta **venv**
- Registrar todos los blueprints en `server/app.py`
- Utilizar las [instrucciones de prueba](./python-tests.instructions.md) al crear pruebas
## Archivos prototipo
- [Prototipo de endpoint](../../server/routes/games.py)
- [Prototipo de pruebas](../../server/tests/test_games.py)
Observa cómo proporcionamos información específica sobre cómo queremos que se creen nuestros endpoints. Incluso estamos enlazando a otros archivos del proyecto utilizando hipervínculos: archivos existentes para que Copilot los utilice como ejemplos representativos, y otros archivos de instrucciones para obtener más información.
Además, puedes aplicar instrucciones a tipos de archivo basándote en un patrón. Por ejemplo, si todas las pruebas se encuentran en server/tests y comienzan con test_, puedes agregar metadatos en la parte superior para asegurarte de que Copilot siempre incluya las instrucciones al trabajar en un archivo de prueba:
---
applyTo: server/tests/test_*.py
---
Esto te brinda mucha flexibilidad para garantizar que Copilot pueda acceder a la información correcta en el momento adecuado, ya sea explícitamente agregando el archivo de instrucciones o implícitamente proporcionando un patrón para que Copilot lo utilice al construir ciertos archivos.
Al igual que antes, estos son artefactos en tu repositorio. Puede llevar tiempo construir una colección de archivos de instrucciones, pero esa inversión se amortizará en forma de código de mayor calidad y, a su vez, una mayor productividad.
Prompts totalmente reutilizables
El equipo de VS Code ha publicado recientemente una nueva característica experimental llamada archivos de prompt. En resumen, te permiten crear prompts con “script” para Copilot. Puedes elegir los modos de Copilot en los que están disponibles (ask, edit y agent), las herramientas que se llamarán y qué preguntas se le harán al desarrollador. Estos pueden ser creados por el equipo para una mayor reutilización y consistencia.
Extendiendo las capacidades de GitHub Copilot con el Protocolo de Contexto del Modelo (MCP)
En un panorama de desarrollo de software en constante cambio, necesitamos asegurarnos de que la información con la que estamos trabajando sea precisa, relevante y esté actualizada. ¡Para esto está creado MCP, o Protocolo de Contexto del Modelo! Desarrollado inicialmente por Anthropic, MCP es un protocolo de código abierto que permite a las organizaciones exponer sus servicios o datos a herramientas de IA generativa.
Cuando agregas un servidor MCP a tu IDE, permites que Copilot “llame a un amigo” para encontrar información o incluso realizar tareas en tu nombre. Por ejemplo, el servidor Playwright MCP ayuda a crear pruebas end-to-end de Playwright, mientras que el servidor GitHub MCP proporciona acceso a servicios de GitHub como repositorios, incidencias y solicitudes de extracción.
Incluso puedes crear tus propios servidores MCP. Una pregunta común es cómo permitir que Copilot revise una base de código interna o un conjunto de bibliotecas. Con un servidor MCP personalizado, podrías proporcionar una fachada para que Copilot realice este tipo de consultas y luego utilizar la información descubierta para sugerir código basado en tu entorno interno.
Más allá de los prompts
La creación de prompts es importante, es una de las primeras habilidades que cualquier desarrollador debe aprender al comenzar a usar GitHub Copilot. Sin embargo, escribir un buen prompt es solo una parte de lo que Copilot considera al generar una respuesta. Al utilizar las mejores prácticas descritas anteriormente (comentarios y buen código, instrucciones personalizadas y servidores MCP), puedes ayudar a Copilot a comprender lo que quieres que haga y cómo quieres que lo haga.
En resumen, proporciona el contexto adecuado a Copilot y obtendrás resultados mucho más precisos y relevantes. ¡Así te asegurarás de que Copilot te dé waffles en lugar de tortillas!
Fuente: Github Blog
Leave a Comment