+
+Después de confiar la carpeta, puedes iniciar sesión con tu cuenta de GitHub.
+
+```
+> /login
+```
+
+**Qué ocurre a continuación:**
+
+1. Copilot CLI muestra un código de un solo uso (como `ABCD-1234`)
+2. Tu navegador se abre en la página de autorización de dispositivos de GitHub. Inicia sesión en GitHub si no lo has hecho.
+3. Ingresa el código cuando se te solicite
+4. Selecciona "Authorize" para otorgar acceso a GitHub Copilot CLI
+5. Vuelve a tu terminal - ¡ahora has iniciado sesión!
+
+
+
+*El flujo de autorización de dispositivo: tu terminal genera un código, lo verificas en el navegador y Copilot CLI queda autenticado.*
+
+**Consejo**: El inicio de sesión persiste entre sesiones. Solo necesitas hacerlo una vez, a menos que tu token caduque o cierres sesión explícitamente.
+
+---
+
+## Verificar que funciona
+
+### Paso 1: Probar Copilot CLI
+
+Ahora que has iniciado sesión, verifiquemos que Copilot CLI funciona para ti. En la terminal, inicia la CLI si no lo has hecho ya:
+
+```bash
+> Say hello and tell me what you can help with
+```
+
+Después de recibir una respuesta, puedes salir de la CLI:
+
+```bash
+> /exit
+```
+
+---
+
+
+
+Sumérgete y descubre lo que Copilot CLI puede hacer.
+
+---
+
+## Familiarízate: Tus primeros prompts
+
+Antes de sumergirte en las demostraciones impresionantes, comencemos con algunos prompts sencillos que puedes probar ahora mismo. **No se necesita un repositorio de código**. Simplemente abre una terminal y inicia Copilot CLI:
+
+```bash
+copilot
+```
+
+Prueba estos prompts para principiantes:
+
+```
+> Explain what a dataclass is in Python in simple terms
+
+> Write a function that sorts a list of dictionaries by a specific key
+
+> What's the difference between a list and a tuple in Python?
+
+> Give me 5 best practices for writing clean Python code
+```
+
+¿No usas Python? ¡No hay problema! Simplemente haz preguntas sobre el lenguaje que prefieras.
+
+Fíjate en lo natural que se siente. Simplemente haz preguntas como lo harías con un colega. Cuando termines de explorar, escribe `/exit` para salir de la sesión.
+
+**La idea clave**: GitHub Copilot CLI es conversacional. No necesitas una sintaxis especial para empezar. Solo pregunta en lenguaje natural.
+
+## Verlo en acción
+
+Ahora veamos por qué los desarrolladores dicen que esto es "tener a un ingeniero senior en marcación rápida".
+
+> 📖 **Lectura de los ejemplos**: Las líneas que empiezan con `>` son prompts que escribes dentro de una sesión interactiva de Copilot CLI. Las líneas sin el prefijo `>` son comandos de shell que ejecutas en tu terminal.
+
+> 💡 **Sobre los resultados de ejemplo**: Las salidas de ejemplo mostradas a lo largo de este curso son ilustrativas. Como las respuestas de Copilot CLI varían cada vez, tus resultados diferirán en redacción, formato y nivel de detalle. Enfócate en el *tipo* de información devuelta, no en el texto exacto.
+
+### Demostración 1: Revisión de código en segundos
+
+El curso incluye archivos de ejemplo con problemas intencionales de calidad de código. Si estás trabajando en tu máquina local y aún no has clonado el repositorio, por favor ejecuta el comando `git clone` que aparece abajo, navega a la carpeta `copilot-cli-for-beginners` y luego ejecuta el comando `copilot`.
+
+```bash
+# Clona el repositorio del curso si estás trabajando localmente y aún no lo has hecho
+git clone https://github.com/github/copilot-cli-for-beginners
+cd copilot-cli-for-beginners
+
+# Inicia Copilot
+copilot
+```
+
+Una vez dentro de la sesión interactiva de Copilot CLI, ejecuta lo siguiente:
+
+```
+> Review @samples/book-app-project/book_app.py for code quality issues and suggest improvements
+```
+
+> 💡 **¿Para qué se usa el símbolo `@`?** El símbolo `@` le indica a Copilot CLI que lea un archivo. Aprenderás todo sobre esto en el Capítulo 02. Por ahora, copia el comando exactamente como se muestra.
+
+---
+
+
+
+Acabas de ver lo que Copilot CLI puede hacer. Ahora entendamos *cómo* usar estas capacidades de forma efectiva. La clave es saber cuál de los tres modos de interacción usar según la situación.
+
+> 💡 **Nota**: Copilot CLI también tiene un modo **Autopilot** donde trabaja las tareas sin esperar tu entrada. Es poderoso pero requiere conceder permisos completos y usa solicitudes premium de forma autónoma. Este curso se centra en los tres modos que aparecen abajo. Te guiaremos hacia Autopilot una vez que estés cómodo con lo básico.
+
+---
+
+## 🧩 Analogía del mundo real: Salir a comer
+
+Piensa en usar GitHub Copilot CLI como salir a comer. Desde planear el viaje hasta hacer el pedido, diferentes situaciones requieren diferentes enfoques:
+
+| Modo | Analogía gastronómica | Cuándo usarlo |
+|------|-----------------------|---------------|
+| **Plan** | Ruta GPS al restaurante | Tareas complejas: traza la ruta, revisa las paradas, acuerda el plan y luego conduce |
+| **Interactive** | Hablar con el camarero | Exploración e iteración: haz preguntas, personaliza, recibe retroalimentación en tiempo real |
+| **Programmatic** | Pedido por ventanilla (drive-through) | Tareas rápidas y específicas: quédate en tu entorno y obtén un resultado rápido |
+
+Al igual que al salir a comer, aprenderás de forma natural cuándo se siente mejor cada enfoque.
+
+
+
+*Elige tu modo según la tarea: Plan para mapear primero, Interactivo para colaboración bidireccional, Programático para resultados rápidos de una sola vez*
+
+### ¿Con qué modo debo empezar?
+
+**Comienza con el modo Interactivo.**
+- Puedes experimentar y hacer preguntas de seguimiento
+- El contexto se construye naturalmente a través de la conversación
+- Los errores son fáciles de corregir con `/clear`
+
+Una vez que te sientas cómodo, prueba:
+- **Modo Programático** (`copilot -p "
+
+**Ideal para**: Exploración, iteración, conversaciones de múltiples turnos. Como hablar con un camarero que puede responder preguntas, recibir feedback y ajustar el pedido sobre la marcha.
+
+Inicia una sesión interactiva:
+
+```bash
+copilot
+```
+
+Como has visto hasta ahora, verás un prompt donde puedes escribir de forma natural. Para obtener ayuda sobre los comandos disponibles, simplemente escribe:
+
+```
+> /help
+```
+
+**Idea clave**: El modo interactivo mantiene el contexto. Cada mensaje se construye sobre los previos, como en una conversación real.
+
+#### Ejemplo de modo interactivo
+
+```bash
+copilot
+
+> Review @samples/book-app-project/utils.py and suggest improvements
+
+> Add type hints to all functions
+
+> Make the error handling more robust
+
+> /exit
+```
+
+Fíjate en cómo cada prompt se basa en la respuesta anterior. Estás teniendo una conversación, no empezando de cero cada vez.
+
+---
+
+### Modo 2: Modo Plan
+
+
+
+**Ideal para**: Tareas complejas donde quieres revisar el enfoque antes de ejecutarlo. Similar a planear una ruta antes de un viaje usando GPS.
+
+El modo Plan te ayuda a crear un plan paso a paso antes de escribir cualquier código. Usa el comando `/plan`, presiona **Shift+Tab** para cambiar al Modo Plan:
+
+```bash
+copilot
+
+> /plan Add a "mark as read" command to the book app
+```
+
+> 💡 **Consejo**: **Shift+Tab** cicla entre modos: Interactivo → Plan → Autopilot. Púlsalo en cualquier momento durante una sesión interactiva para cambiar de modo sin escribir un comando.
+
+También puedes iniciar Copilot CLI directamente en modo plan usando la bandera `--plan`:
+
+```bash
+copilot --plan
+```
+
+**Salida del modo Plan:** (tu salida puede variar)
+
+```
+📋 Implementation Plan
+
+Step 1: Update the command handler in book_app.py
+ - Add new elif branch for "mark" command
+ - Create handle_mark_as_read() function
+
+Step 2: Implement the handler function
+ - Prompt user for book title
+ - Call collection.mark_as_read(title)
+ - Display success/failure message
+
+Step 3: Update help text
+ - Add "mark" to available commands list
+ - Document the command usage
+
+Step 4: Test the flow
+ - Add a book
+ - Mark it as read
+ - Verify status changes in list output
+
+Proceed with implementation? [Y/n]
+```
+
+**Idea clave**: El modo Plan te permite revisar y modificar el enfoque antes de que se escriba código. Una vez que un plan está completo, incluso puedes pedirle a Copilot CLI que lo guarde en un archivo para referencia posterior. Por ejemplo, "Guardar este plan en `mark_as_read_plan.md`" crearía un archivo markdown con los detalles del plan.
+
+> 💡 **¿Quieres algo más complejo?** Prueba: `/plan Añadir capacidades de búsqueda y filtrado a la aplicación de libros`. El modo Plan escala desde funciones simples hasta aplicaciones completas.
+
+> 📚 **Modo Autopilot**: Puede que hayas notado que Shift+Tab cicla por un tercer modo llamado **Autopilot**. En el modo autopilot, Copilot ejecuta todo un plan sin esperar tu entrada después de cada paso — como delegarle una tarea a un colega y decir "avísame cuando termines". El flujo típico es plan → aceptar → autopilot, lo que significa que necesitas saber escribir buenos planes primero. También puedes iniciar directamente en autopilot con `copilot --autopilot`. Familiarízate primero con los modos Interactivo y Plan, y luego consulta la [documentación oficial](https://docs.github.com/copilot/concepts/agents/copilot-cli/autopilot) cuando estés listo.
+
+---
+
+### Modo 3: Modo programático
+
+
+
+**Ideal para**: Automatización, scripts, CI/CD, comandos de una sola ejecución. Como usar un drive-through para un pedido rápido sin necesidad de hablar con un camarero.
+
+Usa la bandera `-p` para comandos puntuales que no requieren interacción:
+
+```bash
+# Generar código
+copilot -p "Write a function that checks if a number is even or odd"
+
+# Obtener ayuda rápida
+copilot -p "How do I read a JSON file in Python?"
+```
+
+**Idea clave**: El modo programático te da una respuesta rápida y sale. Sin conversación, solo entrada → salida.
+
+
+
+
+---
+
+## Comandos slash esenciales
+
+Estos comandos son buenos para aprender al principio mientras te familiarizas con Copilot CLI:
+
+| Comando | Qué hace | Cuándo usarlo |
+|---------|----------|---------------|
+| `/ask` | Hacer una pregunta rápida sin que afecte tu historial de conversación | Cuando quieres una respuesta rápida sin desviarte de tu tarea actual |
+| `/clear` | Borrar la conversación y empezar de cero | Al cambiar de tema |
+| `/help` | Mostrar todos los comandos disponibles | Cuando olvidas un comando |
+| `/model` | Mostrar o cambiar el modelo de IA | Cuando quieres cambiar el modelo de IA |
+| `/plan` | Planear tu trabajo antes de codificar | Para características más complejas |
+| `/research` | Investigación profunda usando GitHub y fuentes web | Cuando necesitas investigar un tema antes de codificar |
+| `/exit` | Terminar la sesión | Cuando hayas terminado |
+
+> 💡 **`/ask` vs chat normal**: Normalmente cada mensaje que envías pasa a formar parte de la conversación en curso y afecta las respuestas futuras. `/ask` es un atajo "off the record" — perfecto para preguntas rápidas y puntuales como `/ask ¿Qué significa YAML?` sin contaminar el contexto de tu sesión.
+
+> 💡 **Autocompletado con Tab**: Al escribir un comando slash, pulsa **Tab** para autocompletar el nombre del comando o para ciclar entre subcomandos y argumentos disponibles. Esto es especialmente útil cuando no recuerdas el nombre exacto de un comando.
+
+¡Eso es todo para empezar! A medida que te sientas cómodo, puedes explorar comandos adicionales.
+> 📚 **Documentación oficial**: [Referencia de comandos de la CLI](https://docs.github.com/copilot/reference/cli-command-reference) para la lista completa de comandos y banderas.
+
+📚 Ir más allá: Usar el modo programático en scripts (haz clic para expandir)
+ +Una vez que estés cómodo, puedes usar `-p` en scripts de shell: + +```bash +#!/bin/bash + +# Generar mensajes de commit automáticamente +COMMIT_MSG=$(copilot -p "Generate a commit message for: $(git diff --staged)") +git commit -m "$COMMIT_MSG" + +# Revisar un archivo +copilot --allow-all -p "Review @myfile.py for issues" +``` +> ⚠️ **Sobre `--allow-all`**: Esta bandera omite todas las solicitudes de permisos, permitiendo que Copilot CLI lea archivos, ejecute comandos y acceda a URLs sin preguntar primero. Esto es necesario para el modo programático (`-p`) ya que no hay una sesión interactiva para aprobar acciones. Usa `--allow-all` solo con prompts que hayas escrito tú mismo y en directorios de confianza. Nunca lo uses con entrada no confiable o en directorios sensibles. + +
+` | Agregar un directorio a la lista permitida |
+| `/allow-all [on\|off\|show]` | Aprobar automáticamente todos los avisos de permisos; usa `on` para habilitar, `off` para deshabilitar, `show` para verificar el estado actual |
+| `/yolo` | Alias rápido de `/allow-all on` — aprueba automáticamente todos los avisos de permisos. |
+| `/cwd`, `/cd [directory]` | Ver o cambiar el directorio de trabajo |
+| `/list-dirs` | Mostrar todos los directorios permitidos |
+
+> ⚠️ **Usar con precaución**: `/allow-all` y `/yolo` omiten las solicitudes de confirmación. Genial para proyectos de confianza, pero ten cuidado con código no confiable.
+
+### Sesión
+
+| Command | Qué hace |
+|---------|--------------|
+| `/clear` | Abandona la sesión actual (no se guarda el historial) y inicia una conversación nueva |
+| `/compact` | Resumir la conversación para reducir el uso del contexto |
+| `/context` | Mostrar el uso de tokens de la ventana de contexto y su visualización |
+| `/keep-alive` | Evitar que tu sistema entre en suspensión mientras Copilot CLI está activo — útil para tareas de larga duración en un portátil |
+| `/new` | Finaliza la sesión actual (guardándola en el historial para búsqueda/continuación) e inicia una conversación nueva. |
+| `/resume` | Cambiar a una sesión diferente (opcionalmente especificar ID o nombre de la sesión) |
+| `/rename` | Renombrar la sesión actual (omite el nombre para autogenerarlo) |
+| `/rewind` | Abrir un selector de línea de tiempo para retroceder a cualquier punto anterior de la conversación |
+| `/usage` | Mostrar métricas y estadísticas de uso de la sesión |
+| `/session` | Mostrar información de la sesión y resumen del espacio de trabajo; usa `/session delete`, `/session delete `, o `/session delete-all` para eliminar sesiones |
+| `/share` | Exportar la sesión como archivo markdown, gist de GitHub o archivo HTML autocontenido |
+
+### Visualización
+
+| Command | Qué hace |
+|---------|--------------|
+| `/statusline` (or `/footer`) | Personalizar qué elementos aparecen en la barra de estado en la parte inferior de la sesión (directorio, rama, esfuerzo, ventana de contexto, cuota) |
+| `/theme` | Ver o establecer el tema del terminal |
+
+### Ayuda y comentarios
+
+| Command | Qué hace |
+|---------|--------------|
+| `/changelog` | Mostrar el registro de cambios de las versiones de la CLI |
+| `/feedback` | Enviar comentarios a GitHub |
+| `/help` | Mostrar todos los comandos disponibles |
+
+### Comandos rápidos de shell
+
+Ejecuta comandos de shell directamente sin IA anteponiendo `!`:
+
+```bash
+copilot
+
+> !git status
+# Ejecuta git status directamente, sin usar la IA
+
+> !python -m pytest tests/
+# Ejecuta pytest directamente
+```
+
+### Cambio de modelos
+
+Copilot CLI admite múltiples modelos de IA de OpenAI, Anthropic, Google y otros. Los modelos disponibles para ti dependen de tu nivel de suscripción y región. Usa `/model` para ver tus opciones y cambiar entre ellos:
+
+```bash
+copilot
+> /model
+
+# Muestra los modelos disponibles y te permite elegir uno. Selecciona Sonnet 4.5.
+```
+
+> 💡 **Consejo**: Algunos modelos cuestan más "premium requests" que otros. Los modelos marcados **1x** (como Claude Sonnet 4.5) son una excelente opción por defecto. Son capaces y eficientes. Los modelos con multiplicadores más altos usan tu cuota de solicitudes premium más rápido, así que guárdalos para cuando realmente los necesites.
+
+> 💡 **¿No estás seguro de qué modelo elegir?** Selecciona **`Auto`** en el selector de modelos para permitir que Copilot elija automáticamente el mejor modelo disponible para cada sesión. Esto es un excelente valor predeterminado si recién comienzas y no quieres pensar en la selección de modelos.
+
+
+
+---
+
+# Práctica
+
+📚 Comandos adicionales (hacer clic para expandir)
+ +> 💡 Los comandos esenciales anteriores cubren gran parte de lo que harás en el uso diario. Esta referencia está aquí para cuando estés listo para explorar más. + +### Entorno de agentes + +| Command | Qué hace | +|---------|--------------| +| `/agent` | Explorar y seleccionar entre los agentes disponibles | +| `/env` | Mostrar detalles del entorno cargado — qué instrucciones, servidores MCP, habilidades, agentes y complementos están activos | +| `/init` | Inicializar las instrucciones de Copilot para tu repositorio | +| `/mcp` | Gestionar la configuración del servidor MCP | +| `/skills` | Gestionar habilidades para capacidades mejoradas | + +> 💡 Los agentes se tratan en [Capítulo 04](../04-agents-custom-instructions/README.md), las habilidades en [Capítulo 05](../05-skills/README.md) y los servidores MCP en [Capítulo 06](../06-mcp-servers/README.md). + +### Modelos y subagentes + +| Command | Qué hace | +|---------|--------------| +| `/delegate` | Delegar la tarea al agente en la nube de GitHub Copilot | +| `/fleet` | Dividir una tarea compleja en subtareas paralelas para completarla más rápido | +| `/model` | Mostrar o cambiar el modelo de IA | +| `/tasks` | Ver subagentes en segundo plano y sesiones de shell separadas | + +### Código + +| Command | Qué hace | +|---------|--------------| +| `/diff` | Revisar los cambios realizados en el directorio actual | +| `/pr` | Operar sobre pull requests de la rama actual | +| `/research` | Realizar investigación profunda utilizando GitHub y fuentes web | +| `/review` | Ejecutar el agente de revisión de código para analizar cambios | +| `/terminal-setup` | Habilitar soporte de entrada multilínea (shift+enter y ctrl+enter) | + +### Permisos + +| Command | Qué hace | +|---------|--------------| +| `/add-dir
+
+Es hora de poner en práctica lo que has aprendido.
+
+---
+
+## ▶️ Pruébalo tú mismo
+
+### Exploración interactiva
+
+Inicia Copilot y usa indicaciones de seguimiento para mejorar iterativamente la aplicación de libros:
+
+```bash
+copilot
+
+> Review @samples/book-app-project/book_app.py - what could be improved?
+
+> Refactor the if/elif chain into a more maintainable structure
+
+> Add type hints to all the handler functions
+
+> /exit
+```
+
+### Planificar una función
+
+Usa `/plan` para que Copilot CLI trace una implementación antes de escribir código:
+
+```bash
+copilot
+
+> /plan Add a search feature to the book app that can find books by title or author
+
+# Revisar el plan
+# Aprobar o modificar
+# Observar su implementación paso a paso
+```
+
+### Automatizar con el modo programático
+
+La bandera `-p` te permite ejecutar Copilot CLI directamente desde tu terminal sin entrar en modo interactivo. Copia y pega el siguiente script en tu terminal (no dentro de Copilot) desde la raíz del repositorio para revisar todos los archivos Python de la aplicación de libros.
+
+```bash
+# Revisar todos los archivos Python en la aplicación book
+for file in samples/book-app-project/*.py; do
+ echo "Reviewing $file..."
+ copilot --allow-all -p "Quick code quality review of @$file - critical issues only"
+done
+```
+
+**PowerShell (Windows):**
+
+```powershell
+# Revisar todos los archivos Python en la aplicación de libros
+Get-ChildItem samples/book-app-project/*.py | ForEach-Object {
+ $relativePath = "samples/book-app-project/$($_.Name)";
+ Write-Host "Reviewing $relativePath...";
+ copilot --allow-all -p "Quick code quality review of @$relativePath - critical issues only"
+}
+```
+
+---
+
+Después de completar las demostraciones, prueba estas variaciones:
+
+1. **Desafío interactivo**: Inicia `copilot` y explora la aplicación de libros. Pregunta sobre `@samples/book-app-project/books.py` y solicita mejoras 3 veces seguidas.
+
+2. **Desafío en modo Plan**: Ejecuta `/plan Add rating and review features to the book app`. Lee el plan cuidadosamente. ¿Tiene sentido?
+
+3. **Desafío programático**: Ejecuta `copilot --allow-all -p "List all functions in @samples/book-app-project/book_app.py and describe what each does"`. ¿Funcionó a la primera?
+
+---
+
+## 💡 Consejo: Controla tu sesión de CLI desde la web o el móvil
+
+GitHub Copilot CLI admite **sesiones remotas**, que te permiten monitorizar e interactuar con una sesión de CLI en ejecución desde un navegador web (en escritorio o móvil) o la app GitHub Mobile sin estar físicamente en tu terminal.
+
+Inicia una sesión remota con la bandera `--remote`:
+
+```bash
+copilot --remote
+```
+
+Copilot CLI mostrará un enlace y proporcionará acceso a un código QR. Abre el enlace en tu teléfono o en una pestaña del navegador de escritorio para ver la sesión en tiempo real, enviar indicaciones de seguimiento, revisar planes y dirigir el agente de forma remota. Las sesiones son específicas por usuario, por lo que solo puedes acceder a tus propias sesiones de Copilot CLI.
+
+También puedes habilitar el acceso remoto desde dentro de una sesión activa en cualquier momento:
+
+```
+> /remote
+```
+
+Detalles adicionales sobre sesiones remotas se pueden encontrar en la [documentación de Copilot CLI](https://docs.github.com/copilot/how-tos/copilot-cli/steer-remotely).
+
+---
+
+## 📝 Tarea
+
+### Desafío principal: Mejorar las utilidades de la aplicación de libros
+
+Los ejemplos prácticos se centraron en revisar y refactorizar `book_app.py`. Ahora practica las mismas habilidades en un archivo diferente, `utils.py`:
+
+1. Inicia una sesión interactiva: `copilot`
+2. Pide a Copilot CLI que resuma el archivo: "Summarize @samples/book-app-project/utils.py and explain what each function in this file does"
+3. Pídele que agregue validación de entrada: "Add validation to `get_user_choice()` so it handles empty input and non-numeric entries"
+4. Pídele que mejore el manejo de errores: "What happens if `get_book_details()` receives an empty string for the title? Add guards for that."
+5. Pídele un docstring: "Add a comprehensive docstring to `get_book_details()` with parameter descriptions and return values"
+6. Observa cómo el contexto se mantiene entre las indicaciones. Cada mejora se basa en la anterior
+7. Sal con `/exit`
+
+**Criterios de éxito**: Deberías tener un `utils.py` mejorado con validación de entrada, manejo de errores y un docstring, todo construido mediante una conversación de múltiples turnos.
+
+
+
+
+### Desafío adicional: Compara los modos
+
+Los ejemplos usaron `/plan` para una función de búsqueda y `-p` para revisiones por lotes. Ahora prueba los tres modos en una única nueva tarea: agregar un método `list_by_year()` a la clase `BookCollection`:
+
+1. **Interactivo**: `copilot` → pídele que diseñe y construya el método paso a paso
+2. **Plan**: `/plan Add a list_by_year(start, end) method to BookCollection that filters books by publication year range`
+3. **Programático**: `copilot --allow-all -p "@samples/book-app-project/books.py Add a list_by_year(start, end) method that returns books published between start and end year inclusive"`
+
+**Reflexión**: ¿Qué modo te pareció más natural? ¿Cuándo usarías cada uno?
+
+---
+
+💡 Pistas (hacer clic para expandir)
+ +**Ejemplos de indicaciones para probar:** +```bash +> @samples/book-app-project/utils.py What does each function in this file do? +> Add validation to get_user_choice() so it handles empty input and non-numeric entries +> What happens if get_book_details() receives an empty string for the title? Add guards for that. +> Add a comprehensive docstring to get_book_details() with parameter descriptions and return values +``` + +**Problemas comunes:** +- Si Copilot CLI hace preguntas de aclaración, simplemente respóndelas de forma natural +- El contexto se mantiene, por lo que cada indicación se basa en la anterior +- Usa `/clear` si quieres empezar de nuevo + +
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **El modo interactivo** es para exploración e iteración: el contexto se conserva. Es como tener una conversación con alguien que recuerda lo que has dicho hasta ese momento.
+2. **El modo Plan** suele ser para tareas más complejas. Revisa antes de implementar.
+3. **El modo programático** es para automatización. No se necesita interacción.
+4. **Comandos esenciales** (`/ask`, `/help`, `/clear`, `/plan`, `/research`, `/model`, `/exit`) cubren la mayoría del uso diario.
+
+> 📋 **Referencia rápida**: Consulta la [referencia de comandos de GitHub Copilot CLI](https://docs.github.com/en/copilot/reference/cli-command-reference) para una lista completa de comandos y atajos.
+
+---
+
+## ➡️ Qué sigue
+
+Ahora que entiendes los tres modos, aprendamos cómo proporcionar contexto sobre tu código a Copilot CLI.
+
+En **[Capítulo 02: Contexto y conversaciones](../02-context-conversations/README.md)**, aprenderás:
+
+- La sintaxis `@` para referenciar archivos y directorios
+- Gestión de sesiones con `--resume` y `--continue`
+- Cómo la gestión de contexto hace que Copilot CLI sea realmente potente
+
+---
+
+**[← Volver a la página principal del curso](../README.md)** | **[Continuar al Capítulo 02 →](../02-context-conversations/README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/02-context-conversations/README.md b/translations/es/02-context-conversations/README.md
new file mode 100644
index 00000000..ce22d802
--- /dev/null
+++ b/translations/es/02-context-conversations/README.md
@@ -0,0 +1,915 @@
+
+
+> **¿Y si la IA pudiera ver todo tu código, no solo un archivo a la vez?**
+
+En este capítulo desbloquearás el verdadero poder de GitHub Copilot CLI: el contexto. Aprenderás a usar la sintaxis `@` para referenciar archivos y directorios, dando a Copilot CLI un entendimiento profundo de tu base de código. Descubrirás cómo mantener conversaciones a través de sesiones, reanudar el trabajo días después exactamente donde lo dejaste, y verás cómo el análisis entre archivos detecta errores que las revisiones de un solo archivo no alcanzan a ver.
+
+## 🎯 Learning Objectives
+
+Al final de este capítulo, podrás:
+
+- Usar la sintaxis `@` para referenciar archivos, directorios e imágenes
+- Reanudar sesiones previas con `--resume` y `--continue`
+- Comprender cómo funcionan las [ventanas de contexto](../GLOSSARY.md#context-window)
+- Escribir conversaciones de varios turnos efectivas
+- Gestionar permisos de directorio para flujos de trabajo de múltiples proyectos
+
+> ⏱️ **Estimated Time**: ~50 minutes (20 min reading + 30 min hands-on)
+
+---
+
+## 🧩 Real-World Analogy: Working with a Colleague
+
+🔧 Errores comunes y solución de problemas (hacer clic para expandir)
+ +### Errores comunes + +| Error | Qué ocurre | Solución | +|---------|--------------|-----| +| Escribir `exit` en lugar de `/exit` | Copilot CLI trata "exit" como una indicación, no como un comando | Los comandos con barra siempre comienzan con `/` | +| Usar `-p` para conversaciones de múltiples turnos | Cada llamada con `-p` está aislada sin memoria de llamadas previas | Usa el modo interactivo (`copilot`) para conversaciones que se basen en el contexto | +| Olvidar las comillas alrededor de indicaciones con `$` o `!` | El shell interpreta caracteres especiales antes de que Copilot CLI los vea | Encierra las indicaciones entre comillas: `copilot -p "What does $HOME mean?"` | +| Presionar Esc una vez para cancelar una tarea en ejecución | Un solo Esc ya no cancela el trabajo en curso (para evitar accidentes) | Presiona **Esc dos veces** para cancelar mientras Copilot CLI está procesando | + +### Solución de problemas + +**"Model not available"** - Es posible que tu suscripción no incluya todos los modelos. Usa `/model` para ver qué está disponible. + +**"Context too long"** - Tu conversación ha usado toda la ventana de contexto. Usa `/clear` para reiniciar, o inicia una nueva sesión. + +**"Rate limit exceeded"** - Espera unos minutos e inténtalo de nuevo. Considera usar el modo programático para operaciones por lotes con retrasos. + +
+
+*Al igual que tus colegas, Copilot CLI no es un lector de mentes. Proporcionar más información ayuda tanto a las personas como a Copilot a ofrecer soporte más específico!*
+
+Imagina que le explicas un error a un colega:
+
+> **Sin contexto**: "La aplicación de libros no funciona."
+
+> **Con contexto**: "Mira `books.py`, especialmente la función `find_book_by_title`. No está haciendo una comparación insensible a mayúsculas."
+
+Para proporcionar contexto a Copilot CLI usa *la sintaxis `@`* para indicarle archivos específicos a Copilot CLI.
+
+---
+
+# Essential: Basic Context
+
+
+
+Esta sección cubre todo lo que necesitas para trabajar de forma efectiva con el contexto. Domina estos conceptos básicos primero.
+
+---
+
+## The @ Syntax
+
+El símbolo `@` referencia archivos y directorios en tus mensajes. Es la forma de decirle a Copilot CLI "mira este archivo."
+
+> 💡 **Nota**: Todos los ejemplos de este curso usan la carpeta `samples/` incluida en este repositorio, así que puedes probar cada comando directamente.
+
+### Try It Now (No Setup Required)
+
+Puedes probar esto con cualquier archivo en tu computadora:
+
+```bash
+copilot
+
+# Apunta a cualquier archivo que tengas
+> Explain what @package.json does
+> Summarize @README.md
+> What's in @.gitignore and why?
+```
+
+> 💡 **¿No tienes un proyecto a mano?** Crea un archivo de prueba rápido:
+> ```bash
+> echo "def greet(name): return 'Hello ' + name" > test.py
+> copilot
+> > What does @test.py do?
+> ```
+
+### Basic @ Patterns
+
+| Pattern | Qué hace | Ejemplo de uso |
+|---------|--------------|-------------|
+| `@file.py` | Referencia un único archivo | `Review @samples/book-app-project/books.py` |
+| `@folder/` | Referencia todos los archivos en un directorio | `Review @samples/book-app-project/` |
+| `@file1.py @file2.py` | Referencia múltiples archivos | `Compare @samples/book-app-project/book_app.py @samples/book-app-project/books.py` |
+
+### Reference a Single File
+
+```bash
+copilot
+
+> Explain what @samples/book-app-project/utils.py does
+```
+
+---
+
+
+
+
+---
+
+### Reference Multiple Files
+
+```bash
+copilot
+
+> Compare @samples/book-app-project/book_app.py and @samples/book-app-project/books.py for consistency
+```
+
+### Reference an Entire Directory
+
+```bash
+copilot
+
+> Review all files in @samples/book-app-project/ for error handling
+```
+
+---
+
+## Cross-File Intelligence
+
+Aquí es donde el contexto se convierte en una superpotencia. El análisis de un solo archivo es útil. El análisis entre archivos es transformador.
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demostración varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+### Demo: Find Bugs That Span Multiple Files
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py @samples/book-app-project/books.py
+>
+> How do these files work together? What's the data flow?
+```
+
+> 💡 **Opción avanzada**: Para análisis entre archivos centrados en seguridad, prueba los ejemplos de seguridad en Python:
+> ```bash
+> > @samples/buggy-code/python/user_service.py @samples/buggy-code/python/payment_processor.py
+> > Find security vulnerabilities that span BOTH files
+> ```
+
+---
+
+
+
+
+---
+
+**Lo que descubre Copilot CLI**:
+
+```
+Cross-Module Analysis
+=====================
+
+1. DATA FLOW PATTERN
+ book_app.py creates BookCollection instance and calls methods
+ books.py defines BookCollection class and manages data persistence
+
+ Flow: book_app.py (UI) → books.py (business logic) → data.json (storage)
+
+2. DUPLICATE DISPLAY FUNCTIONS
+ book_app.py:9-21 show_books() function
+ utils.py:28-36 print_books() function
+
+ Impact: Two nearly identical functions doing the same thing. If you update
+ one (like changing the format), you must remember to update the other.
+
+3. INCONSISTENT ERROR HANDLING
+ book_app.py handles ValueError from year conversion
+ books.py silently returns None/False on errors
+
+ Pattern: No unified approach to error handling across modules
+```
+
+**Por qué esto importa**: Una revisión de un solo archivo perdería el panorama completo. Solo el análisis entre archivos revela:
+- **Código duplicado** que debería consolidarse
+- **Patrones de flujo de datos** que muestran cómo interactúan los componentes
+- **Problemas arquitectónicos** que afectan la mantenibilidad
+
+---
+
+### Demo: Understand a Codebase in 60 Seconds
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demostración varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+¿Nuevo en un proyecto? Conócela rápidamente usando Copilot CLI.
+
+```bash
+copilot
+
+> @samples/book-app-project/
+>
+> In one paragraph, what does this app do and what are its biggest quality issues?
+```
+
+**Lo que obtienes**:
+```
+This is a CLI book collection manager that lets users add, list, remove, and
+search books stored in a JSON file. The biggest quality issues are:
+
+1. Duplicate display logic - show_books() and print_books() do the same thing
+2. Inconsistent error handling - some errors raise exceptions, others return False
+3. No input validation - year can be 0, empty strings accepted for title/author
+4. Missing tests - no test coverage for critical functions like find_book_by_title
+
+Priority fix: Consolidate duplicate display functions and add input validation.
+```
+
+**Resultado**: Lo que toma una hora de lectura de código comprimido en 10 segundos. Sabes exactamente dónde enfocarte.
+
+---
+
+## Practical Examples
+
+### Example 1: Code Review with Context
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Review this file for potential bugs
+
+# Copilot CLI ahora tiene el contenido completo del archivo y puede dar retroalimentación específica:
+# "Line 49: La comparación que distingue entre mayúsculas y minúsculas puede omitir libros..."
+# "Line 29: Los errores de decodificación JSON se capturan pero la corrupción de datos no se registra..."
+
+> What about @samples/book-app-project/book_app.py?
+
+# Ahora revisando book_app.py, pero aún consciente del contexto de books.py
+```
+
+### Example 2: Understanding a Codebase
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py What does this module do?
+
+# Copilot CLI lee books.py y comprende la clase BookCollection
+
+> @samples/book-app-project/ Give me an overview of the code structure
+
+# Copilot CLI escanea el directorio y resume
+
+> How does the app save and load books?
+
+# Copilot CLI puede rastrear el código que ya ha visto
+```
+
+
+
+
+### Example 3: Multi-File Refactoring
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py @samples/book-app-project/utils.py
+> I see duplicate display functions: show_books() and print_books(). Help me consolidate these.
+
+# Copilot CLI ve ambos archivos y puede sugerir cómo fusionar el código duplicado
+```
+
+---
+
+## Session Management
+
+Las sesiones se guardan automáticamente mientras trabajas. Puedes reanudar sesiones previas para continuar donde lo dejaste.
+
+### Sessions Auto-Save
+
+Cada conversación se guarda automáticamente. Simplemente sal normalmente:
+
+```bash
+copilot
+
+> @samples/book-app-project/ Let's improve error handling across all modules
+
+[... do some work ...]
+
+> /exit
+```
+
+### Resume the Most Recent Session
+
+```bash
+# Continúa donde lo dejaste
+copilot --continue
+```
+
+### Resume a Specific Session
+
+```bash
+# Selecciona de una lista de sesiones de forma interactiva
+copilot --resume
+
+# O reanuda una sesión específica por su ID
+copilot --resume=abc123
+
+# O reanuda por el nombre que le diste a la sesión
+copilot --resume="my book app review"
+```
+
+> 💡 **¿Cómo encuentro un ID de sesión?** No necesitas memorizarlos. Ejecutar `copilot --resume` sin un ID muestra una lista interactiva de tus sesiones previas, sus nombres, IDs y cuándo estuvieron activas por última vez. Simplemente elige la que quieras.
+>
+> **¿Y si tengo múltiples terminales?** Cada ventana de terminal es su propia sesión con su propio contexto. Si tienes Copilot CLI abierto en tres terminales, eso son tres sesiones separadas. Ejecutar `--resume` desde cualquier terminal te permite explorar todas ellas. La bandera `--continue` toma la sesión del directorio de trabajo actual primero; si no existe allí, elige la sesión más recientemente activa.
+>
+> **¿Puedo cambiar de sesión sin reiniciar?** Sí. Usa el comando con barra `/resume` desde dentro de una sesión activa:
+> ```
+> > /resume
+> # Shows a list of sessions to switch to
+> ```
+
+### Organize Your Sessions
+
+Da a las sesiones nombres significativos para que las puedas encontrar después. Puedes nombrar una sesión cuando la inicias, o renombrarla en cualquier momento mientras estás dentro de la sesión:
+
+```bash
+# Nombra una sesión justo cuando la inicias
+copilot --name book-app-review
+
+# O renombra la sesión actual desde dentro
+copilot
+
+> /rename book-app-review
+# Sesión renombrada para facilitar su identificación
+```
+
+Una vez que una sesión tiene nombre, puedes reanudarla directamente por nombre sin navegar por la lista:
+
+```bash
+copilot --resume=book-app-review
+```
+
+Para limpiar sesiones que ya no necesitas, usa `/session delete` desde dentro de una sesión:
+
+```bash
+copilot
+
+> /session delete # Elimina la sesión actual
+> /session delete abc123 # Elimina una sesión específica por ID
+> /session delete-all # Elimina todas las sesiones (¡usar con precaución!)
+```
+
+### Check and Manage Context
+
+A medida que añades archivos y conversación, la [ventana de contexto](../GLOSSARY.md#context-window) de Copilot CLI se llena. Hay varios comandos disponibles para ayudarte a mantener el control:
+
+```bash
+copilot
+
+> /context
+Context usage: 62k/200k tokens (31%)
+
+> /clear
+# Abandona la sesión actual (no se guarda el historial) y comienza una conversación nueva
+
+> /new
+# Finaliza la sesión actual (guardándola en el historial para búsqueda/reanudación) y comienza una conversación nueva
+
+> /rewind
+# Abre un selector de línea de tiempo que te permite retroceder a un punto anterior de tu conversación
+```
+
+> 💡 **¿Cuándo usar `/clear` o `/new`?** Si has estado revisando books.py y quieres cambiar a discutir utils.py, ejecuta /new primero (o /clear si no necesitas el historial de la sesión). De lo contrario, el contexto obsoleto del tema anterior puede confundir las respuestas.
+
+> 💡 **¿Cometiste un error o quieres probar un enfoque distinto?** Usa `/rewind` (o presiona Esc dos veces) para abrir un **selector de línea de tiempo** que te permite retroceder a cualquier punto anterior en tu conversación, no solo al más reciente. Esto es útil cuando te desviastes por un camino equivocado y quieres retroceder sin empezar de nuevo por completo.
+
+---
+
+### Pick Up Where You Left Off
+
+🎬 Observa una conversación de varios turnos en acción!
+ + + +*La salida de la demostración varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+*Las sesiones se guardan automáticamente cuando sales. Reanuda días después con todo el contexto: archivos, problemas y progreso, todo recordado.*
+
+Imagina este flujo de trabajo a lo largo de varios días:
+
+```bash
+# Lunes: Comenzar la revisión de la aplicación de libros con un nombre desde el principio
+copilot --name book-app-review
+
+> @samples/book-app-project/books.py
+> Review and number all code quality issues
+
+Quality Issues Found:
+1. Duplicate display functions (book_app.py & utils.py) - MEDIUM
+2. No input validation for empty strings - MEDIUM
+3. Year can be 0 or negative - LOW
+4. No type hints on all functions - LOW
+5. Missing error logging - LOW
+
+> Fix issue #1 (funciones duplicadas)
+# Trabajar en la corrección...
+
+> /exit
+```
+
+```bash
+# Miércoles: Reanuda exactamente donde lo dejaste, por nombre
+copilot --resume=book-app-review
+
+> What issues remain unfixed from our book app review?
+
+Remaining issues from our book-app-review session:
+2. No input validation for empty strings - MEDIUM
+3. Year can be 0 or negative - LOW
+4. No type hints on all functions - LOW
+5. Missing error logging - LOW
+
+Issue #1 (funciones duplicadas) se corrigió el lunes.
+
+> Let's tackle issue #2 next
+```
+
+**Qué lo hace poderoso**: Días después, Copilot CLI recuerda:
+- El archivo exacto en el que estabas trabajando
+- La lista numerada de problemas
+- Cuáles ya has solucionado
+- El contexto de tu conversación
+
+Sin volver a explicar. Sin volver a leer archivos. Simplemente continúa trabajando.
+
+---
+
+**🎉 ¡Ahora conoces lo esencial!** La sintaxis `@`, la gestión de sesiones (`--name`/`--continue`/`--resume`/`/rename`) y los comandos de contexto (`/context`/`/clear`) son suficientes para ser muy productivo. Todo lo que sigue abajo es opcional. Vuelve a ello cuando estés listo.
+
+---
+
+# Optional: Going Deeper
+
+
+
+Estos temas se basan en lo esencial anterior. **Elige lo que te interese, o salta a [Práctica](#el-espectro-de-especificidad).**
+
+| I want to learn about... | Jump to |
+|---|---|
+| Wildcard patterns and advanced session commands | [Additional @ Patterns & Session Commands](#check-and-manage-context) |
+| Building on context across multiple prompts | [Context-Aware Conversations](#patrones-adicionales) |
+| Token limits and `/compact` | [Understanding Context Windows](#compartir-tu-sesión) |
+| How to pick the right files to reference | [Choosing What to Reference](#el-comando-compact) |
+| Analyzing screenshots and mockups | [Working with Images](#qué-incluir-vs-excluir) |
+
+
+
+
+Patrones @ adicionales y comandos de sesión
+ + +### Patrones @ adicionales + +Para usuarios avanzados, Copilot CLI soporta patrones comodín y referencias a imágenes: + +| Pattern | Qué hace | +|---------|--------------| +| `@folder/*.py` | Todos los archivos .py en la carpeta | +| `@**/test_*.py` | Comodín recursivo: encuentra todos los archivos de prueba en cualquier lugar | +| `@image.png` | Archivo de imagen para revisión de la UI | + +```bash +copilot + +> Find all TODO comments in @samples/book-app-project/**/*.py +``` + +### Ver información de la sesión + +```bash +copilot + +> /session +# Muestra los detalles de la sesión actual y el resumen del espacio de trabajo + +> /usage +# Muestra métricas y estadísticas de la sesión +``` + +### Compartir tu sesión + +```bash +copilot + +> /share file ./my-session.md +# Exporta la sesión como un archivo Markdown + +> /share gist +# Crea un gist de GitHub con la sesión + +> /share html +# Exporta la sesión como un archivo HTML interactivo autocontenido +# Útil para compartir informes de sesión pulidos con compañeros de equipo o guardarlos para referencia +``` + +
+
+
+Conversaciones conscientes del contexto
+ + +### Conversaciones conscientes del contexto + +La magia ocurre cuando tienes conversaciones de varios turnos que se construyen unas sobre otras. + +#### Example: Progressive Enhancement + +```bash +copilot + +> @samples/book-app-project/books.py Review the BookCollection class + +Copilot CLI: "The class looks functional, but I notice: +1. Missing type hints on some methods +2. No validation for empty title/author +3. Could benefit from better error handling" + +> Add type hints to all methods + +Copilot CLI: "Here's the class with complete type hints..." +[Shows typed version] + +> Now improve error handling + +Copilot CLI: "Building on the typed version, here's improved error handling..." +[Adds validation and proper exceptions] + +> Generate tests for this final version + +Copilot CLI: "Based on the class with types and error handling..." +[Generates comprehensive tests] +``` + +Fíjate cómo cada instrucción se basa en el trabajo anterior. Este es el poder del contexto. + +
+
+
+*La ventana de contexto es como un escritorio: solo puede contener cierta cantidad a la vez. Archivos, historial de conversación y prompts del sistema consumen espacio.*
+
+#### Qué sucede cuando se alcanza el límite
+
+```bash
+copilot
+
+> /context
+
+Context usage: 45,000 / 128,000 tokens (35%)
+
+# A medida que agregas más archivos y conversaciones, esto crece
+
+> @large-codebase/
+
+Context usage: 120,000 / 128,000 tokens (94%)
+
+# Advertencia: Acercándose al límite de contexto
+
+> @another-large-file.py
+
+Context limit reached. Older context will be summarized.
+```
+
+#### El comando `/compact`
+
+Cuando tu contexto se está llenando pero no quieres perder la conversación, `/compact` resume tu historial para liberar tokens:
+
+```bash
+copilot
+
+> /compact
+# Resume el historial de la conversación, liberando espacio de contexto
+# Se preservan tus hallazgos y decisiones clave
+```
+
+#### Consejos de eficiencia del contexto
+
+| Situación | Acción | Por qué |
+|-----------|--------|-----|
+| Iniciar un nuevo tema | `/clear` | Elimina contexto irrelevante |
+| Tomaste el camino equivocado | `/rewind` | Retrocede a cualquier punto anterior |
+| Conversación larga | `/compact` | Resume el historial, libera tokens |
+| Necesitas archivo específico | `@file.py` no `@folder/` | Carga solo lo que necesitas |
+| Alcanzando límites | `/new` o `/clear` | Contexto fresco |
+| Múltiples temas | Usa `/rename` por tema | Fácil reanudar la sesión correcta |
+
+#### Buenas prácticas para bases de código grandes
+
+1. **Sé específico**: `@samples/book-app-project/books.py` en lugar de `@samples/book-app-project/`
+2. **Limpia el contexto entre temas**: Usa `/new` o `/clear` cuando cambies de enfoque
+3. **Usa `/compact`**: Resume la conversación para liberar contexto
+4. **Usa varias sesiones**: Una sesión por característica o tema
+
+
+
+Comprender las ventanas de contexto
+ + +### Comprender las ventanas de contexto + +Ya conoces `/context` y `/clear` de lo esencial. Aquí está la imagen más profunda de cómo funcionan las ventanas de contexto. + +Cada modelo de IA tiene una "ventana de contexto", que es la cantidad de texto que puede considerar a la vez. + +
+
+*La ventana de contexto es como un escritorio: solo puede contener cierta cantidad a la vez. Archivos, historial de conversación y prompts del sistema consumen espacio.*
+
+#### Qué sucede cuando se alcanza el límite
+
+```bash
+copilot
+
+> /context
+
+Context usage: 45,000 / 128,000 tokens (35%)
+
+# A medida que agregas más archivos y conversaciones, esto crece
+
+> @large-codebase/
+
+Context usage: 120,000 / 128,000 tokens (94%)
+
+# Advertencia: Acercándose al límite de contexto
+
+> @another-large-file.py
+
+Context limit reached. Older context will be summarized.
+```
+
+#### El comando `/compact`
+
+Cuando tu contexto se está llenando pero no quieres perder la conversación, `/compact` resume tu historial para liberar tokens:
+
+```bash
+copilot
+
+> /compact
+# Resume el historial de la conversación, liberando espacio de contexto
+# Se preservan tus hallazgos y decisiones clave
+```
+
+#### Consejos de eficiencia del contexto
+
+| Situación | Acción | Por qué |
+|-----------|--------|-----|
+| Iniciar un nuevo tema | `/clear` | Elimina contexto irrelevante |
+| Tomaste el camino equivocado | `/rewind` | Retrocede a cualquier punto anterior |
+| Conversación larga | `/compact` | Resume el historial, libera tokens |
+| Necesitas archivo específico | `@file.py` no `@folder/` | Carga solo lo que necesitas |
+| Alcanzando límites | `/new` o `/clear` | Contexto fresco |
+| Múltiples temas | Usa `/rename` por tema | Fácil reanudar la sesión correcta |
+
+#### Buenas prácticas para bases de código grandes
+
+1. **Sé específico**: `@samples/book-app-project/books.py` en lugar de `@samples/book-app-project/`
+2. **Limpia el contexto entre temas**: Usa `/new` o `/clear` cuando cambies de enfoque
+3. **Usa `/compact`**: Resume la conversación para liberar contexto
+4. **Usa varias sesiones**: Una sesión por característica o tema
+
+
+
+
+Eligiendo qué referenciar
+ + +### Eligiendo qué referenciar + +No todos los archivos son iguales cuando se trata de contexto. Aquí tienes cómo elegir sabiamente: + +#### Consideraciones sobre el tamaño de archivo + +| Tamaño del archivo | Aproximados [Tokens](../GLOSSARY.md#token) | Estrategia | +|-----------|-------------------|----------| +| Pequeño (<100 líneas) | ~500-1,500 tokens | Referenciar libremente | +| Mediano (100-500 líneas) | ~1,500-7,500 tokens | Referenciar archivos específicos | +| Grande (500+ líneas) | 7,500+ tokens | Sé selectivo, usa archivos específicos | +| Muy grande (1000+ líneas) | 15,000+ tokens | Considera dividir o apuntar a secciones | + +**Ejemplos concretos:** +- Los 4 archivos Python de la app de libros combinados ≈ 2,000-3,000 tokens +- Un módulo Python típico (200 líneas) ≈ 3,000 tokens +- Un archivo de API Flask (400 líneas) ≈ 6,000 tokens +- Tu package.json ≈ 200-500 tokens +- Un prompt corto + respuesta ≈ 500-1,500 tokens + +> 💡 **Estimación rápida para código:** Multiplica las líneas de código por ~15 para obtener los tokens aproximados. Ten en cuenta que esto es solo una estimación. + +#### Qué incluir vs. excluir + +**Alto valor** (incluir estos): +- Puntos de entrada (`book_app.py`, `main.py`, `app.py`) +- Los archivos específicos que estás consultando +- Archivos importados directamente por tu archivo objetivo +- Archivos de configuración (`requirements.txt`, `pyproject.toml`) +- Modelos de datos o dataclasses + +**Menor valor** (considera excluir): +- Archivos generados (salida compilada, assets empaquetados) +- node_modules o directorios vendor +- Archivos de datos grandes o fixtures +- Archivos no relacionados con tu pregunta + +#### El espectro de especificidad + +``` +Less specific ────────────────────────► More specific +@samples/book-app-project/ @samples/book-app-project/books.py:47-52 + │ │ + └─ Scans everything └─ Just what you need + (uses more context) (preserves context) +``` + +**Cuando ir amplio** (`@samples/book-app-project/`): +- Exploración inicial del código base +- Encontrar patrones a través de muchos archivos +- Revisiones de arquitectura + +**Cuando ir específico** (`@samples/book-app-project/books.py`): +- Depurar un problema en particular +- Revisión de código de un archivo específico +- Preguntar sobre una única función + +#### Ejemplo práctico: Carga de contexto por etapas + +```bash +copilot + +# Paso 1: Comienza con la estructura +> @package.json What frameworks does this project use? + +# Paso 2: Acota según la respuesta +> @samples/book-app-project/ Show me the project structure + +# Paso 3: Enfócate en lo que importa +> @samples/book-app-project/books.py Review the BookCollection class + +# Paso 4: Añade solo los archivos relacionados cuando sea necesario +> @samples/book-app-project/book_app.py @samples/book-app-project/books.py How does the CLI use the BookCollection? +``` + +Este enfoque por etapas mantiene el contexto enfocado y eficiente. + +
+
+
+---
+
+# Práctica
+
+Trabajar con imágenes
+ + +### Trabajar con imágenes + +Puedes incluir imágenes en tus conversaciones usando la sintaxis `@`, o simplemente **pegar desde tu portapapeles** (Cmd+V / Ctrl+V). Copilot CLI puede analizar capturas de pantalla, maquetas y diagramas para ayudar con la depuración de UI, la implementación de diseño y el análisis de errores. + +```bash +copilot + +> @images/screenshot.png What is happening in this image? + +> @images/mockup.png Write the HTML and CSS to match this design. Place it in a new file called index.html and put the CSS in styles.css. +``` + +> 📖 **Aprende más**: Consulta [Funciones adicionales de contexto](../appendices/additional-context.md#trabajar-con-imágenes) para formatos soportados, casos de uso prácticos y consejos para combinar imágenes con código. + +
+
+Es hora de aplicar tus habilidades de manejo de contexto y sesiones.
+
+---
+
+## ▶️ Inténtalo tú mismo
+
+### Revisión completa del proyecto
+
+El curso incluye archivos de muestra que puedes revisar directamente. Inicia copilot y ejecuta el prompt mostrado a continuación:
+
+```bash
+copilot
+
+> @samples/book-app-project/ Give me a code quality review of this project
+
+# Copilot CLI identificará problemas como:
+# - Funciones de visualización duplicadas
+# - Falta de validación de entradas
+# - Manejo inconsistente de errores
+```
+
+> 💡 **¿Quieres probar con tus propios archivos?** Crea un pequeño proyecto Python (`mkdir -p my-project/src`), añade algunos archivos .py, luego usa `@my-project/src/` para revisarlos. ¡Puedes pedirle a copilot que cree código de ejemplo si quieres!
+
+### Flujo de trabajo de la sesión
+
+```bash
+copilot
+
+> /rename book-app-review
+> @samples/book-app-project/books.py Let's add input validation for empty titles
+
+[Copilot CLI suggests validation approach]
+
+> Implement that fix
+> Now consolidate the duplicate display functions in @samples/book-app-project/
+> /exit
+
+# Más tarde - reanuda donde lo dejaste
+copilot --continue
+
+> Generate tests for the changes we made
+```
+
+---
+
+Después de completar las demos, prueba estas variaciones:
+
+1. **Desafío entre archivos**: Analiza cómo trabajan book_app.py y books.py juntos:
+ ```bash
+ copilot
+ > @samples/book-app-project/book_app.py @samples/book-app-project/books.py
+ > What's the relationship between these files? Are there any code smells?
+ ```
+
+2. **Desafío de sesión**: Inicia una sesión, asígnale nombre con `/rename my-first-session`, trabaja en algo, sal con `/exit`, luego ejecuta `copilot --continue`. ¿Recuerda lo que estabas haciendo?
+
+3. **Desafío de contexto**: Ejecuta `/context` a mitad de la sesión. ¿Cuántos tokens estás usando? Prueba `/compact` y verifica de nuevo. (Consulta [Comprender las ventanas de contexto](#compartir-tu-sesión) en Going Deeper para más sobre `/compact`.)
+
+**Autoevaluación**: Entiendes el contexto cuando puedes explicar por qué `@folder/` es más poderoso que abrir cada archivo individualmente.
+
+---
+
+## 📝 Tarea
+
+### Desafío principal: Rastrear el flujo de datos
+
+Los ejemplos prácticos se centraron en revisiones de calidad de código y validación de entradas. Ahora practica las mismas habilidades de contexto en una tarea diferente, rastreando cómo se mueven los datos a través de la aplicación:
+
+1. Inicia una sesión interactiva: `copilot`
+2. Referencia `books.py` y `book_app.py` juntos:
+ `@samples/book-app-project/books.py @samples/book-app-project/book_app.py Trace how a book goes from user input to being saved in data.json. What functions are involved at each step?`
+3. Trae el archivo de datos para contexto adicional:
+ `@samples/book-app-project/data.json What happens if this JSON file is missing or corrupted? Which functions would fail?`
+4. Pide una mejora entre archivos:
+ `@samples/book-app-project/books.py @samples/book-app-project/utils.py Suggest a consistent error-handling strategy that works across both files.`
+5. Renombra la sesión: `/rename data-flow-analysis`
+6. Sal con `/exit`, luego reanuda con `copilot --continue` y haz una pregunta de seguimiento sobre el flujo de datos
+
+**Criterios de éxito**: Puedes rastrear datos a través de múltiples archivos, reanudar una sesión nombrada y obtener sugerencias entre archivos.
+
+
+` - Nombra tu sesión para reanudarla fácilmente
+
+
+
+### Desafío extra: Límites de contexto
+
+1. Referencia todos los archivos de la app de libros a la vez con `@samples/book-app-project/`
+2. Haz varias preguntas detalladas sobre diferentes archivos (`books.py`, `utils.py`, `book_app.py`, `data.json`)
+3. Ejecuta `/context` para ver el uso. ¿Qué tan rápido se llena?
+4. Practica usando `/compact` para recuperar espacio, luego continúa la conversación
+5. Intenta ser más específico con las referencias de archivos (por ejemplo, `@samples/book-app-project/books.py` en lugar de toda la carpeta) y observa cómo afecta el uso del contexto
+
+---
+
+💡 Sugerencias (haz clic para expandir)
+ +**Para empezar:** +```bash +cd /path/to/copilot-cli-for-beginners +copilot +> @samples/book-app-project/books.py @samples/book-app-project/book_app.py Trace how a book goes from user input to being saved in data.json. +> @samples/book-app-project/data.json What happens if this file is missing or corrupted? +> /rename data-flow-analysis +> /exit +``` + +Luego reanuda con: `copilot --continue` + +**Comandos útiles:** +- `@file.py` - Referencia un solo archivo +- `@folder/` - Referencia todos los archivos en una carpeta (fíjate en la `/` final) +- `/context` - Verifica cuánto contexto estás usando +- `/rename
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **Sintaxis `@`** proporciona a Copilot CLI contexto sobre archivos, directorios e imágenes
+2. **Conversaciones de múltiples turnos** se construyen unas sobre otras a medida que el contexto se acumula
+3. **Las sesiones se guardan automáticamente**: nómbralas al inicio con `--name`, reanuda por nombre con `--resume=🔧 Errores comunes y solución de problemas (haz clic para expandir)
+ +### Errores comunes + +| Error | Qué sucede | Solución | +|---------|--------------|-----| +| Olvidar `@` antes de los nombres de archivo | Copilot CLI trata "books.py" como texto plano | Usa `@samples/book-app-project/books.py` para referenciar archivos | +| Esperar que las sesiones persistan automáticamente | Iniciar `copilot` de nuevo pierde todo el contexto previo | Usa `--continue` (última sesión) o `--resume` (elige una sesión) | +| Referenciar archivos fuera del directorio actual | "Permission denied" or "File not found" errors | Usa `/add-dir /path/to/directory` para otorgar acceso | +| No usar `/clear` al cambiar de tema | El contexto antiguo confunde las respuestas sobre el nuevo tema | Ejecuta `/clear` antes de empezar una tarea diferente | + +### Solución de problemas + +**"File not found" errors** - Asegúrate de estar en el directorio correcto: + +```bash +pwd # Comprobar el directorio actual +ls # Listar archivos + +# Luego inicia copilot y usa rutas relativas +copilot + +> Review @samples/book-app-project/books.py +``` + +**"Permission denied"** - Agrega el directorio a tu lista de permitidos: + +```bash +copilot --add-dir /path/to/directory + +# O en una sesión: +> /add-dir /path/to/directory +``` + +**El contexto se llena demasiado rápido**: +- Sé más específico con las referencias a archivos +- Usa `/clear` entre diferentes temas +- Divide el trabajo en varias sesiones + +
+
+De manera similar, los desarrolladores tienen flujos de trabajo para distintas tareas. GitHub Copilot CLI mejora cada uno de estos flujos, haciéndote más eficiente y eficaz en tus tareas diarias de programación.
+
+---
+
+# Los cinco flujos de trabajo
+
+
+
+Cada flujo de trabajo a continuación es autónomo. Elige los que se ajusten a tus necesidades actuales o recórrelos todos.
+
+---
+
+## Elige tu propia aventura
+
+Este capítulo cubre cinco flujos de trabajo que los desarrolladores suelen usar. **¡Sin embargo, no necesitas leerlos todos de una vez!** Cada flujo de trabajo está contenido en una sección plegable abajo. Elige los que coincidan con lo que necesitas y lo que mejor se adapte a tu proyecto actual. Siempre puedes volver y explorar los demás más tarde.
+
+
+
+| I want to... | Jump to |
+|---|---|
+| Review code before merging | [Workflow 1: Code Review](#workflow-1-code-review) |
+| Clean up messy or legacy code | [Workflow 2: Refactoring](#workflow-2-refactoring) |
+| Track down and fix a bug | [Workflow 3: Debugging](#workflow-3-debugging) |
+| Generate tests for my code | [Workflow 4: Test Generation](#workflow-4-test-generation) |
+| Write better commits and PRs | [Workflow 5: Git Integration](#workflow-5-git-integration) |
+| Research before coding | [Quick Tip: Research Before You Plan or Code](#revisar-antes-del-push) |
+| See a full bug-fix workflow end to end | [Putting It All Together](#usar-delegate-para-tareas-en-segundo-plano) |
+
+**Selecciona un flujo de trabajo abajo para expandirlo** y ver cómo GitHub Copilot CLI puede mejorar tu proceso de desarrollo en esa área.
+
+---
+
+
+
+
+
+### Revisión básica
+
+Este ejemplo usa el símbolo `@` para referenciar un archivo, otorgando a Copilot CLI acceso directo a su contenido para revisión.
+
+```bash
+copilot
+
+> Review @samples/book-app-project/book_app.py for code quality
+```
+
+---
+
+
+
+---
+
+
+Workflow 1: Code Review - Revisa archivos, usa el agente /review, crea listas de verificación por severidad
+ +
+
+### Revisión básica
+
+Este ejemplo usa el símbolo `@` para referenciar un archivo, otorgando a Copilot CLI acceso directo a su contenido para revisión.
+
+```bash
+copilot
+
+> Review @samples/book-app-project/book_app.py for code quality
+```
+
+---
+
+
+
+
+---
+
+### Revisión de validación de entrada
+
+Pide a Copilot CLI que enfoque su revisión en una preocupación específica (aquí, validación de entrada) enumerando las categorías que te interesan en el prompt.
+
+```text
+copilot
+
+> Review @samples/book-app-project/utils.py for input validation issues. Check for: missing validation, error handling gaps, and edge cases
+```
+
+
+### Revisión del proyecto en varios archivos
+
+Referencia todo un directorio con `@` para permitir que Copilot CLI escanee todos los archivos del proyecto a la vez.
+
+```bash
+copilot
+
+> @samples/book-app-project/ Review this entire project. Create a markdown checklist of issues found, categorized by severity
+```
+
+### Revisión de código interactiva
+
+Usa una conversación multi-turno para profundizar. Comienza con una revisión amplia y luego haz preguntas de seguimiento sin reiniciar.
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py Review this file for:
+> - Input validation
+> - Error handling
+> - Code style and best practices
+
+# Copilot CLI proporciona una revisión detallada
+
+> The user input handling - are there any edge cases I'm missing?
+
+# Copilot CLI muestra problemas potenciales con cadenas vacías y caracteres especiales
+
+> Create a checklist of all issues found, prioritized by severity
+
+# Copilot CLI genera elementos de acción priorizados
+```
+
+### Plantilla de lista de verificación para revisión
+
+Pide a Copilot CLI que estructure su salida en un formato específico (aquí, una lista de verificación en markdown categorizada por severidad que puedes pegar en un issue).
+
+```bash
+copilot
+
+> Review @samples/book-app-project/ and create a markdown checklist of issues found, categorized by:
+> - Critical (data loss risks, crashes)
+> - High (bugs, incorrect behavior)
+> - Medium (performance, maintainability)
+> - Low (style, minor improvements)
+```
+
+### Entendiendo los cambios en Git (Importante para /review)
+
+Antes de usar el comando `/review`, necesitas entender dos tipos de cambios en git:
+
+| Change Type | What It Means | How to See |
+|-------------|---------------|------------|
+| **Staged changes** | Files you've marked for the next commit with `git add` | `git diff --staged` |
+| **Unstaged changes** | Files you've modified but haven't added yet | `git diff` |
+
+```bash
+# Referencia rápida
+git status # Muestra tanto los cambios preparados como los no preparados
+git add file.py # Preparar un archivo para el commit
+git diff # Muestra cambios no preparados
+git diff --staged # Muestra cambios preparados
+```
+
+### Uso del comando /review
+
+El comando `/review` invoca el **agente de revisión de código** incorporado, que está optimizado para analizar cambios staged y unstaged con una salida de alta relación señal/ruido. Usa un comando con slash para activar un agente integrado especializado en lugar de escribir un prompt en lenguaje libre.
+
+```bash
+copilot
+
+> /review
+# Invoca al agente de revisión de código sobre cambios preparados/no preparados
+# Proporciona comentarios enfocados y accionables
+
+> /review Check for security issues in authentication
+# Ejecuta la revisión con un área de enfoque específica
+```
+
+> 💡 **Consejo**: El agente de revisión de código funciona mejor cuando tienes cambios pendientes. Etapa tus archivos con `git add` para revisiones más enfocadas.
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+
+### Refactorización simple
+
+> **Prueba esto primero:** `@samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.`
+
+Comienza con mejoras sencillas. Pruébalas en la aplicación de libros. Cada prompt usa una referencia de archivo `@` junto con una instrucción de refactorización específica para que Copilot CLI sepa exactamente qué cambiar.
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.
+
+> @samples/book-app-project/utils.py Add type hints to all functions
+
+> @samples/book-app-project/book_app.py Extract the book display logic into utils.py for better separation of concerns
+```
+
+> 💡 **¿Nuevo en refactorización?** Comienza con solicitudes simples como agregar type hints o mejorar nombres de variables antes de abordar transformaciones complejas.
+
+---
+
+
+
+---
+
+
+Workflow 2: Refactoring - Reestructura el código, separa responsabilidades, mejora el manejo de errores
+ +
+
+### Refactorización simple
+
+> **Prueba esto primero:** `@samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.`
+
+Comienza con mejoras sencillas. Pruébalas en la aplicación de libros. Cada prompt usa una referencia de archivo `@` junto con una instrucción de refactorización específica para que Copilot CLI sepa exactamente qué cambiar.
+
+```bash
+copilot
+
+> @samples/book-app-project/book_app.py The command handling uses if/elif chains. Refactor it to use a dictionary dispatch pattern.
+
+> @samples/book-app-project/utils.py Add type hints to all functions
+
+> @samples/book-app-project/book_app.py Extract the book display logic into utils.py for better separation of concerns
+```
+
+> 💡 **¿Nuevo en refactorización?** Comienza con solicitudes simples como agregar type hints o mejorar nombres de variables antes de abordar transformaciones complejas.
+
+---
+
+
+
+
+---
+
+### Separar responsabilidades
+
+Referencia múltiples archivos con `@` en un solo prompt para que Copilot CLI pueda mover código entre ellos como parte del refactor.
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py @samples/book-app-project/book_app.py
+> The utils.py file has print statements mixed with logic. Refactor to separate display functions from data processing.
+```
+
+### Mejorar el manejo de errores
+
+Proporciona dos archivos relacionados y describe la preocupación transversal para que Copilot CLI pueda sugerir una corrección coherente en ambos.
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py @samples/book-app-project/books.py
+> These files have inconsistent error handling. Suggest a unified approach using custom exceptions.
+```
+
+### Añadir documentación
+
+Usa una lista de viñetas detallada para especificar exactamente qué debe contener cada docstring.
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Add comprehensive docstrings to all methods:
+> - Include parameter types and descriptions
+> - Document return values
+> - Note any exceptions raised
+> - Add usage examples
+```
+
+### Refactorización segura con pruebas
+
+Encadena dos solicitudes relacionadas en una conversación multi-turno. Primero genera pruebas y luego refactoriza con esas pruebas como red de seguridad.
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Before refactoring, generate tests for current behavior
+
+# Escribe las pruebas primero
+
+> Now refactor the BookCollection class to use a context manager for file operations
+
+# Refactoriza con confianza - las pruebas verifican que el comportamiento se mantiene
+```
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+
+### Depuración simple
+
+> **Prueba esto primero:** `@samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.`
+
+Comienza describiendo qué está mal. Aquí hay patrones comunes de depuración que puedes probar con la aplicación de libros con errores. Cada prompt combina una referencia de archivo `@` con una descripción clara del síntoma para que Copilot CLI pueda localizar y diagnosticar el error.
+
+```bash
+copilot
+
+# Patrón: "Se esperaba X pero se obtuvo Y"
+> @samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.
+
+# Patrón: "Comportamiento inesperado"
+> @samples/book-app-buggy/book_app_buggy.py When I remove a book that doesn't exist, the app says it was removed. Help me find why.
+
+# Patrón: "Resultados incorrectos"
+> @samples/book-app-buggy/books_buggy.py When I mark one book as read, ALL books get marked. What's the bug?
+```
+
+> 💡 **Consejo de depuración**: Describe el *síntoma* (lo que ves) y la *expectativa* (lo que debería suceder). Copilot CLI se encarga del resto.
+
+---
+
+
+
+---
+
+
+Workflow 3: Debugging - Localiza errores, auditorías de seguridad, rastrea problemas a través de archivos
+ +
+
+### Depuración simple
+
+> **Prueba esto primero:** `@samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.`
+
+Comienza describiendo qué está mal. Aquí hay patrones comunes de depuración que puedes probar con la aplicación de libros con errores. Cada prompt combina una referencia de archivo `@` con una descripción clara del síntoma para que Copilot CLI pueda localizar y diagnosticar el error.
+
+```bash
+copilot
+
+# Patrón: "Se esperaba X pero se obtuvo Y"
+> @samples/book-app-buggy/books_buggy.py Users report that searching for "The Hobbit" returns no results even though it's in the data. Debug why.
+
+# Patrón: "Comportamiento inesperado"
+> @samples/book-app-buggy/book_app_buggy.py When I remove a book that doesn't exist, the app says it was removed. Help me find why.
+
+# Patrón: "Resultados incorrectos"
+> @samples/book-app-buggy/books_buggy.py When I mark one book as read, ALL books get marked. What's the bug?
+```
+
+> 💡 **Consejo de depuración**: Describe el *síntoma* (lo que ves) y la *expectativa* (lo que debería suceder). Copilot CLI se encarga del resto.
+
+---
+
+
+
+
+---
+
+### El "Detective de bugs" - La IA encuentra bugs RELACIONADOS
+
+Aquí es donde la depuración con contexto brilla. Prueba este escenario con la aplicación de libros con errores. Proporciona el archivo completo mediante `@` y describe solo el síntoma informado por el usuario. Copilot CLI trazará la causa raíz y puede encontrar errores adicionales cercanos.
+
+```bash
+copilot
+
+> @samples/book-app-buggy/books_buggy.py
+>
+> Users report: "Finding books by author name doesn't work for partial names"
+> Debug why this happens
+```
+
+**Lo que hace Copilot CLI**:
+```
+Root Cause: Line 80 uses exact match (==) instead of partial match (in).
+
+Line 80: return [b for b in self.books if b.author == author]
+
+The find_by_author function requires an exact match. Searching for "Tolkien"
+won't find books by "J.R.R. Tolkien".
+
+Fix: Change to case-insensitive partial match:
+return [b for b in self.books if author.lower() in b.author.lower()]
+```
+
+**Por qué importa**: Copilot CLI lee todo el archivo, comprende el contexto de tu informe de error y te da una solución específica con una explicación clara.
+
+> 💡 **Bonus**: Debido a que Copilot CLI analiza todo el archivo, a menudo descubre *otros* problemas sobre los que no preguntaste. Por ejemplo, al arreglar la búsqueda por autor, Copilot CLI podría notar también el bug de sensibilidad a mayúsculas en `find_book_by_title`!
+
+### Barra lateral de seguridad en el mundo real
+
+Aunque depurar tu propio código es importante, entender las vulnerabilidades de seguridad en aplicaciones en producción es crítico. Prueba este ejemplo: señala a Copilot CLI un archivo desconocido y pídele auditarlo en busca de problemas de seguridad.
+
+```bash
+copilot
+
+> @samples/buggy-code/python/user_service.py Find all security vulnerabilities in this Python user service
+```
+
+Este archivo demuestra patrones de seguridad del mundo real que encontrarás en aplicaciones de producción.
+
+> 💡 **Términos comunes de seguridad que encontrarás:**
+> - **Inyección SQL**: Cuando la entrada del usuario se pone directamente en una consulta a la base de datos, permitiendo que atacantes ejecuten comandos maliciosos
+> - **Consultas parametrizadas**: La alternativa segura: marcadores (`?`) separan los datos del usuario de los comandos SQL
+> - **Condición de carrera**: Cuando dos operaciones ocurren al mismo tiempo y se interfieren entre sí
+> - **XSS (Cross-Site Scripting)**: Cuando atacantes inyectan scripts maliciosos en páginas web
+
+---
+
+### Entendiendo un error
+
+Pega un stack trace directamente en tu prompt junto con una referencia de archivo `@` para que Copilot CLI pueda mapear el error al código fuente.
+
+```bash
+copilot
+
+> I'm getting this error:
+> AttributeError: 'NoneType' object has no attribute 'title'
+> at show_books (book_app.py:19)
+>
+> @samples/book-app-project/book_app.py Explain why and how to fix it
+```
+
+### Depuración con caso de prueba
+
+Describe la entrada exacta y la salida observada para darle a Copilot CLI un caso de prueba concreto y reproducible sobre el que razonar.
+
+```bash
+copilot
+
+> @samples/book-app-buggy/books_buggy.py The remove_book function has a bug. When I try to remove "Dune",
+> it also removes "Dune Messiah". Debug this: explain the root cause and provide a fix.
+```
+
+### Rastrear un problema a través del código
+
+Referencia múltiples archivos y pide a Copilot CLI que siga el flujo de datos entre ellos para localizar dónde se origina el problema.
+
+```bash
+copilot
+
+> Users report that the book list numbering starts at 0 instead of 1.
+> @samples/book-app-buggy/book_app_buggy.py @samples/book-app-buggy/books_buggy.py
+> Trace through the list display flow and identify where the issue occurs
+```
+
+### Entendiendo problemas de datos
+
+Incluye un archivo de datos junto con el código que lo lee para que Copilot CLI entienda el panorama completo al sugerir mejoras en el manejo de errores.
+
+```bash
+copilot
+
+> @samples/book-app-project/data.json @samples/book-app-project/books.py
+> Sometimes the JSON file gets corrupted and the app crashes. How should we handle this gracefully?
+```
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+
+> **Prueba esto primero:** `@samples/book-app-project/books.py Generate pytest tests for all functions including edge cases`
+
+### La "Explosión de pruebas" - 2 pruebas vs 15+ pruebas
+
+Al escribir pruebas manualmente, los desarrolladores típicamente crean 2-3 pruebas básicas:
+- Probar entrada válida
+- Probar entrada inválida
+- Probar un caso límite
+
+Observa lo que ocurre cuando pides a Copilot CLI generar pruebas exhaustivas. Este prompt usa una lista de viñetas estructurada con una referencia de archivo `@` para guiar a Copilot CLI hacia una cobertura de prueba completa:
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Generate comprehensive pytest tests. Include tests for:
+> - Adding books
+> - Removing books
+> - Finding by title
+> - Finding by author
+> - Marking as read
+> - Edge cases with empty data
+```
+
+---
+
+
+
+---
+
+
+Workflow 4: Test Generation - Genera pruebas y casos límite de forma automática
+ +
+
+> **Prueba esto primero:** `@samples/book-app-project/books.py Generate pytest tests for all functions including edge cases`
+
+### La "Explosión de pruebas" - 2 pruebas vs 15+ pruebas
+
+Al escribir pruebas manualmente, los desarrolladores típicamente crean 2-3 pruebas básicas:
+- Probar entrada válida
+- Probar entrada inválida
+- Probar un caso límite
+
+Observa lo que ocurre cuando pides a Copilot CLI generar pruebas exhaustivas. Este prompt usa una lista de viñetas estructurada con una referencia de archivo `@` para guiar a Copilot CLI hacia una cobertura de prueba completa:
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Generate comprehensive pytest tests. Include tests for:
+> - Adding books
+> - Removing books
+> - Finding by title
+> - Finding by author
+> - Marking as read
+> - Edge cases with empty data
+```
+
+---
+
+
+
+
+---
+
+**Lo que obtienes**: 15+ pruebas exhaustivas incluyendo:
+
+```python
+class TestBookCollection:
+ # Camino feliz
+ def test_add_book_creates_new_book(self):
+ ...
+ def test_list_books_returns_all_books(self):
+ ...
+
+ # Operaciones de búsqueda
+ def test_find_book_by_title_case_insensitive(self):
+ ...
+ def test_find_book_by_title_returns_none_when_not_found(self):
+ ...
+ def test_find_by_author_partial_match(self):
+ ...
+ def test_find_by_author_case_insensitive(self):
+ ...
+
+ # Casos límite
+ def test_add_book_with_empty_title(self):
+ ...
+ def test_remove_nonexistent_book(self):
+ ...
+ def test_mark_as_read_nonexistent_book(self):
+ ...
+
+ # Persistencia de datos
+ def test_save_books_persists_to_json(self):
+ ...
+ def test_load_books_handles_missing_file(self):
+ ...
+ def test_load_books_handles_corrupted_json(self):
+ ...
+
+ # Caracteres especiales
+ def test_add_book_with_unicode_characters(self):
+ ...
+ def test_find_by_author_with_special_characters(self):
+ ...
+```
+
+**Resultado**: En 30 segundos, obtienes pruebas de casos límite que tomarían una hora en pensar y escribir.
+
+---
+
+### Pruebas unitarias
+
+Apunta a una sola función y enumera las categorías de entrada que quieres probar para que Copilot CLI genere pruebas unitarias enfocadas y completas.
+
+```bash
+copilot
+
+> @samples/book-app-project/utils.py Generate comprehensive pytest tests for get_book_details covering:
+> - Valid input
+> - Empty strings
+> - Invalid year formats
+> - Very long titles
+> - Special characters in author names
+```
+
+### Ejecutar pruebas
+
+Hazle a Copilot CLI una pregunta en lenguaje natural sobre tu cadena de herramientas. Puede generar el comando shell correcto para ti.
+
+```bash
+copilot
+
+> How do I run the tests? Show me the pytest command.
+
+# Copilot CLI responde:
+# cd samples/book-app-project && python -m pytest tests/
+# O para salida detallada: python -m pytest tests/ -v
+# Para ver las sentencias print: python -m pytest tests/ -s
+```
+
+### Prueba escenarios específicos
+
+Enumera escenarios avanzados o complicados que quieras cubrir para que Copilot CLI vaya más allá del camino feliz.
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py Generate tests for these scenarios:
+> - Adding duplicate books (same title and author)
+> - Removing a book by partial title match
+> - Finding books when collection is empty
+> - File permission errors during save
+> - Concurrent access to the book collection
+```
+
+### Agregar pruebas al archivo existente
+
+Ask for *additional* tests for a single function so Copilot CLI generates new cases that complement what you already have.
+
+```bash
+copilot
+
+> @samples/book-app-project/books.py
+> Generate additional tests for the find_by_author function with edge cases:
+> - Author name with hyphens (e.g., "Jean-Paul Sartre")
+> - Author with multiple first names
+> - Empty string as author
+> - Author name with accented characters
+```
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas serán diferentes a lo que se muestra aquí.* + +
+
+
+> 💡 **Este flujo de trabajo asume familiaridad básica con git** (preparar cambios, commits, ramas). Si git es nuevo para ti, prueba primero los otros cuatro flujos de trabajo.
+
+### Generar mensajes de commit
+
+> **Intenta esto primero:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — prepara algunos cambios, luego ejecuta esto para ver cómo Copilot CLI escribe tu mensaje de commit.
+
+This example uses the `-p` inline prompt flag with shell command substitution to pipe `git diff` output directly into Copilot CLI for a one-shot commit message. The `$(...)` syntax runs the command inside the parentheses and inserts its output into the outer command.
+
+```bash
+
+# Ver qué cambió
+git diff --staged
+
+# Generar mensaje de commit usando el formato [Conventional Commit](../GLOSSARY.md#conventional-commit)
+# (mensajes estructurados como "feat(books): agregar búsqueda" o "fix(data): manejar entrada vacía")
+copilot -p "Generate a conventional commit message for: $(git diff --staged)"
+
+# Salida: "feat(books): agregar búsqueda parcial de nombre de autor
+#
+# - Actualizar find_by_author para admitir coincidencias parciales
+# - Añadir comparación sin distinción entre mayúsculas y minúsculas
+# - Mejorar la experiencia del usuario al buscar autores"
+```
+
+---
+
+
+
+---
+
+## Consejo rápido: Investigar antes de planear o codificar
+
+When you need to investigate a library, understand best practices, or explore an unfamiliar topic, use `/research` to run a deep research investigation before writing any code:
+
+```bash
+copilot
+
+> /research What are the best Python libraries for validating user input in CLI apps?
+```
+
+Copilot searches GitHub repositories and web sources, then returns a summary with references. This is useful when you're about to start a new feature and want to make informed decisions first. You can share the results using `/share`.
+
+> 💡 **Consejo**: `/research` funciona bien *antes* de `/plan`. Investiga el enfoque, luego planifica la implementación.
+
+---
+
+## Poniéndolo todo junto: flujo de trabajo de corrección de errores
+
+Here's a complete workflow for fixing a reported bug:
+
+```bash
+
+# 1. Comprender el informe de errores
+copilot
+
+> Users report: 'Finding books by author name doesn't work for partial names'
+> @samples/book-app-project/books.py Analyze and identify the likely cause
+
+# 2. Depurar el problema y corregirlo (continuando en la misma sesión)
+> Based on the analysis, show me the find_by_author function and explain the issue
+
+> Fix the find_by_author function to handle partial name matches
+
+# 3. Generar pruebas para la corrección
+> @samples/book-app-project/books.py Generate pytest tests specifically for:
+> - Full author name match
+> - Partial author name match
+> - Case-insensitive matching
+> - Author name not found
+
+# Salir de la sesión interactiva
+
+> /exit
+
+# 4. Ejecutar git add
+
+# Poner los cambios en el área de preparación para que git diff --staged tenga algo con lo que trabajar
+git add .
+
+# 5. Generar el mensaje de commit
+copilot -p "Generate commit message for: $(git diff --staged)"
+
+# Example Output: "fix(books): soportar búsqueda parcial por nombre de autor"
+
+# 6. Confirmar los cambios (opcional)
+
+git commit -m "Flujo de trabajo 5: Integración con Git - Mensajes de commit, descripciones de PR, /pr, /delegate y /diff
+ +
+
+> 💡 **Este flujo de trabajo asume familiaridad básica con git** (preparar cambios, commits, ramas). Si git es nuevo para ti, prueba primero los otros cuatro flujos de trabajo.
+
+### Generar mensajes de commit
+
+> **Intenta esto primero:** `copilot -p "Generate a conventional commit message for: $(git diff --staged)"` — prepara algunos cambios, luego ejecuta esto para ver cómo Copilot CLI escribe tu mensaje de commit.
+
+This example uses the `-p` inline prompt flag with shell command substitution to pipe `git diff` output directly into Copilot CLI for a one-shot commit message. The `$(...)` syntax runs the command inside the parentheses and inserts its output into the outer command.
+
+```bash
+
+# Ver qué cambió
+git diff --staged
+
+# Generar mensaje de commit usando el formato [Conventional Commit](../GLOSSARY.md#conventional-commit)
+# (mensajes estructurados como "feat(books): agregar búsqueda" o "fix(data): manejar entrada vacía")
+copilot -p "Generate a conventional commit message for: $(git diff --staged)"
+
+# Salida: "feat(books): agregar búsqueda parcial de nombre de autor
+#
+# - Actualizar find_by_author para admitir coincidencias parciales
+# - Añadir comparación sin distinción entre mayúsculas y minúsculas
+# - Mejorar la experiencia del usuario al buscar autores"
+```
+
+---
+
+
+
+
+---
+
+### Explicar cambios
+
+Pasa la salida de `git show` a un prompt `-p` para obtener un resumen en lenguaje natural del último commit.
+
+```bash
+# ¿Qué cambió este commit?
+copilot -p "Explain what this commit does: $(git show HEAD --stat)"
+```
+
+### Descripción de PR
+
+Combina la salida de `git log` con una plantilla de prompt estructurada para generar automáticamente una descripción completa del pull request.
+
+```bash
+# Generar la descripción del PR a partir de los cambios en la rama
+copilot -p "Generate a pull request description for these changes:
+$(git log main..HEAD --oneline)
+
+Include:
+- Summary of changes
+- Why these changes were made
+- Testing done
+- Breaking changes? (yes/no)"
+```
+
+### Usar /pr en modo interactivo para la rama actual
+
+Si estás trabajando con una rama en el modo interactivo de Copilot CLI, puedes usar el comando `/pr` para trabajar con pull requests. Usa `/pr` para ver un PR, crear uno nuevo, arreglar un PR existente o dejar que Copilot CLI decida automáticamente según el estado de la rama.
+
+```bash
+copilot
+
+> /pr [view|create|fix|auto]
+```
+
+### Revisar antes del push
+
+Usa `git diff main..HEAD` dentro de un prompt `-p` para una verificación rápida (pre-push) de todos los cambios de la rama.
+
+```bash
+# Última revisión antes de hacer push
+copilot -p "Review these changes for issues before I push:
+$(git diff main..HEAD)"
+```
+
+### Usar /delegate para tareas en segundo plano
+
+El comando `/delegate` delega trabajo al agente en la nube de GitHub Copilot. Usa el comando slash `/delegate` (o el atajo `&`) para descargar una tarea bien definida a un agente en segundo plano.
+
+```bash
+copilot
+
+> /delegate Add input validation to the login form
+
+# O usa el atajo con el prefijo &:
+> & Fix the typo in the README header
+
+# Copilot CLI:
+# 1. Confirma tus cambios en una nueva rama
+# 2. Abre un pull request en borrador
+# 3. Funciona en segundo plano en GitHub
+# 4. Solicita tu revisión cuando termine
+```
+
+This is great for well-defined tasks you want completed while you focus on other work.
+
+### Usar /diff para revisar los cambios de la sesión
+
+El comando `/diff` muestra todos los cambios realizados durante tu sesión actual. Usa este comando slash para ver un diff visual de todo lo que Copilot CLI ha modificado antes de que confirmes los cambios.
+
+```bash
+copilot
+
+# Después de hacer algunos cambios...
+> /diff
+
+# Muestra una comparación visual de todos los archivos modificados en esta sesión
+# Ideal para revisar antes de confirmar los cambios
+```
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demostración varía. Tu modelo, herramientas y respuestas diferirán de lo que se muestra aquí.* + +
+
+Ahora es tu turno para aplicar estos flujos de trabajo.
+
+---
+
+## ▶️ Inténtalo tú mismo
+
+After completing the demos, try these variations:
+
+1. **Desafío detective de bugs**: Pídele a Copilot CLI que depure la función `mark_as_read` en `samples/book-app-buggy/books_buggy.py`. ¿Explicó por qué la función marca TODOS los libros como leídos en vez de solo uno?
+2. **Desafío de pruebas**: Genera pruebas para la función `add_book` en la aplicación de libros. Cuenta cuántos casos límite incluye Copilot CLI que tú no habrías pensado.
+3. **Desafío de mensaje de commit**: Haz cualquier cambio pequeño en un archivo de la aplicación de libros, agrégalo al área de staging (`git add .`), luego ejecuta:
+ ```bash
+ copilot -p "Generate a conventional commit message for: $(git diff --staged)"
+ ```
+ ¿Es el mensaje mejor que lo que hubieras escrito rápidamente?
+
+**Autoevaluación**: Entiendes los flujos de trabajo de desarrollo cuando puedas explicar por qué "depurar este bug" es más poderoso que "encontrar bugs" (¡el contexto importa!).
+
+---
+
+## 📝 Tarea
+
+### Desafío principal: Refactorizar, probar y entregar
+
+The hands-on examples focused on `find_book_by_title` and code reviews. Now practice the same workflow skills on different functions in `book-app-project`:
+
+1. **Revisar**: Pide a Copilot CLI que revise `remove_book()` en `books.py` en busca de casos límite y problemas potenciales:
+ `@samples/book-app-project/books.py Review the remove_book() function. What happens if the title partially matches another book (e.g., "Dune" vs "Dune Messiah")? Are there any edge cases not handled?`
+2. **Refactorizar**: Pide a Copilot CLI que mejore `remove_book()` para manejar casos límite como coincidencia sin distinguir mayúsculas/minúsculas y devolver retroalimentación útil cuando no se encuentra un libro
+3. **Probar**: Genera pruebas con pytest específicamente para la función `remove_book()` mejorada, cubriendo:
+ - Eliminar un libro que existe
+ - Coincidencia de título sin distinguir mayúsculas/minúsculas
+ - Un libro que no existe devuelve retroalimentación apropiada
+ - Eliminar de una colección vacía
+4. **Revisión**: Pon tus cambios en staging y ejecuta `/review` para comprobar si quedan problemas
+5. **Commit**: Genera un mensaje de commit convencional:
+ `copilot -p "Generate a conventional commit message for: $(git diff --staged)"`
+
+
+
+
+### Bonus Challenge: Create an application with the Copilot CLI
+
+> 💡 **Nota**: Este ejercicio de GitHub Skills usa **Node.js** en lugar de Python. Las técnicas de GitHub Copilot CLI que practicarás - crear issues, generar código y colaborar desde la terminal - aplican a cualquier lenguaje.
+
+The exercise shows developers how to use GitHub Copilot CLI to create issues, generate code, and collaborate from the terminal while building a Node.js calculator app. You'll install the CLI, use templates and agents, and practice iterative, command-line driven development.
+
+##### 💡 Sugerencias (haz clic para expandir)
+ +**Ejemplos de prompts para cada paso:** + +```bash +copilot + +# Paso 1: Revisar +> @samples/book-app-project/books.py Review the remove_book() function. What edge cases are not handled? + +# Paso 2: Refactorizar +> Improve remove_book() to use case-insensitive matching and return a clear message when the book isn't found. Show me the before and after code. + +# Paso 3: Probar +> Generate pytest tests for the improved remove_book() function, including: +> - Removing a book that exists +> - Case-insensitive matching ("dune" should remove "Dune") +> - Book not found returns appropriate response +> - Removing from an empty collection + +# Paso 4: Revisar +> /review + +# Paso 5: Confirmar +> Generate a conventional commit message for this refactor +``` + +**Consejo:** Después de mejorar `remove_book()`, prueba a preguntarle a Copilot CLI: "¿Hay otras funciones en este archivo que podrían beneficiarse de las mismas mejoras?". Puede sugerir cambios similares en `find_book_by_title()` o `find_by_author()`. + +
[Iniciar el ejercicio de Skills "Crear aplicaciones con el Copilot CLI"](https://github.com/skills/create-applications-with-the-copilot-cli)
+
+---
+
+
+
+
+---
+
+# Resumen
+
+## 🔑 Conclusiones clave
+
+🔧 Errores comunes y solución de problemas (haz clic para expandir)
+ +### Errores comunes + +| Error | Qué pasa | Solución | +|---------|--------------|-----| +| Usar prompts vagos como "Revisa este código" | Retroalimentación genérica que omite problemas específicos | Sé específico: "Revisa para inyección SQL, XSS y problemas de autenticación" | +| No usar `/review` para revisiones de código | Pierdes el agente optimizado para revisión de código | Usa `/review`, que está ajustado para una salida con alta relación señal/ruido | +| Pedir "find bugs" sin contexto | Copilot CLI no sabe qué error estás experimentando | Describe el síntoma: "Los usuarios reportan que X sucede cuando Y" | +| Generar pruebas sin especificar el framework | Las pruebas pueden usar sintaxis incorrecta o una biblioteca de aserciones equivocada | Especifica: "Generar pruebas usando Jest" o "usando pytest" | + +### Solución de problemas + +**La revisión parece incompleta** - Sé más específico sobre qué buscar: + +```bash +copilot + +# En lugar de: +> Review @samples/book-app-project/book_app.py + +# Prueba: +> Review @samples/book-app-project/book_app.py for input validation, error handling, and edge cases +``` + +**Las pruebas no coinciden con mi framework** - Especifica el framework: + +```bash +copilot + +> @samples/book-app-project/books.py Generate tests using pytest (not unittest) +``` + +**La refactorización cambia el comportamiento** - Pide a Copilot CLI que preserve el comportamiento: + +```bash +copilot + +> @samples/book-app-project/book_app.py Refactor command handling to use dictionary dispatch. IMPORTANT: Maintain identical external behavior - no breaking changes +``` + +
+
+1. **La revisión de código se vuelve más completa con prompts específicos**
+2. **La refactorización es más segura cuando generas pruebas primero**
+3. **La depuración se beneficia de mostrar a Copilot CLI el error Y el código**
+4. **La generación de pruebas debe incluir casos límite y escenarios de error**
+5. **La integración con Git automatiza mensajes de commit y descripciones de PR**
+
+> 📋 **Referencia rápida**: Consulta la [referencia de comandos de GitHub Copilot CLI](https://docs.github.com/en/copilot/reference/cli-command-reference) para una lista completa de comandos y atajos.
+
+---
+
+## ✅ Punto de control: Has dominado lo esencial
+
+**¡Felicidades!** Ahora tienes todas las habilidades básicas para ser productivo con GitHub Copilot CLI:
+
+| Habilidad | Capítulo | Ahora puedes... |
+|-------|---------|----------------|
+| Comandos básicos | Cap 01 | Usar el modo interactivo, modo plan, modo programático (-p), y comandos slash |
+| Contexto | Cap 02 | Referenciar archivos con `@`, gestionar sesiones, entender las ventanas de contexto |
+| Flujos de trabajo | Cap 03 | Revisar código, refactorizar, depurar, generar pruebas, integrar con git |
+
+Los capítulos 04-06 cubren características adicionales que añaden aún más potencia y vale la pena aprender.
+
+---
+
+## 🛠️ Construyendo tu flujo de trabajo personal
+
+No hay una única forma "correcta" de usar GitHub Copilot CLI. Aquí tienes algunos consejos mientras desarrollas tus propios patrones:
+
+> 📚 **Documentación oficial**: [Buenas prácticas de Copilot CLI](https://docs.github.com/copilot/how-tos/copilot-cli/cli-best-practices) para flujos de trabajo recomendados y consejos de GitHub.
+
+- **Empieza con `/plan`** para cualquier cosa no trivial. Refina el plan antes de la ejecución: un buen plan conduce a mejores resultados.
+- **Guarda los prompts que funcionen bien.** Cuando Copilot CLI cometa un error, anota qué salió mal. Con el tiempo, esto se convierte en tu manual personal.
+- **Experimenta libremente.** Algunos desarrolladores prefieren prompts largos y detallados. Otros prefieren prompts cortos con seguimientos. Prueba diferentes enfoques y observa qué se siente más natural.
+
+> 💡 **Próximo**: En los capítulos 04 y 05 aprenderás cómo codificar tus mejores prácticas en instrucciones personalizadas y habilidades que Copilot CLI carga automáticamente.
+
+---
+
+## ➡️ Qué sigue
+
+| Capítulo | Qué cubre | Cuándo lo necesitarás |
+|---------|----------------|---------------------|
+| Ch 04: Agents | Crear personajes de IA especializados | Cuando quieras expertos de dominio (frontend, seguridad) |
+| Ch 05: Skills | Cargar automáticamente instrucciones para tareas | Cuando repites los mismos prompts con frecuencia |
+| Ch 06: MCP | Conectar servicios externos | Cuando necesites datos en vivo desde GitHub, bases de datos |
+
+**Recomendación**: Prueba los flujos de trabajo principales durante una semana, luego vuelve a los capítulos 04-06 cuando tengas necesidades específicas.
+
+---
+
+## Continúa con temas adicionales
+
+En **[Capítulo 04: Agentes e instrucciones personalizadas](../04-agents-custom-instructions/README.md)**, aprenderás:
+
+- Usar agentes integrados (`/plan`, `/review`)
+- Crear agentes especializados (experto frontend, auditor de seguridad) con archivos `.agent.md`
+- Patrones de colaboración multi-agente
+- Archivos de instrucciones personalizadas para estándares del proyecto
+
+---
+
+**[← Volver al Capítulo 02](../02-context-conversations/README.md)** | **[Continuar al Capítulo 04 →](../04-agents-custom-instructions/README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/04-agents-custom-instructions/README.md b/translations/es/04-agents-custom-instructions/README.md
new file mode 100644
index 00000000..219d063c
--- /dev/null
+++ b/translations/es/04-agents-custom-instructions/README.md
@@ -0,0 +1,815 @@
+
+
+> **¿Qué pasaría si pudieras contratar a un revisor de código en Python, un experto en testing y un revisor de seguridad... todo en una sola herramienta?**
+
+En el Capítulo 03, dominaste los flujos de trabajo esenciales: revisión de código, refactorización, depuración, generación de pruebas e integración con git. Esos te hacen muy productivo con GitHub Copilot CLI. Ahora, llevémoslo más lejos.
+
+Hasta ahora, has estado usando Copilot CLI como un asistente de propósito general. Los agentes te permiten darle una persona específica con estándares incorporados, como un revisor de código que aplica type hints y PEP 8, o un ayudante de testing que escribe casos pytest. Verás cómo el mismo prompt obtiene resultados notablemente mejores cuando lo maneja un agente con instrucciones dirigidas.
+
+## 🎯 Objetivos de aprendizaje
+
+Al final de este capítulo, podrás:
+
+- Usar agentes integrados: Plan (`/plan`), Code-review (`/review`), y entender agentes automáticos (Explore, Task)
+- Crear agentes especializados usando archivos de agente (`.agent.md`)
+- Usar agentes para tareas específicas de dominio
+- Cambiar entre agentes usando `/agent` y `--agent`
+- Escribir archivos de instrucciones personalizados para estándares específicos del proyecto
+
+> ⏱️ **Tiempo estimado**: ~55 minutos (20 min lectura + 35 min práctica)
+
+---
+
+## 🧩 Analogía del mundo real: Contratar especialistas
+
+Cuando necesitas ayuda con tu casa, no llamas a un "ayudante general". Llamas a especialistas:
+
+| Problema | Especialista | Por qué |
+|---------|------------|-----|
+| Leaky pipe | Fontanero | Conoce los códigos de fontanería, tiene herramientas especializadas |
+| Rewiring | Electricista | Entiende los requisitos de seguridad, cumple con la normativa |
+| New roof | Techador | Conoce los materiales y las consideraciones del clima local |
+
+Los agentes funcionan de la misma manera. En lugar de una IA genérica, usa agentes que se enfocan en tareas específicas y conocen el proceso correcto a seguir. Configura las instrucciones una vez y vuelvelas a usar siempre que necesites esa especialidad: revisión de código, testing, seguridad, documentación.
+
+
+
+---
+
+# Uso de Agentes
+
+Comienza ya con agentes integrados y personalizados.
+
+---
+
+## *¿Nuevo en agentes?* ¡Comienza aquí!
+¿Nunca has usado o creado un agente? Esto es todo lo que necesitas saber para empezar en este curso.
+
+1. **Prueba un agente *integrado* ahora mismo:**
+ ```bash
+ copilot
+ > /plan Add input validation for book year in the book app
+ ```
+ Esto invoca al agente Plan para crear un plan de implementación paso a paso.
+
+2. **Ve uno de nuestros ejemplos de agentes personalizados:** Es sencillo definir las instrucciones de un agente, mira nuestro archivo provisto [python-reviewer.agent.md](../../../.github/agents/python-reviewer.agent.md) para ver el patrón.
+
+3. **Entiende el concepto central:** Los agentes son como consultar a un especialista en lugar de a un generalista. Un "agente frontend" se centrará automáticamente en accesibilidad y patrones de componentes, no tienes que recordárselo porque ya está especificado en las instrucciones del agente.
+
+
+## Agentes integrados
+
+**¡Ya has usado algunos agentes integrados en el Flujo de Trabajo del Capítulo 03!**
+`/plan` y `/review` son en realidad agentes integrados. Ahora sabes qué está pasando detrás de escena. Aquí está la lista completa: + +| Agente | Cómo invocarlo | Qué hace | +|-------|---------------|--------------| +| **Plan** | `/plan` o `Shift+Tab` (cycle modes) | Crea planes de implementación paso a paso antes de codificar | +| **Code-review** | `/review` | Revisa cambios staged/unstaged con comentarios enfocados y accionables | +| **Init** | `/init` | Genera archivos de configuración del proyecto (instrucciones, agentes) | +| **Explore** | *Automatic* | Se usa internamente cuando le pides a Copilot que explore o analice el código base | +| **Task** | *Automatic* | Ejecuta comandos como pruebas, compilaciones, lint e instalaciones de dependencias | + +
+ +**Agentes integrados en acción** - Ejemplos de invocación de Plan, Code-review, Explore y Task + +```bash +copilot + +# Invoca el agente Plan para crear un plan de implementación +> /plan Add input validation for book year in the book app + +# Invoca el agente Code-review sobre tus cambios +> /review + +# Los agentes Explore y Task se invocan automáticamente cuando sea relevante: +> Run the test suite # Usa el agente Task + +> Explore how book data is loaded # Usa el agente Explore +``` + +¿Qué pasa con el Agente Task? Trabaja entre bastidores para gestionar y hacer seguimiento de lo que ocurre y para reportar de vuelta en un formato claro y limpio: + +| Resultado | Lo que ves | +|---------|--------------| +| ✅ **Éxito** | Resumen breve (p. ej., "All 247 tests passed", "Build succeeded") | +| ❌ **Fallo** | Salida completa con stack traces, errores del compilador y logs detallados | + + +> 📚 **Documentación oficial**: [GitHub Copilot CLI Agents](https://docs.github.com/copilot/how-tos/use-copilot-agents/use-copilot-cli#use-custom-agents) + +--- + +# Añadiendo agentes a Copilot CLI + +¡Puedes simplemente definir tus propios agentes para que formen parte de tu flujo de trabajo! Define una vez, luego dirige. + +
+
+## 🗂️ Añade tus agentes
+
+Los archivos de agente son archivos markdown con la extensión `.agent.md`. Tienen dos partes: frontmatter YAML (metadatos) e instrucciones en markdown.
+
+> 💡 **¿Nuevo en frontmatter YAML?** Es un pequeño bloque de ajustes en la parte superior del archivo, rodeado por marcadores `---`. YAML es simplemente pares `clave: valor`. El resto del archivo es markdown regular.
+
+Aquí hay un agente mínimo:
+
+```markdown
+---
+name: my-reviewer
+description: Code reviewer focused on bugs and security issues
+---
+
+# Code Reviewer
+
+You are a code reviewer focused on finding bugs and security issues.
+
+When reviewing code, always check for:
+- SQL injection vulnerabilities
+- Missing error handling
+- Hardcoded secrets
+```
+
+> 💡 **Requerido vs Opcional**: El campo `description` es obligatorio. Otros campos como `name`, `tools` y `model` son opcionales.
+
+## Dónde poner los archivos de agente
+
+| Ubicación | Ámbito | Ideal para |
+|----------|-------|----------|
+| `.github/agents/` | Específico del proyecto | Agentes compartidos por el equipo con convenciones del proyecto |
+| `~/.copilot/agents/` | Global (todos los proyectos) | Agentes personales que usas en todas partes |
+
+**Este proyecto incluye archivos de agente de ejemplo en la carpeta [.github/agents/](../../../.github/agents)**. Puedes escribir los tuyos, o personalizar los que ya vienen.
+
+
+
+
+
+## 🚀 Dos maneras de usar agentes personalizados
+
+### Modo interactivo
+Dentro del modo interactivo, lista agentes usando `/agent` y selecciona el agente para empezar a trabajar.
+Selecciona un agente para continuar tu conversación con él.
+
+```bash
+copilot
+> /agent
+```
+
+Para cambiar a un agente diferente, o para volver al modo predeterminado, usa el comando `/agent` de nuevo.
+
+### Modo programático
+
+Lanza directamente una nueva sesión con un agente.
+
+```bash
+copilot --agent python-reviewer
+> Review @samples/book-app-project/books.py
+```
+
+> 💡 **Cambiar de agentes**: Puedes cambiar a un agente diferente en cualquier momento usando `/agent` o `--agent` de nuevo. Para volver a la experiencia estándar de Copilot CLI, usa `/agent` y selecciona **sin agente**.
+
+---
+
+# Profundizando con Agentes
+
+📂 Ver los agentes de ejemplo en este curso
+ +| Archivo | Descripción | +|------|-------------| +| `hello-world.agent.md` | Ejemplo mínimo - empieza aquí | +| `python-reviewer.agent.md` | Revisor de calidad de código Python | +| `pytest-helper.agent.md` | Especialista en pruebas Pytest | + +```bash +# O copia uno en tu carpeta de agentes personales (disponible en cada proyecto) +cp .github/agents/python-reviewer.agent.md ~/.copilot/agents/ +``` + +Para más agentes de la comunidad, mira [github/awesome-copilot](https://github.com/github/awesome-copilot) + +
+
+> 💡 **Esta sección es opcional.** Los agentes integrados (`/plan`, `/review`) son suficientemente potentes para la mayoría de los flujos de trabajo. Crea agentes personalizados cuando necesites experiencia especializada que se aplique de forma consistente a tu trabajo.
+
+Cada tema abajo es independiente. **Elige lo que te interese - no necesitas leerlos todos de una vez.**
+
+| Quiero... | Ir a |
+|---|---|
+| Ver por qué los agentes superan a los prompts genéricos | [Especialista vs Genérico](#especialista-vs-genérico-ve-la-diferencia) |
+| Combinar agentes en una funcionalidad | [Trabajar con múltiples agentes](#trabajar-con-múltiples-agentes) |
+| Organizar, nombrar y compartir agentes | [Organizar y compartir agentes](#organizar-y-compartir-agentes) |
+| Configurar contexto de proyecto siempre activo | [Configurar tu proyecto para Copilot](#configuración-rápida-con-init) |
+| Consultar propiedades YAML y herramientas | [Referencia de archivo de agente](#un-ejemplo-más-completo) |
+
+Selecciona un escenario abajo para expandirlo.
+
+---
+
+
+
+
+
+---
+
+
+Especialista vs Genérico: Ve la diferencia - Por qué los agentes producen mejores resultados que los prompts genéricos
+ +## Especialista vs Genérico: Ve la diferencia + +Aquí es donde los agentes demuestran su valor. Observa la diferencia: + +### Sin un Agente (Copilot genérico) + +```bash +copilot + +> Add a function to search books by year range in the book app +``` + +**Salida genérica**: +```python +def search_by_year_range(books, start_year, end_year): + results = [] + for book in books: + if book['year'] >= start_year and book['year'] <= end_year: + results.append(book) + return results +``` + +Básico. Funciona. Pero falta mucho. + +--- + +### Con el agente Python Reviewer + +```bash +copilot + +> /agent +# Seleccione "python-reviewer" + +> Add a function to search books by year range in the book app +``` + +**Salida del especialista**: +```python +from typing import List, Dict, Any + +def search_by_year_range( + books: List[Dict[str, Any]], + start_year: int, + end_year: int +) -> List[Dict[str, Any]]: + """ + Search for books within a specified year range. + + Args: + books: List of book dictionaries + start_year: Starting year (inclusive) + end_year: Ending year (inclusive) + + Returns: + List of books published within the year range + + Raises: + ValueError: If start_year is greater than end_year + TypeError: If year values are not integers + """ + if not isinstance(start_year, int) or not isinstance(end_year, int): + raise TypeError("Year values must be integers") + + if start_year > end_year: + raise ValueError(f"Start year ({start_year}) cannot be greater than end year ({end_year})") + + return [ + book for book in books + if isinstance(book.get('year'), int) + and start_year <= book['year'] <= end_year + ] +``` + +**Lo que el agente python-reviewer incluye automáticamente**: +- ✅ Sugerencias de tipo en todos los parámetros y valores de retorno +- ✅ Docstring completo con Args/Returns/Raises +- ✅ Validación de entrada con manejo de errores adecuado +- ✅ Comprensiones de listas para mejor rendimiento +- ✅ Manejo de casos límite (valores de año faltantes/ inválidos) +- ✅ Formato conforme a PEP 8 +- ✅ Prácticas de programación defensiva + +**La diferencia**: Mismo prompt, salida drásticamente mejor. El agente aporta la experiencia que olvidarías pedir. + +
+
+
+---
+
+
+Trabajar con múltiples agentes - Combina especialistas, cambia a mitad de sesión, agente-como-herramientas
+ +## Trabajar con múltiples agentes + +El verdadero poder viene cuando los especialistas trabajan juntos en una funcionalidad. + +### Ejemplo: Construyendo una funcionalidad simple + +```bash +copilot + +> I want to add a "search by year range" feature to the book app + +# Usa python-reviewer para el diseño +> /agent +# Selecciona "python-reviewer" + +> @samples/book-app-project/books.py Design a find_by_year_range method. What's the best approach? + +# Cambia a pytest-helper para el diseño de pruebas +> /agent +# Selecciona "pytest-helper" + +> @samples/book-app-project/tests/test_books.py Design test cases for a find_by_year_range method. +> What edge cases should we cover? + +# Sintetiza ambos diseños +> Create an implementation plan that includes the method implementation and comprehensive tests. +``` + +**La idea clave**: Tú eres el arquitecto dirigiendo a los especialistas. Ellos manejan los detalles, tú te encargas de la visión. + +
+
+
+### Agente como herramientas
+
+Cuando los agentes están configurados, Copilot también puede llamarlos como herramientas durante tareas complejas. Si pides una funcionalidad full-stack, Copilot puede delegar automáticamente partes a los agentes especialistas apropiados.
+
+🎬 ¡Verlo en acción!
+ + + +*La salida de la demo varía - tu modelo, herramientas y respuestas diferirán de lo que se muestra aquí.* + +
+
+
+**Empieza simple:** Crea un único archivo `*.agent.md` en la carpeta de tu proyecto. Muévelo a una ubicación permanente una vez que estés satisfecho con él.
+
+Más allá de los archivos de agente, Copilot también lee **archivos de instrucciones a nivel de proyecto** automáticamente, sin necesidad de `/agent`. Ve [Configurar tu proyecto para Copilot](#configuración-rápida-con-init) abajo para `AGENTS.md`, `.instructions.md`, y `/init`.
+
+
+
+---
+
+
+Organizar y compartir agentes - Nombres, ubicación de archivos, archivos de instrucciones y uso en equipo
+ +## Organizar y compartir agentes + +### Nombrar tus agentes + +Cuando creas archivos de agente, el nombre importa. Es lo que escribirás después de `/agent` o `--agent`, y lo que verán tus compañeros en la lista de agentes. + +| ✅ Buenos nombres | ❌ Evitar | +|--------------|----------| +| `frontend` | `my-agent` | +| `backend-api` | `agent1` | +| `security-reviewer` | `helper` | +| `react-specialist` | `code` | +| `python-backend` | `assistant` | + +**Convenciones de nombres:** +- Usa minúsculas con guiones: `my-agent-name.agent.md` +- Incluye el dominio: `frontend`, `backend`, `devops`, `security` +- Sé específico cuando sea necesario: `react-typescript` vs solo `frontend` + +--- + +### Compartir con tu equipo + +Coloca archivos de agente en `.github/agents/` y estarán bajo control de versiones. Haz push a tu repo y todos los miembros del equipo los obtendrán automáticamente. Pero los agentes son solo un tipo de archivo que Copilot lee desde tu proyecto. También soporta **archivos de instrucciones** que se aplican automáticamente a cada sesión, sin que nadie tenga que ejecutar `/agent`. + +Piensa en ello así: los agentes son especialistas que llamas, y los archivos de instrucciones son reglas del equipo que están siempre activas. + +### Dónde colocar tus archivos + +Ya conoces las dos ubicaciones principales (ver [Dónde poner archivos de agente](#dónde-poner-los-archivos-de-agente) arriba). Usa este árbol de decisión para elegir: + +
+
+**Empieza simple:** Crea un único archivo `*.agent.md` en la carpeta de tu proyecto. Muévelo a una ubicación permanente una vez que estés satisfecho con él.
+
+Más allá de los archivos de agente, Copilot también lee **archivos de instrucciones a nivel de proyecto** automáticamente, sin necesidad de `/agent`. Ve [Configurar tu proyecto para Copilot](#configuración-rápida-con-init) abajo para `AGENTS.md`, `.instructions.md`, y `/init`.
+
+
+
+
+---
+
+
+Configurar tu proyecto para Copilot - AGENTS.md, archivos de instrucciones y configuración con /init
+## Configurando tu proyecto para Copilot + +Los agentes son especialistas que invocas bajo demanda. **Los archivos de configuración del proyecto** son diferentes: Copilot los lee automáticamente en cada sesión para entender las convenciones, la pila tecnológica y las reglas de tu proyecto. Nadie necesita ejecutar `/agent`; el contexto siempre está activo para todas las personas que trabajan en el repositorio. + +### Configuración rápida con /init + +La forma más rápida de comenzar es dejar que Copilot genere archivos de configuración por ti: + +```bash +copilot +> /init +``` + +Copilot escaneará tu proyecto y creará archivos de instrucciones a medida. Puedes editarlos después. + +### Formatos de archivos de instrucciones + +| Archivo | Ámbito | Notas | +|------|-------|-------| +| `AGENTS.md` | Raíz del proyecto o anidado | **Estándar multiplataforma** - funciona con Copilot y otros asistentes de IA | +| `.github/copilot-instructions.md` | Proyecto | Específico de GitHub Copilot | +| `.github/instructions/*.instructions.md` | Proyecto | Instrucciones granulares y específicas por tema | +| `CLAUDE.md`, `GEMINI.md` | Raíz del proyecto | Soportados para compatibilidad | + +> 🎯 **¿Apenas empezando?** Usa `AGENTS.md` para las instrucciones del proyecto. Puedes explorar los otros formatos más tarde según sea necesario. + +### AGENTS.md + +`AGENTS.md` es el formato recomendado. Es un [estándar abierto](https://agents.md/) que funciona con Copilot y otras herramientas de programación con IA. Colócalo en la raíz de tu repositorio y Copilot lo lee automáticamente. El propio [AGENTS.md](../AGENTS.md) de este proyecto es un ejemplo funcional. + +Un `AGENTS.md` típico describe el contexto de tu proyecto, el estilo de código, los requisitos de seguridad y los estándares de pruebas. Escribe el tuyo siguiendo el patrón en nuestro archivo de ejemplo. + +### Archivos de instrucciones personalizados (.instructions.md) + +Para equipos que quieran un control más granular, divide las instrucciones en archivos por tema. Cada archivo cubre una preocupación y se aplica automáticamente: + +``` +.github/ +└── instructions/ + ├── python-standards.instructions.md + ├── security-checklist.instructions.md + └── api-design.instructions.md +``` + +> 💡 **Nota**: Los archivos de instrucciones funcionan con cualquier lenguaje. Este ejemplo usa Python para coincidir con el proyecto del curso, pero puedes crear archivos similares para TypeScript, Go, Rust o cualquier tecnología que use tu equipo. + +#### Delimitando instrucciones con `applyTo` + +Por defecto, un archivo de instrucciones se aplica a toda conversación. Para limitarlo a tipos de archivo específicos, añade un campo `applyTo` en el frontmatter YAML (el bloque entre `---` marcadores en la parte superior del archivo): + +```markdown +--- +applyTo: "**/*.py" +--- +# Python Standards +Always follow PEP 8 style conventions. +Use type hints in all function signatures. +``` + +Con `applyTo: "**/*.py"`, Copilot carga ese archivo de instrucciones solo cuando estás trabajando con archivos Python. Las instrucciones para el estilo de Python nunca saturan una conversación sobre, por ejemplo, un Dockerfile o una consulta SQL. + +Aquí hay algunos patrones comunes: + +| `applyTo` value | Cuándo se aplica | +|---|---| +| `"**/*.py"` | Cualquier archivo Python | +| `"**/*.{ts,tsx}"` | Archivos TypeScript y TSX | +| `"tests/**"` | Cualquier archivo dentro de una carpeta `tests/` | +| (sin frontmatter) | Toda conversación — por defecto | + +> 💡 **Consejo**: Encierra el patrón glob entre comillas (p. ej., `"**/*.py"`) para asegurar que se interprete correctamente en todos los sistemas operativos y shells. + +**Encontrar archivos de instrucciones de la comunidad**: Busca en [github/awesome-copilot](https://github.com/github/awesome-copilot) archivos de instrucciones preconfeccionados que cubren .NET, Angular, Azure, Python, Docker y muchas más tecnologías. + +### Deshabilitar instrucciones personalizadas + +Si necesitas que Copilot ignore todas las configuraciones específicas del proyecto (útil para depurar o comparar comportamientos): + +```bash +copilot --no-custom-instructions +``` + +
+
+
+---
+
+# Práctica
+
+Referencia de archivo de agente - Propiedades YAML, alias de herramientas y ejemplos completos
+ +## Referencia de archivo de agente + +### Un ejemplo más completo + +Has visto el [formato de agente minimalista](#-add-your-agents) arriba. Aquí hay un agente más completo que usa la propiedad `tools`. Crea `~/.copilot/agents/python-reviewer.agent.md`: + +```markdown +--- +name: python-reviewer +description: Python code quality specialist for reviewing Python projects +tools: ["read", "edit", "search", "execute"] +--- + +# Python Code Reviewer + +You are a Python specialist focused on code quality and best practices. + +**Your focus areas:** +- Code quality (PEP 8, type hints, docstrings) +- Performance optimization (list comprehensions, generators) +- Error handling (proper exception handling) +- Maintainability (DRY principles, clear naming) + +**Code style requirements:** +- Use Python 3.10+ features (dataclasses, type hints, pattern matching) +- Follow PEP 8 naming conventions +- Use context managers for file I/O +- All functions must have type hints and docstrings + +**When reviewing code, always check:** +- Missing type hints on function signatures +- Mutable default arguments +- Proper error handling (no bare except) +- Input validation completeness +``` + +### Propiedades YAML + +| Propiedad | Requerido | Descripción | +|----------|----------|-------------| +| `name` | No | Nombre para mostrar (por defecto: usa el nombre del archivo) | +| `description` | **Sí** | Lo que hace el agente - ayuda a Copilot a entender cuándo sugerirlo | +| `tools` | No | Lista de herramientas permitidas (omitir = todas las herramientas disponibles). Ver alias de herramientas abajo. | +| `target` | No | Limitar a `vscode` o `github-copilot` únicamente | + +### Alias de herramientas + +Usa estos nombres en la lista `tools`: +- `read` - Leer el contenido de archivos +- `edit` - Editar archivos +- `search` - Buscar archivos (grep/glob) +- `execute` - Ejecutar comandos de shell (también: `shell`, `Bash`) +- `agent` - Invocar otros agentes personalizados + +> 📖 **Documentación oficial**: [Configuración de agentes personalizados](https://docs.github.com/copilot/reference/custom-agents-configuration) +> +> ⚠️ **Solo VS Code**: La propiedad `model` (para seleccionar modelos de IA) funciona en VS Code pero no es compatible con GitHub Copilot CLI. Puedes incluirla sin problemas en archivos de agentes multiplataforma. GitHub Copilot CLI la ignorará. + +### Más plantillas de agentes + +> 💡 **Nota para principiantes**: Los ejemplos a continuación son plantillas. **Sustituye las tecnologías específicas por las que use tu proyecto.** Lo importante es la *estructura* del agente, no las tecnologías específicas mencionadas. + +Este proyecto incluye ejemplos funcionales en la carpeta [.github/agents/](../../../.github/agents): +- [hello-world.agent.md](../../../.github/agents/hello-world.agent.md) - Ejemplo mínimo, comienza aquí +- [python-reviewer.agent.md](../../../.github/agents/python-reviewer.agent.md) - Revisor de calidad de código Python +- [pytest-helper.agent.md](../../../.github/agents/pytest-helper.agent.md) - Especialista en pruebas Pytest + +Para agentes comunitarios, consulta [github/awesome-copilot](https://github.com/github/awesome-copilot). + +
+
+Crea tus propios agentes y míralos en acción.
+
+---
+
+## ▶️ Pruébalo tú mismo
+
+```bash
+
+# Crear el directorio de agentes (si no existe)
+mkdir -p .github/agents
+
+# Crear un agente revisor de código
+cat > .github/agents/reviewer.agent.md << 'EOF'
+---
+name: reviewer
+description: Senior code reviewer focused on security and best practices
+---
+
+# Agente revisor de código
+
+You are a senior code reviewer focused on code quality.
+
+**Review priorities:**
+1. Security vulnerabilities
+2. Performance issues
+3. Maintainability concerns
+4. Best practice violations
+
+**Output format:**
+Provide issues as a numbered list with severity tags:
+[CRITICAL], [HIGH], [MEDIUM], [LOW]
+EOF
+
+# Crear un agente de documentación
+cat > .github/agents/documentor.agent.md << 'EOF'
+---
+name: documentor
+description: Technical writer for clear and complete documentation
+---
+
+# Agente de documentación
+
+You are a technical writer who creates clear documentation.
+
+**Documentation standards:**
+- Start with a one-sentence summary
+- Include usage examples
+- Document parameters and return values
+- Note any gotchas or limitations
+EOF
+
+# Úsalos ahora
+copilot --agent reviewer
+> Review @samples/book-app-project/books.py
+
+# O cambia de agentes
+copilot
+> /agent
+# Selecciona "documentador"
+> Document @samples/book-app-project/books.py
+```
+
+---
+
+## 📝 Tarea
+
+### Reto principal: Construir un equipo de agentes especializados
+
+El ejemplo práctico creó agentes `reviewer` y `documentor`. Ahora practica creando y usando agentes para una tarea diferente: mejorar la validación de datos en la aplicación de libros:
+
+1. Crea 3 archivos de agente (`.agent.md`) adaptados a la app de libros, uno por agente, colocados en `.github/agents/`
+2. Tus agentes:
+ - **data-validator**: comprueba `data.json` en busca de datos faltantes o mal formados (autores vacíos, year=0, campos faltantes)
+ - **error-handler**: revisa el código Python en busca de manejo de errores inconsistente y sugiere un enfoque unificado
+ - **doc-writer**: genera o actualiza docstrings y contenido de README
+3. Usa cada agente en la app de libros:
+ - `data-validator` → auditar `@samples/book-app-project/data.json`
+ - `error-handler` → revisar `@samples/book-app-project/books.py` y `@samples/book-app-project/utils.py`
+ - `doc-writer` → añadir docstrings a `@samples/book-app-project/books.py`
+4. Colaborar: usa `error-handler` para identificar brechas en el manejo de errores, y luego `doc-writer` para documentar el enfoque mejorado
+
+**Criterios de éxito**: Tienes 3 agentes funcionando que producen resultados coherentes y de alta calidad y puedes alternar entre ellos con `/agent`.
+
+
+
+
+### Reto adicional: Biblioteca de instrucciones
+
+Has creado agentes que invocas bajo demanda. Ahora prueba el otro lado: **archivos de instrucciones** que Copilot lee automáticamente en cada sesión, sin necesidad de `/agent`.
+
+Crea una carpeta `.github/instructions/` con al menos 3 archivos de instrucciones:
+- `python-style.instructions.md` para aplicar PEP 8 y las convenciones de anotaciones de tipo
+- `test-standards.instructions.md` para aplicar las convenciones de pytest en archivos de pruebas
+- `data-quality.instructions.md` para validar entradas de datos JSON
+
+Prueba cada archivo de instrucciones en el código de la app de libros.
+
+---
+
+💡 Pistas (haz clic para expandir)
+ +**Plantillas iniciales**: crea un archivo por agente en `.github/agents/`: + +`data-validator.agent.md`: +```markdown +--- +description: Analyzes JSON data files for missing or malformed entries +--- + +You analyze JSON data files for missing or malformed entries. + +**Focus areas:** +- Empty or missing author fields +- Invalid years (year=0, future years, negative years) +- Missing required fields (title, author, year, read) +- Duplicate entries +``` + +`error-handler.agent.md`: +```markdown +--- +description: Reviews Python code for error handling consistency +--- + +You review Python code for error handling consistency. + +**Standards:** +- No bare except clauses +- Use custom exceptions where appropriate +- All file operations use context managers +- Consistent return types for success/failure +``` + +`doc-writer.agent.md`: +```markdown +--- +description: Technical writer for clear Python documentation +--- + +You are a technical writer who creates clear Python documentation. + +**Standards:** +- Google-style docstrings +- Include parameter types and return values +- Add usage examples for public methods +- Note any exceptions raised +``` + +**Probar tus agentes:** + +> 💡 **Nota:** Deberías ya tener `samples/book-app-project/data.json` en tu copia local de este repositorio. Si falta, descarga la versión original del repositorio fuente: +> [data.json](https://github.com/github/copilot-cli-for-beginners/blob/main/samples/book-app-project/data.json) + +```bash +copilot +> /agent +# Seleccione "data-validator" de la lista +> @samples/book-app-project/data.json Check for books with empty author fields or invalid years +``` + +**Consejo:** El campo `description` en el frontmatter YAML es obligatorio para que los agentes funcionen. + +
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **Agentes integrados**: `/plan` y `/review` se invocan directamente; Explore y Task funcionan automáticamente
+2. **Agentes personalizados** son especialistas definidos en archivos `.agent.md`
+3. **Buenos agentes** tienen experiencia clara, estándares y formatos de salida
+4. **Colaboración multiagente** resuelve problemas complejos combinando experiencia
+5. **Los archivos de instrucciones** (`.instructions.md`) codifican los estándares del equipo para su aplicación automática
+6. **Salida consistente** proviene de instrucciones de agente bien definidas
+
+> 📋 **Referencia rápida**: Consulta la [referencia de comandos de GitHub Copilot CLI](https://docs.github.com/en/copilot/reference/cli-command-reference) para una lista completa de comandos y atajos.
+
+---
+
+## ➡️ ¿Qué sigue?
+
+Los agentes cambian *cómo Copilot aborda y realiza acciones específicas* en tu código. A continuación, aprenderás sobre **skills** — que cambian *qué pasos* sigue. ¿Te preguntas cómo difieren agentes y skills? El Capítulo 05 trata eso directamente.
+
+En **[Capítulo 05: Sistema de skills](../05-skills/README.md)**, aprenderás:
+
+- Cómo los skills se activan automáticamente a partir de tus indicaciones (no se necesita un comando con barra)
+- Cómo instalar skills de la comunidad
+- Crear skills personalizados con archivos SKILL.md
+- La diferencia entre agentes, skills y MCP
+- Cuándo usar cada uno
+
+---
+
+**[← Volver al Capítulo 03](../03-development-workflows/README.md)** | **[Continuar al Capítulo 05 →](../05-skills/README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/05-skills/README.md b/translations/es/05-skills/README.md
new file mode 100644
index 00000000..5c3273e3
--- /dev/null
+++ b/translations/es/05-skills/README.md
@@ -0,0 +1,889 @@
+
+
+> **¿Y si Copilot pudiera aplicar automáticamente las mejores prácticas de tu equipo sin que tengas que explicarlas cada vez?**
+
+En este capítulo aprenderás sobre Agent Skills: carpetas de instrucciones que Copilot carga automáticamente cuando son relevantes para tu tarea. Mientras que los agentes cambian *cómo* piensa Copilot, las skills le enseñan *formas específicas de completar tareas*. Crearás una skill de auditoría de seguridad que Copilot aplicará siempre que preguntes sobre seguridad, construirás criterios de revisión estándar del equipo que garanticen calidad de código coherente y aprenderás cómo funcionan las skills en Copilot CLI, VS Code y el agente en la nube de GitHub Copilot.
+
+## 🎯 Learning Objectives
+
+Al final de este capítulo, podrás:
+
+- Entender cómo funcionan las Agent Skills y cuándo usarlas
+- Crear skills personalizadas con archivos SKILL.md
+- Usar skills comunitarias desde repositorios compartidos
+- Saber cuándo usar skills vs agentes vs MCP
+
+> ⏱️ **Tiempo estimado**: ~55 minutos (20 min lectura + 35 min práctica)
+
+---
+
+## 🧩 Analogía del Mundo Real: Herramientas Eléctricas
+
+Un taladro de uso general es útil, pero los accesorios especializados lo hacen potente.
+🔧 Errores comunes y solución de problemas (haz clic para expandir)
+ +### Errores comunes + +| Error | Qué ocurre | Solución | +|---------|--------------|-----| +| Falta `description` en el frontmatter del agente | El agente no se cargará o no será detectable | Siempre incluye `description:` en el frontmatter YAML | +| Ubicación incorrecta de los archivos de agentes | El agente no se encuentra cuando intentas usarlo | Colócalo en `~/.copilot/agents/` (personal) o `.github/agents/` (proyecto) | +| Usar `.md` en vez de `.agent.md` | El archivo puede no ser reconocido como un agente | Nombra los archivos como `python-reviewer.agent.md` | +| Prompts de agente demasiado largos | Pueden alcanzar el límite de 30,000 caracteres | Mantén las definiciones de agentes enfocadas; usa skills para instrucciones detalladas | + +### Solución de problemas + +**Agente no encontrado** - Comprueba que el archivo del agente exista en una de estas ubicaciones: +- `~/.copilot/agents/` +- `.github/agents/` + +Lista de agentes disponibles: + +```bash +copilot +> /agent +# Muestra todos los agentes disponibles +``` + +**Agente que no sigue las instrucciones** - Sé explícito en tus prompts y añade más detalle a las definiciones de agentes: +- Frameworks/bibliotecas específicas con versiones +- Convenciones del equipo +- Patrones de código de ejemplo + +**Instrucciones personalizadas no se cargan** - Ejecuta `/init` en tu proyecto para configurar instrucciones específicas del proyecto: + +```bash +copilot +> /init +``` + +O verifica si están deshabilitadas: +```bash +# No uses --no-custom-instructions si quieres que se carguen +copilot # Esto carga instrucciones personalizadas de forma predeterminada +``` + +
+
+Las skills funcionan de la misma manera. Igual que cambiar brocas para diferentes trabajos, puedes añadir skills a Copilot para distintas tareas:
+
+| Skill Attachment | Purpose |
+|------------|---------|
+| `commit` | Generar mensajes de commit consistentes |
+| `security-audit` | Comprobar vulnerabilidades OWASP |
+| `generate-tests` | Crear pruebas pytest exhaustivas |
+| `code-checklist` | Aplicar estándares de calidad de código del equipo |
+
+
+
+*Las skills son accesorios especializados que amplían lo que Copilot puede hacer*
+
+---
+
+# How Skills Work
+
+
+
+Aprende qué son las skills, por qué importan y en qué se diferencian de los agentes y MCP.
+
+---
+
+## *¿Nuevo en Skills?* Comienza aquí!
+
+1. **Ve qué skills ya están disponibles:**
+ ```bash
+ copilot
+ > /skills list
+ ```
+ Esto muestra todas las skills que Copilot puede encontrar, incluidas las **skills integradas** que vienen con la propia CLI, además de las skills de tu proyecto y de las carpetas personales.
+
+ > 💡 **Skills integradas**: La Copilot CLI viene con skills preinstaladas desde el inicio. Por ejemplo, la skill `customizing-copilot-cloud-agents-environment` ofrece una guía para personalizar el entorno del agente en la nube de Copilot. No necesitas crear ni instalar nada para usarlas. Ejecuta `/skills list` para ver qué hay disponible.
+
+2. **Mira un archivo de skill real:** Consulta nuestro [code-checklist SKILL.md](../../../.github/skills/code-checklist/SKILL.md) para ver el patrón. Es solo frontmatter YAML más instrucciones en markdown.
+
+3. **Entiende el concepto principal:** Las skills son instrucciones específicas de tareas que Copilot carga *automáticamente* cuando tu prompt coincide con la descripción de la skill. No necesitas activarlas, solo pregunta de forma natural.
+
+## Understanding Skills
+
+Agent Skills son carpetas que contienen instrucciones, scripts y recursos que Copilot **carga automáticamente cuando son relevantes** para tu tarea. Copilot lee tu prompt, comprueba si alguna skill coincide y aplica las instrucciones relevantes automáticamente.
+
+```bash
+copilot
+
+> Check books.py against our quality checklist
+# Copilot detecta que esto coincide con tu habilidad "code-checklist"
+# y aplica automáticamente su lista de verificación de calidad para Python
+
+> Generate tests for the BookCollection class
+# Copilot carga tu habilidad "pytest-gen"
+# y aplica tu estructura de pruebas preferida
+
+> What are the code quality issues in this file?
+# Copilot carga tu habilidad "code-checklist"
+# y verifica frente a los estándares de tu equipo
+```
+
+> 💡 **Idea clave**: Las skills se **activan automáticamente** en función de que tu prompt coincida con la descripción de la skill. Solo pregunta de forma natural y Copilot aplica las skills relevantes en segundo plano. También puedes invocar skills directamente, lo cual aprenderás a continuación.
+
+> 🧰 **Plantillas listas para usar**: Revisa la carpeta [.github/skills](../../../.github/skills) para skills simples que puedes copiar y probar.
+
+### Invocación directa con comando slash
+
+Aunque el auto-disparo es la forma principal en que funcionan las skills, también puedes **invocarlas directamente** usando su nombre como comando slash:
+
+```bash
+> /generate-tests Create tests for the user authentication module
+
+> /code-checklist Check books.py for code quality issues
+
+> /security-audit Check the API endpoints for vulnerabilities
+```
+
+Esto te da control explícito cuando quieres asegurarte de que se use una skill específica.
+
+#### Combinar múltiples skills en un solo mensaje
+
+Puedes invocar **más de una skill en un solo mensaje**, y el comando slash de la skill puede aparecer en cualquier parte de tu prompt — no solo al principio. Esto es útil cuando quieres que se realicen dos comprobaciones distintas de una vez:
+
+```bash
+> Check @samples/book-app-project/book_app.py with /code-checklist and also run /generate-tests for it
+
+> Review the auth module /security-audit then /code-checklist the result
+```
+
+Copilot aplicará cada skill nombrada en la misma respuesta, ahorrándote enviar varios mensajes separados.
+
+> 💡 **Consejo**: Coloca los comandos slash de las skills donde se sientan más naturales en tu frase. Puedes ponerlos al inicio, en medio o al final de tu mensaje.
+
+> 📝 **Invocación: Skills vs Agentes**: No confundas la invocación de una skill con la invocación de un agente:
+> - **Skills**: `/skill-name 
+
+| Feature | What It Does | When to Use |
+|---------|--------------|-------------|
+| **Agents** | Changes how AI thinks | Need specialized expertise across many tasks |
+| **Skills** | Provides task-specific instructions | Specific, repeatable tasks with detailed steps |
+| **MCP** | Connects external services | Need live data from APIs |
+
+Usa agentes para experiencia amplia, skills para instrucciones específicas de tareas y MCP para datos externos. Un agente puede usar una o más skills durante una conversación. Por ejemplo, cuando le pides a un agente que revise tu código, puede aplicar tanto una skill `security-audit` como una `code-checklist` automáticamente.
+
+> 📚 **Aprende más**: Consulta la documentación oficial [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills) para la referencia completa sobre formatos de skill y buenas prácticas.
+
+---
+
+## Desde prompts manuales hasta experiencia automática
+
+Antes de profundizar en cómo crear skills, veamos *por qué* vale la pena aprenderlas. Una vez que veas las ganancias en coherencia, el "cómo" tendrá más sentido.
+
+### Antes de las Skills: Revisiones inconsistentes
+
+En cada revisión de código, podrías olvidar algo:
+
+```bash
+copilot
+
+> Review this code for issues
+# Revisión genérica - puede pasar por alto las preocupaciones específicas de su equipo
+```
+
+O escribes un prompt largo cada vez:
+
+```bash
+> Review this code checking for bare except clauses, missing type hints,
+> mutable default arguments, missing context managers for file I/O,
+> functions over 50 lines, print statements in production code...
+```
+
+Tiempo: **30+ segundos** para escribir. Coherencia: **varía según la memoria**.
+
+### Después de las Skills: Mejores prácticas automáticas
+
+Con una skill `code-checklist` instalada, solo pregunta de forma natural:
+
+```bash
+copilot
+
+> Check the book collection code for quality issues
+```
+
+**Qué ocurre entre bastidores**:
+1. Copilot ve "code quality" y "issues" en tu prompt
+2. Comprueba las descripciones de las skills, encuentra que tu skill `code-checklist` coincide
+3. Carga automáticamente la lista de verificación de calidad de tu equipo
+4. Aplica todas las comprobaciones sin que las enumeres
+
+
+
+*Solo pregunta de forma natural. Copilot empareja tu prompt con la skill adecuada y la aplica automáticamente.*
+
+**Salida**:
+```
+## Code Checklist: books.py
+
+### Code Quality
+- [PASS] All functions have type hints
+- [PASS] No bare except clauses
+- [PASS] No mutable default arguments
+- [PASS] Context managers used for file I/O
+- [PASS] Functions are under 50 lines
+- [PASS] Variable and function names follow PEP 8
+
+### Input Validation
+- [FAIL] User input is not validated - add_book() accepts any year value
+- [FAIL] Edge cases not fully handled - empty strings accepted for title/author
+- [PASS] Error messages are clear and helpful
+
+### Testing
+- [FAIL] No corresponding pytest tests found
+
+### Summary
+3 items need attention before merge
+```
+
+**La diferencia**: Los estándares de tu equipo se aplican automáticamente, siempre, sin tener que escribirlos.
+
+---
+
+
+
+
+---
+
+## Coherencia a escala: Skill de revisión de PR del equipo
+
+Imagina que tu equipo tiene una lista de verificación de PR de 10 puntos. Sin una skill, cada desarrollador debe recordar los 10 puntos, y alguien siempre olvida uno. Con una skill `pr-review`, todo el equipo obtiene revisiones coherentes:
+
+```bash
+copilot
+
+> Can you review this PR?
+```
+
+Copilot carga automáticamente la skill `pr-review` de tu equipo y comprueba los 10 puntos:
+
+```
+PR Review: feature/user-auth
+
+## Security ✅
+- No hardcoded secrets
+- Input validation present
+- No bare except clauses
+
+## Code Quality ⚠️
+- [WARN] print statement on line 45 - remove before merge
+- [WARN] TODO on line 78 missing issue reference
+- [WARN] Missing type hints on public functions
+
+## Testing ✅
+- New tests added
+- Edge cases covered
+
+## Documentation ❌
+- [FAIL] Breaking change not documented in CHANGELOG
+- [FAIL] API changes need OpenAPI spec update
+```
+
+**El poder**: Cada miembro del equipo aplica los mismos estándares automáticamente. Las nuevas contrataciones no necesitan memorizar la lista porque la skill se encarga de ello.
+
+---
+
+# Creando Skills Personalizadas
+
+🎬 ¡Míralo en acción!
+ + + +*La salida del demo varía. Tu modelo, herramientas y respuestas diferirán de lo mostrado aquí.* + +
+
+Crea tus propias skills desde archivos SKILL.md.
+
+---
+
+## Ubicaciones de las Skills
+
+Las skills se almacenan en `.github/skills/` (específicas del proyecto) o `~/.copilot/skills/` (a nivel de usuario).
+
+### Cómo encuentra Copilot las skills
+
+Copilot escanea automáticamente estas ubicaciones en busca de skills:
+
+| Location | Scope |
+|----------|-------|
+| `.github/skills/` | Project-specific (shared with team via git) |
+| `~/.copilot/skills/` | User-specific (your personal skills) |
+
+### Estructura de una Skill
+
+Cada skill vive en su propia carpeta con un archivo `SKILL.md`. Opcionalmente puedes incluir scripts, ejemplos u otros recursos:
+
+```
+.github/skills/
+└── my-skill/
+ ├── SKILL.md # Required: Skill definition and instructions
+ ├── examples/ # Optional: Example files Copilot can reference
+ │ └── sample.py
+ └── scripts/ # Optional: Scripts the skill can use
+ └── validate.sh
+```
+
+> 💡 **Consejo**: El nombre del directorio debe coincidir con el `name` en el frontmatter de tu SKILL.md (minúsculas con guiones).
+
+### Formato SKILL.md
+
+Las skills usan un formato markdown simple con frontmatter YAML:
+
+```markdown
+---
+name: code-checklist
+description: Comprehensive code quality checklist with security, performance, and maintainability checks
+license: MIT
+---
+
+# Code Checklist
+
+When checking code, look for:
+
+## Security
+- SQL injection vulnerabilities
+- XSS vulnerabilities
+- Authentication/authorization issues
+- Sensitive data exposure
+
+## Performance
+- N+1 query problems (running one query per item instead of one query for all items)
+- Unnecessary loops or computations
+- Memory leaks
+- Blocking operations
+
+## Maintainability
+- Function length (flag functions > 50 lines)
+- Code duplication
+- Missing error handling
+- Unclear naming
+
+## Output Format
+Provide issues as a numbered list with severity:
+- [CRITICAL] - Must fix before merge
+- [HIGH] - Should fix before merge
+- [MEDIUM] - Should address soon
+- [LOW] - Nice to have
+```
+
+**Propiedades YAML:**
+
+| Property | Required | Description |
+|----------|----------|-------------|
+| `name` | **Yes** | Identificador único (minúsculas, guiones para espacios) |
+| `description` | **Yes** | Qué hace la skill y cuándo Copilot debe usarla |
+| `license` | No | Licencia que aplica a esta skill |
+
+> 📖 **Documentación oficial**: [About Agent Skills](https://docs.github.com/copilot/concepts/agents/about-agent-skills)
+
+### Creando tu primera Skill
+
+Vamos a construir una skill de auditoría de seguridad que compruebe las vulnerabilidades OWASP Top 10:
+
+```bash
+# Crear el directorio de la habilidad
+mkdir -p .github/skills/security-audit
+
+# Crear el archivo SKILL.md
+cat > .github/skills/security-audit/SKILL.md << 'EOF'
+---
+name: security-audit
+description: Security-focused code review checking OWASP (Open Web Application Security Project) Top 10 vulnerabilities
+---
+
+# Auditoría de seguridad
+
+Perform a security audit checking for:
+
+## Vulnerabilidades de inyección
+- SQL injection (string concatenation in queries)
+- Command injection (unsanitized shell commands)
+- LDAP injection
+- XPath injection
+
+## Problemas de autenticación
+- Hardcoded credentials
+- Weak password requirements
+- Missing rate limiting
+- Session management flaws
+
+## Datos sensibles
+- Plaintext passwords
+- API keys in code
+- Logging sensitive information
+- Missing encryption
+
+## Control de acceso
+- Missing authorization checks
+- Insecure direct object references
+- Path traversal vulnerabilities
+
+## Salida
+For each issue found, provide:
+1. File and line number
+2. Vulnerability type
+3. Severity (CRITICAL/HIGH/MEDIUM/LOW)
+4. Recommended fix
+EOF
+
+# Prueba tu habilidad (las habilidades se cargan automáticamente según tu indicación)
+copilot
+
+> @samples/book-app-project/ Check this code for security vulnerabilities
+# Copilot detecta "vulnerabilidades de seguridad" que coinciden con tu habilidad
+# y aplica automáticamente su lista de verificación OWASP
+```
+
+**Salida esperada** (tus resultados variarán):
+
+```
+Security Audit: book-app-project
+
+[HIGH] Hardcoded file path (book_app.py, line 12)
+ File path is hardcoded rather than configurable
+ Fix: Use environment variable or config file
+
+[MEDIUM] No input validation (book_app.py, line 34)
+ User input passed directly to function without sanitization
+ Fix: Add input validation before processing
+
+✅ No SQL injection found
+✅ No hardcoded credentials found
+```
+
+---
+
+## Escribir buenas descripciones de Skill
+
+El campo `description` en tu SKILL.md ¡es crucial! Es cómo Copilot decide si cargar tu skill:
+
+```markdown
+---
+name: security-audit
+description: Use for security reviews, vulnerability scanning,
+ checking for SQL injection, XSS, authentication issues,
+ OWASP Top 10 vulnerabilities, and security best practices
+---
+```
+
+> 💡 **Consejo**: Incluye palabras clave que coincidan con cómo preguntas de forma natural. Si dices "security review", incluye "security review" en la descripción.
+
+### Combinar Skills con Agentes
+
+Las skills y los agentes funcionan juntos. El agente aporta la experiencia, la skill aporta instrucciones específicas:
+
+```bash
+# Comience con un agente revisor de código
+copilot --agent code-reviewer
+
+> Check the book app for quality issues
+# La experiencia del agente revisor de código se combina
+# con la lista de verificación de su habilidad code-checklist
+```
+
+---
+
+# Gestionar y Compartir Skills
+
+Descubre las skills instaladas, encuentra skills comunitarias y comparte las tuyas.
+
+
+
+---
+
+## Gestionar Skills con el comando `/skills`
+
+Usa el comando `/skills` para gestionar tus skills instaladas:
+
+| Command | What It Does |
+|---------|--------------|
+| `/skills list` | Mostrar todas las skills instaladas |
+| `/skills info
+
+
+---
+
+### Cuándo usar `/skills reload`
+
+Después de crear o editar el archivo SKILL.md de una skill, ejecuta `/skills reload` para recoger los cambios sin reiniciar Copilot:
+
+```bash
+# Edita tu archivo de habilidad
+# Luego, en Copilot:
+> /skills reload
+Skills reloaded successfully.
+```
+
+> 💡 **Buen dato**: Las skills siguen siendo efectivas incluso después de usar `/compact` para resumir el historial de la conversación. No es necesario recargar después de compactar.
+
+---
+
+## Encontrar y usar Skills comunitarias
+
+### Usar Plugins para instalar Skills
+> 💡 **¿Qué son los plugins?** Los plugins son paquetes instalables que pueden agrupar skills, agents y configuraciones de servidores MCP. Piénsalos como extensiones tipo "app store" para Copilot CLI.
+
+El comando `/plugin` te permite explorar e instalar estos paquetes:
+
+```bash
+copilot
+
+> /plugin list
+# Muestra los complementos instalados
+
+> /plugin marketplace
+# Explorar complementos disponibles
+
+> /plugin install ¡Míralo en acción!
+ + + +*La salida del demo varía. Tu modelo, herramientas y respuestas diferirán de lo mostrado aquí.* + +
+
+Aplica lo que has aprendido construyendo y probando tus propias skills.
+
+---
+
+## ▶️ Pruébalo tú mismo
+
+### Crea más skills
+
+Aquí hay dos skills más que muestran distintos patrones. Sigue el mismo flujo de trabajo `mkdir` + `cat` de "Crear tu primera skill" arriba o copia y pega las skills en la ubicación adecuada. Hay más ejemplos disponibles en [.github/skills](../../../.github/skills).
+
+### Skill de generación de tests con pytest
+
+Una skill que garantiza una estructura consistente de pytest en tu base de código:
+
+```bash
+mkdir -p .github/skills/pytest-gen
+
+cat > .github/skills/pytest-gen/SKILL.md << 'EOF'
+---
+name: pytest-gen
+description: Generate comprehensive pytest tests with fixtures and edge cases
+---
+
+# Generación de pruebas con pytest
+
+Generate pytest tests that include:
+
+## Estructura de pruebas
+- Use pytest conventions (test_ prefix)
+- One assertion per test when possible
+- Clear test names describing expected behavior
+- Use fixtures for setup/teardown
+
+## Cobertura
+- Happy path scenarios
+- Edge cases: None, empty strings, empty lists
+- Boundary values
+- Error scenarios with pytest.raises()
+
+## Fixtures
+- Use @pytest.fixture for reusable test data
+- Use tmpdir/tmp_path for file operations
+- Mock external dependencies with pytest-mock
+
+## Salida
+Provide complete, runnable test file with proper imports.
+EOF
+```
+
+### Skill de revisión de PR del equipo
+
+Una skill que aplica estándares coherentes de revisión de PR en tu equipo:
+
+```bash
+mkdir -p .github/skills/pr-review
+
+cat > .github/skills/pr-review/SKILL.md << 'EOF'
+---
+name: pr-review
+description: Team-standard PR review checklist
+---
+
+# Revisión de PR
+
+Review code changes against team standards:
+
+## Lista de verificación de seguridad
+- [ ] No hardcoded secrets or API keys
+- [ ] Input validation on all user data
+- [ ] No bare except clauses
+- [ ] No sensitive data in logs
+
+## Calidad del código
+- [ ] Functions under 50 lines
+- [ ] No print statements in production code
+- [ ] Type hints on public functions
+- [ ] Context managers for file I/O
+- [ ] No TODOs without issue references
+
+## Pruebas
+- [ ] New code has tests
+- [ ] Edge cases covered
+- [ ] No skipped tests without explanation
+
+## Documentación
+- [ ] API changes documented
+- [ ] Breaking changes noted
+- [ ] README updated if needed
+
+## Formato de salida
+Provide results as:
+- ✅ PASS: Items that look good
+- ⚠️ WARN: Items that could be improved
+- ❌ FAIL: Items that must be fixed before merge
+EOF
+```
+
+### Ir más allá
+
+1. **Desafío de creación de skills**: Crea una skill `quick-review` que haga una lista de verificación de 3 puntos:
+ - Cláusulas except sin especificar
+ - Falta de hints de tipo
+ - Nombres de variables poco claros
+
+ Pruébala preguntando: "Haz una revisión rápida de books.py"
+
+2. **Comparación de skills**: Cronometra cuánto tardas en escribir manualmente un prompt detallado de revisión de seguridad. Luego simplemente pregunta "Comprueba si hay problemas de seguridad en este archivo" y deja que tu skill de auditoría de seguridad se cargue automáticamente. ¿Cuánto tiempo ahorró la skill?
+
+3. **Desafío de skill para el equipo**: Piensa en la lista de comprobación de revisión de código de tu equipo. ¿Podrías codificarla como una skill? Anota 3 cosas que la skill debería revisar siempre.
+
+**Autoevaluación**: Entenderás las skills cuando puedas explicar por qué importa el campo `description` (es como Copilot decide si cargar tu skill).
+
+---
+
+## 📝 Tarea
+
+### Desafío principal: Crea una skill de resumen de libros
+
+Los ejemplos anteriores crearon las skills `pytest-gen` y `pr-review`. Ahora practica creando un tipo de skill completamente diferente: una para generar salida formateada a partir de datos.
+
+1. Lista tus skills actuales: Ejecuta Copilot y pásale `/skills list`. También puedes usar `ls .github/skills/` para ver las skills del proyecto o `ls ~/.copilot/skills/` para las personales.
+2. Crea una skill `book-summary` en `.github/skills/book-summary/SKILL.md` que genere un resumen en Markdown formateado de la colección de libros
+3. Tu skill debe tener:
+ - Nombre y descripción claros (¡la descripción es crucial para el emparejamiento!)
+ - Reglas de formato específicas (p. ej., tabla en Markdown con título, autor, año, estado de lectura)
+ - Convenciones de salida (p. ej., usa ✅/❌ para el estado de lectura, ordenar por año)
+4. Prueba la skill: `@samples/book-app-project/data.json Summarize the books in this collection`
+5. Verifica que la skill se active automáticamente comprobando `/skills list`
+6. Intenta invocarla directamente con `/book-summary Summarize the books in this collection`
+
+**Criterios de éxito**: Tienes una skill `book-summary` funcionando que Copilot aplica automáticamente cuando preguntas sobre la colección de libros.
+
+
+
+
+### Desafío extra: Skill de mensajes de commit
+
+1. Crea una skill `commit-message` que genere mensajes de commit convencionales con un formato consistente
+2. Pruébala poniendo en stage un cambio y preguntando: "Genera un mensaje de commit para mis cambios en stage"
+3. Documenta tu skill y compártela en GitHub con el tema `copilot-skill`
+
+---
+
+💡 Sugerencias (haz clic para expandir)
+ +**Plantilla inicial**: Crea `.github/skills/book-summary/SKILL.md`: + +```markdown +--- +name: book-summary +description: Generate a formatted markdown summary of a book collection +--- + +# Book Summary Generator + +Generate a summary of the book collection following these rules: + +1. Output a markdown table with columns: Title, Author, Year, Status +2. Use ✅ for read books and ❌ for unread books +3. Sort by year (oldest first) +4. Include a total count at the bottom +5. Flag any data issues (missing authors, invalid years) + +Example: +| Title | Author | Year | Status | +|-------|--------|------|--------| +| 1984 | George Orwell | 1949 | ✅ | +| Dune | Frank Herbert | 1965 | ❌ | + +**Total: 2 books (1 read, 1 unread)** +``` + +**Pruébalo:** +```bash +copilot +> @samples/book-app-project/data.json Summarize the books in this collection +# La habilidad debería activarse automáticamente según la coincidencia de la descripción +``` + +**Si no se activa:** Intenta `/skills reload` y luego pregunta de nuevo. + +
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **Las skills se cargan automáticamente**: Copilot las carga cuando tu prompt coincide con la descripción de la skill
+2. **Invocación directa**: También puedes invocar skills directamente con `/skill-name` como comando slash
+3. **Formato SKILL.md**: Frontmatter YAML (name, description, licencia opcional) más instrucciones en Markdown
+4. **La ubicación importa**: `.github/skills/` para compartir en proyecto/equipo, `~/.copilot/skills/` para uso personal
+5. **La descripción es clave**: Escribe descripciones que coincidan con la forma en que preguntas naturalmente
+
+> 📋 **Referencia rápida**: Consulta la [Referencia de comandos de GitHub Copilot CLI](https://docs.github.com/en/copilot/reference/cli-command-reference) para una lista completa de comandos y atajos.
+
+---
+
+## ➡️ ¿Qué sigue?
+
+Las skills amplían lo que Copilot puede hacer con instrucciones que se cargan automáticamente. ¿Pero qué pasa con la conexión a servicios externos? Ahí es donde entra MCP.
+
+En **[Capítulo 06: Servidores MCP](../06-mcp-servers/README.md)**, aprenderás:
+
+- Qué es MCP (Model Context Protocol)
+- Conexión a GitHub, sistema de archivos y servicios de documentación
+- Configurar servidores MCP
+- Flujos de trabajo multi-servidor
+
+---
+
+**[← Volver al Capítulo 04](../04-agents-custom-instructions/README.md)** | **[Continuar al Capítulo 06 →](../06-mcp-servers/README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/06-mcp-servers/README.md b/translations/es/06-mcp-servers/README.md
new file mode 100644
index 00000000..23feed33
--- /dev/null
+++ b/translations/es/06-mcp-servers/README.md
@@ -0,0 +1,981 @@
+
+
+> **¿Y si Copilot pudiera leer tus issues de GitHub, revisar tu base de datos y crear PRs... todo desde la terminal?**
+
+Hasta ahora, Copilot solo puede trabajar con lo que le das directamente: archivos que referencias con `@`, el historial de la conversación y sus propios datos de entrenamiento. Pero, ¿y si pudiera salir por su cuenta para revisar tu repositorio de GitHub, examinar los archivos de tu proyecto o consultar la documentación más reciente de una biblioteca?
+
+Eso es lo que hace MCP (Model Context Protocol). Es una forma de conectar Copilot a servicios externos para que tenga acceso a datos en vivo y del mundo real. Cada servicio al que Copilot se conecta se llama "servidor MCP". En este capítulo, configurarás algunas de estas conexiones y verás cómo hacen que Copilot sea mucho más útil.
+
+> 💡 **¿Ya estás familiarizado con MCP?** [Ir al inicio rápido](#-use-the-built-in-github-mcp) para confirmar que funciona y empezar a configurar servidores.
+
+## 🎯 Objetivos de aprendizaje
+
+Al final de este capítulo, serás capaz de:
+
+- Entender qué es MCP y por qué importa
+- Gestionar servidores MCP usando comandos `/mcp`
+- Configurar servidores MCP para GitHub, sistema de archivos y documentación
+- Usar flujos de trabajo potenciados por MCP con el proyecto de la app del libro
+- Saber cuándo y cómo crear un servidor MCP personalizado (opcional)
+
+> ⏱️ **Tiempo estimado**: ~50 minutos (15 min lectura + 35 min práctica)
+
+---
+
+## 🧩 Analogía del mundo real: Extensiones del navegador
+
+🔧 Errores comunes y solución de problemas (haz clic para expandir)
+ +### Errores comunes + +| Error | Qué ocurre | Solución | +|---------|--------------|-----| +| Nombrar el archivo con otro nombre que no sea `SKILL.md` | La skill no será reconocida | El archivo debe llamarse exactamente `SKILL.md` | +| Campo `description` vago | La skill nunca se carga automáticamente | La descripción es el mecanismo PRINCIPAL de descubrimiento. Usa palabras clave específicas | +| Falta `name` o `description` en el frontmatter | La skill no se carga | Añade ambos campos en el frontmatter YAML | +| Ubicación de carpeta incorrecta | Skill no encontrada | Usa `.github/skills/skill-name/` (proyecto) o `~/.copilot/skills/skill-name/` (personal) | + +### Solución de problemas + +**Skill no usada** - Si Copilot no está usando tu skill cuando se espera: + +1. **Revisa la descripción**: ¿Coincide con la forma en que preguntas? + ```markdown + # Bad: Too vague + description: Reviews code + + # Good: Includes trigger words + description: Use for code reviews, checking code quality, + finding bugs, security issues, and best practice violations + ``` + +2. **Verifica la ubicación del archivo**: + ```bash + # Habilidades del proyecto + ls .github/skills/ + + # Habilidades del usuario + ls ~/.copilot/skills/ + ``` + +3. **Revisa el formato de SKILL.md**: El frontmatter es obligatorio: + ```markdown + --- + name: skill-name + description: What the skill does and when to use it + --- + + # Instructions here + ``` + +**Skill no aparece** - Verifica la estructura de carpetas: +``` +.github/skills/ +└── my-skill/ # Folder name + └── SKILL.md # Must be exactly SKILL.md (case-sensitive) +``` + +Ejecuta `/skills reload` tras crear o editar skills para asegurarte de que los cambios se carguen. + +**Probar si una skill se carga** - Pregunta a Copilot directamente: +```bash +> What skills do you have available for checking code quality? +# Copilot describirá las habilidades relevantes que encontró +``` + +**¿Cómo sé si mi skill realmente está funcionando?** + +1. **Revisa el formato de salida**: Si tu skill especifica un formato de salida (como etiquetas `[CRITICAL]`), búscalo en la respuesta +2. **Pregunta directamente**: Después de obtener una respuesta, pregunta "¿Usaste alguna skill para eso?" +3. **Compara con/sin**: Prueba el mismo prompt con `--no-custom-instructions` para ver la diferencia: + ```bash + # Con habilidades + copilot --allow-all -p "Review @file.py for security issues" + + # Sin habilidades (comparación de referencia) + copilot --allow-all -p "Review @file.py for security issues" --no-custom-instructions + ``` +4. **Revisa comprobaciones específicas**: Si tu skill incluye comprobaciones específicas (como "funciones de más de 50 líneas"), verifica si aparecen en la salida + +
+
+Piensa en los servidores MCP como extensiones del navegador. Tu navegador por sí solo puede mostrar páginas web, pero las extensiones lo conectan a servicios adicionales:
+
+| Extensión del navegador | A qué se conecta | Equivalente MCP |
+|------------------------|-------------------|-----------------|
+| Password manager | Tu almacén de contraseñas | **GitHub MCP** → tus repos, issues, PRs |
+| Grammarly | Servicio de análisis de redacción | **Context7 MCP** → documentación de bibliotecas |
+| File manager | Almacenamiento en la nube | **Filesystem MCP** → archivos del proyecto local |
+
+Sin extensiones, tu navegador sigue siendo útil, pero con ellas se convierte en una potencia. Los servidores MCP hacen lo mismo por Copilot. Lo conectan a fuentes de datos reales y en vivo para que pueda leer tus issues de GitHub, explorar tu sistema de archivos, obtener documentación actualizada y más.
+
+***Los servidores MCP conectan Copilot con el mundo exterior: GitHub, repositorios, documentación y más***
+
+> 💡 **Idea clave**: Sin MCP, Copilot solo puede ver archivos que compartes explícitamente con `@`. Con MCP, puede explorar proactivamente tu proyecto, revisar tu repositorio de GitHub y consultar documentación, todo automáticamente.
+
+---
+
+
+
+# Inicio rápido: MCP en 30 segundos
+
+## Comienza con el servidor MCP de GitHub integrado
+Veamos MCP en acción ahora mismo, antes de configurar nada.
+El servidor MCP de GitHub está incluido por defecto. Prueba esto:
+
+```bash
+copilot
+> List the recent commits in this repository
+```
+
+Si Copilot devuelve datos reales de commits, acabas de ver MCP en acción. Ese es el servidor MCP de GitHub conectándose a GitHub en tu nombre. Pero GitHub es solo *uno* de los servidores. Este capítulo te muestra cómo añadir más (acceso al sistema de archivos, documentación actualizada y otros) para que Copilot pueda hacer aún más.
+
+---
+
+## El comando `/mcp show`
+
+Usa `/mcp show` para ver qué servidores MCP están configurados y si están habilitados:
+
+```bash
+copilot
+
+> /mcp show
+
+MCP Servers:
+✓ github (enabled) - GitHub integration
+✓ filesystem (enabled) - File system access
+```
+
+> 💡 **¿Solo ves el servidor de GitHub?** ¡Eso es esperado! Si aún no has añadido servidores MCP adicionales, GitHub es el único que aparece. Añadirás más en la siguiente sección.
+
+> 📚 **¿Quieres ver todos los comandos de gestión de MCP?** Puedes gestionar servidores con comandos slash `/mcp` dentro del chat, o con `copilot mcp` directamente desde tu terminal. Consulta la [referencia completa de comandos](#-additional-mcp-commands) al final de este capítulo.
+
+
+
+
+---
+
+## ¿Qué cambia con MCP?
+
+He aquí la diferencia que hace MCP en la práctica:
+
+**Sin MCP:**
+```bash
+> What's in GitHub issue #42?
+
+"I don't have access to GitHub. You'll need to copy and paste the issue content."
+```
+
+**Con MCP:**
+```bash
+> What's in GitHub issue #42 of this repository?
+
+Issue #42: El inicio de sesión falla con caracteres especiales.
+Status: Open
+Labels: bug, priority-high
+Description: Users report that passwords containing...
+```
+
+MCP hace que Copilot sea consciente de tu entorno de desarrollo real.
+
+> 📚 **Documentación oficial**: [Acerca de MCP](https://docs.github.com/copilot/concepts/context/mcp) para profundizar en cómo MCP funciona con GitHub Copilot.
+
+---
+
+# Configuración de servidores MCP
+
+🎬 ¡Míralo en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas diferirán de lo que se muestra aquí.* + +
+
+Ahora que has visto MCP en acción, vamos a configurar servidores adicionales. Puedes añadir servidores de dos maneras: **desde el registro integrado** (más fácil: configuración guiada directamente en la CLI) o **editando el archivo de configuración** manualmente (más flexible). Empieza con la opción del registro si no estás seguro de cuál elegir.
+
+---
+
+## Instalación de servidores MCP desde el registro
+
+La CLI tiene un registro integrado de servidores MCP que te permite descubrir e instalar servidores populares con una configuración guiada — no se requiere editar JSON.
+
+```bash
+copilot
+
+> /mcp search
+```
+
+Copilot abre un selector interactivo que muestra los servidores disponibles. Selecciona uno y la CLI te guía por cualquier configuración requerida (claves API, rutas, etc.) y lo añade a tu configuración automáticamente.
+
+> 💡 **¿Por qué usar el registro?** Es la forma más fácil de empezar — no necesitas saber el nombre del paquete npm, los argumentos del comando o la estructura JSON. La CLI se encarga de todo eso por ti.
+
+---
+
+## Archivo de configuración de MCP
+
+Los servidores MCP se configuran en `~/.copilot/mcp-config.json` (a nivel de usuario, se aplica a todos los proyectos) o en `.mcp.json` (a nivel de proyecto, colocado en la raíz de tu proyecto). Si usaste `/mcp search` arriba, la CLI ya creó o actualizó este archivo por ti, pero es útil entender el formato para personalizaciones.
+
+> ⚠️ **Nota**: `.vscode/mcp.json` ya no es compatible como fuente de configuración MCP. Si tienes un `.vscode/mcp.json` existente, migra su contenido a `.mcp.json` en la raíz de tu proyecto. La CLI mostrará un aviso de migración si detecta un archivo de configuración antiguo.
+
+```json
+{
+ "mcpServers": {
+ "server-name": {
+ "type": "local",
+ "command": "npx",
+ "args": ["@package/server-name"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+*La mayoría de los servidores MCP se distribuyen como paquetes npm y se ejecutan mediante el comando `npx`.*
+
+
+
+
+---
+
+## Agregar servidores MCP
+
+El servidor MCP de GitHub está integrado y no requiere configuración. A continuación hay servidores adicionales que puedes añadir. **Elige lo que te interese o recórrelos en orden.**
+
+| Quiero... | Ir a |
+|---|---|
+| Permitir que Copilot explore mis archivos de proyecto | [Servidor de sistema de archivos](#servidor-de-sistema-de-archivos) |
+| Obtener documentación de bibliotecas actualizada | [Servidor Context7](#servidor-context7-documentación) |
+| Explorar extras opcionales (servidores personalizados, web_fetch) | [Más allá de lo básico](#más-allá-de-lo-básico) |
+
+💡 ¿Nuevo en JSON? Haz clic aquí para aprender qué significa cada campo
+ +| Field | Qué Significa | +|-------|---------------| +| `"mcpServers"` | Contenedor para todas tus configuraciones de servidores MCP | +| `"server-name"` | Un nombre que eliges (por ejemplo, "github", "filesystem") | +| `"type": "local"` | El servidor se ejecuta en tu máquina | +| `"command": "npx"` | El programa a ejecutar (npx ejecuta paquetes npm) | +| `"args": [...]` | Argumentos pasados al comando | +| `"tools": ["*"]` | Permitir todas las herramientas de este servidor | + +**Reglas importantes de JSON:** +- Usa comillas dobles `"` para cadenas (no comillas simples) +- No pongas comas finales después del último elemento +- El archivo debe ser JSON válido (usa un [validador JSON](https://jsonlint.com/) si tienes dudas) + +
+
+
+Servidor de sistema de archivos - Permitir que Copilot explore los archivos de tu proyecto
+ + +### Servidor de sistema de archivos + +```json +{ + "mcpServers": { + "filesystem": { + "type": "local", + "command": "npx", + "args": ["-y", "@modelcontextprotocol/server-filesystem", "."], + "tools": ["*"] + } + } +} +``` + +> 💡 **La ruta `.`**: El `.` significa "directorio actual". Copilot puede acceder a archivos relativos a donde lo hayas lanzado. En un Codespace, esto es la raíz de tu espacio de trabajo. También puedes usar una ruta absoluta como `/workspaces/copilot-cli-for-beginners` si lo prefieres. + +Añade esto a tu `~/.copilot/mcp-config.json` y reinicia Copilot. + +
+
+
+Servidor Context7 - Obtener documentación de bibliotecas actualizada
+ + +### Servidor Context7 (Documentación) + +Context7 da a Copilot acceso a documentación actualizada para frameworks y bibliotecas populares. En lugar de depender de datos de entrenamiento que podrían estar desfasados, Copilot recupera la documentación actual real. + +```json +{ + "mcpServers": { + "context7": { + "type": "local", + "command": "npx", + "args": ["-y", "@upstash/context7-mcp"], + "tools": ["*"] + } + } +} +``` + +- ✅ **No se requiere clave API** +- ✅ **No se necesita cuenta** +- ✅ **Tu código permanece local** + +Añade esto a tu `~/.copilot/mcp-config.json` y reinicia Copilot. + +
+
+
+
+
+### Archivo de configuración completo
+
+Aquí tienes un `mcp-config.json` completo con los servidores filesystem y Context7:
+
+> 💡 **Nota:** El MCP de GitHub está integrado. No necesitas añadirlo a tu archivo de configuración.
+
+```json
+{
+ "mcpServers": {
+ "filesystem": {
+ "type": "local",
+ "command": "npx",
+ "args": ["-y", "@modelcontextprotocol/server-filesystem", "."],
+ "tools": ["*"]
+ },
+ "context7": {
+ "type": "local",
+ "command": "npx",
+ "args": ["-y", "@upstash/context7-mcp"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+Guarda esto como `~/.copilot/mcp-config.json` para acceso global o `.mcp.json` en la raíz del proyecto para una configuración específica del proyecto.
+
+---
+
+# Usar servidores MCP
+
+Ahora que tienes servidores MCP configurados, veamos qué pueden hacer.
+
+Más allá de lo básico - Servidores personalizados y acceso web (opcional)
+ + +Estos son extras opcionales para cuando te sientas cómodo con los servidores principales anteriores. + +### Servidor MCP de Microsoft Learn + +Hasta ahora todos los servidores MCP que has visto (filesystem, Context7) se ejecutan localmente en tu máquina. Pero los servidores MCP también pueden ejecutarse de forma remota, lo que significa que solo apuntas la CLI de Copilot a una URL y ella se encarga del resto. Sin `npx` ni `python`, sin proceso local, sin dependencias que instalar. + +El [Servidor MCP de Microsoft Learn](https://github.com/microsoftdocs/mcp) es un buen ejemplo. Proporciona a la CLI de Copilot acceso directo a la documentación oficial de Microsoft (Azure, Microsoft Foundry y otros temas de IA, .NET, Microsoft 365 y mucho más) para que pueda buscar en la documentación, recuperar páginas completas y encontrar ejemplos de código oficiales en lugar de depender de los datos de entrenamiento de un modelo. + +- ✅ **No se requiere clave API** +- ✅ **No se necesita cuenta** +- ✅ **No se requiere instalación local** + +**Instalación rápida con `/plugin install`:** + +En lugar de editar tu archivo JSON manualmente, puedes instalarlo con un solo comando: + +```bash +copilot + +> /plugin install microsoftdocs/mcp +``` + +Esto añade el servidor y sus skills de agente asociados automáticamente. Las skills instaladas incluyen: + +- **microsoft-docs**: Conceptos, tutoriales y búsquedas de hechos +- **microsoft-code-reference**: Consultas de API, ejemplos de código y resolución de problemas +- **microsoft-skill-creator**: Una meta-skill para generar skills personalizadas sobre tecnologías de Microsoft + +**Uso:** +```bash +copilot + +> What's the recommended way to deploy a Python app to Azure App Service? Search Microsoft Learn. +``` + +📚 Más información: [Descripción general del servidor MCP de Microsoft Learn](https://learn.microsoft.com/training/support/mcp-get-started) + +### Acceso web con `web_fetch` + +La CLI de Copilot incluye una herramienta integrada `web_fetch` que puede obtener contenido de cualquier URL. Esto es útil para traer README, documentación de API o notas de versión sin salir de tu terminal. No se necesita servidor MCP. + +Puedes controlar qué URLs son accesibles mediante `~/.copilot/config.json` (configuración general de Copilot), que es independiente de `~/.copilot/mcp-config.json` (definiciones de servidores MCP). + +```json +{ + "permissions": { + "allowedUrls": [ + "https://api.github.com/**", + "https://docs.github.com/**", + "https://*.npmjs.org/**" + ], + "blockedUrls": [ + "http://**" + ] + } +} +``` + +**Uso:** +```bash +copilot + +> Fetch and summarize the README from https://github.com/facebook/react +``` + +### Crear un servidor MCP personalizado + +¿Quieres conectar Copilot a tus propias APIs, bases de datos o herramientas internas? Puedes crear un servidor MCP personalizado en Python. Esto es completamente opcional, ya que los servidores preconstruidos (GitHub, filesystem, Context7) cubren la mayoría de los casos de uso. + +📖 Consulta la [Guía de servidor MCP personalizado](mcp-custom-server.md) para un recorrido completo utilizando la app del libro como ejemplo. + +📚 Para más información, consulta el [curso MCP para principiantes](https://github.com/microsoft/mcp-for-beginners). + +
+
+---
+
+## Ejemplos de uso del servidor
+**Elige un servidor para explorar, o recórrelos en orden.**
+
+| Quiero probar... | Ir a |
+|---|---|
+| Repositorios de GitHub, issues y PRs | [Servidor de GitHub](#servidor-de-github-integrado) |
+| Explorar archivos del proyecto | [Uso del Servidor del Sistema de Archivos](#filesystem-server-usage) |
+| Búsqueda de documentación de la biblioteca | [Uso del Servidor Context7](#context7-server-usage) |
+| Servidor personalizado, Microsoft Learn MCP y uso de web_fetch | [Más allá de lo básico](#más-allá-de-lo-básico) |
+
+
+
+
+Servidor de GitHub (integrado) - Accede a repositorios, issues, PRs y más
+ + +### Servidor de GitHub (integrado) + +El servidor MCP de GitHub está **integrado**. Si iniciaste sesión en Copilot (lo que hiciste durante la configuración inicial), ya funciona. ¡No se necesita configuración! + +> 💡 **¿No funciona?** Ejecuta `/login` para volver a autenticarte con GitHub. + +
+
+
+| Funcionalidad | Ejemplo |
+|---------|----------|
+| **Información del repositorio** | Ver commits, ramas, colaboradores |
+| **Incidencias** | Listar, crear, buscar y comentar incidencias |
+| **Pull requests** | Ver PRs, diffs, crear PRs, comprobar estado |
+| **Búsqueda de código** | Buscar código en repositorios |
+| **Actions** | Consultar ejecuciones de workflows y estado |
+
+```bash
+copilot
+
+# Ver la actividad reciente en este repositorio
+> List the last 5 commits in this repository
+
+Recent commits:
+1. abc1234 - Update chapter 05 skills examples (2 days ago)
+2. def5678 - Add book app test fixtures (3 days ago)
+3. ghi9012 - Fix typo in chapter 03 README (4 days ago)
+...
+
+# Explorar la estructura del repositorio
+> What branches exist in this repository?
+
+Branches:
+- main (default)
+- chapter6 (current)
+
+# Buscar patrones de código en todo el repositorio
+> Search this repository for files that import pytest
+
+Found 1 file:
+- samples/book-app-project/tests/test_books.py
+```
+
+> 💡 **¿Trabajando en tu propio fork?** Si hiciste un fork de este repositorio del curso, también puedes probar operaciones de escritura como crear issues y pull requests. Practicaremos eso en los ejercicios más abajo.
+
+> ⚠️ **¿No ves resultados?** El MCP de GitHub opera sobre el remoto del repositorio (en github.com), no solo los archivos locales. Asegúrate de que tu repo tenga un remoto: ejecuta `git remote -v` para comprobarlo.
+
+Autenticación en contenedores de desarrollo
+ +- **GitHub Codespaces** (recomendado): La autenticación es automática. La CLI `gh` hereda tu token de Codespace. No se requiere acción. +- **Contenedor de desarrollo local (Docker)**: Ejecuta `gh auth login` después de que el contenedor se inicie, luego reinicia Copilot. + +**Solución de problemas de autenticación:** +```bash +# Comprueba si estás autenticado +gh auth status + +# Si no, inicia sesión +gh auth login + +# Verifica que el MCP de GitHub esté conectado +copilot +> /mcp show +``` + +
+
+
+Servidor del sistema de archivos - Explora y analiza archivos del proyecto
+ + +### Servidor del sistema de archivos + +Una vez configurado, el MCP de sistema de archivos proporciona herramientas que Copilot puede usar automáticamente: + +```bash +copilot + +> How many Python files are in the book-app-project directory? + +Found 3 Python files in samples/book-app-project/: +- book_app.py +- books.py +- utils.py + +> What's the total size of the data.json file? + +samples/book-app-project/data.json: 2.4 KB + +> Find all functions that don't have type hints in the book app + +Found 2 functions without type hints: +- samples/book-app-project/utils.py:10 - get_user_choice() +- samples/book-app-project/utils.py:14 - get_book_details() +``` + +
+
+
+Servidor Context7 - Consulta documentación de bibliotecas
+ + +### Servidor Context7 + +```bash +copilot + +> What are the best practices for using pytest fixtures? + +From pytest Documentation: + +Fixtures - Use fixtures to provide a fixed baseline for tests: + + import pytest + + @pytest.fixture + def sample_books(): + return [ + {"title": "1984", "author": "George Orwell", "year": 1949}, + {"title": "Dune", "author": "Frank Herbert", "year": 1965}, + ] + + def test_find_by_author(sample_books): + # el fixture se pasa automáticamente como argumento + results = [b for b in sample_books if "Orwell" in b["author"]] + assert len(results) == 1 + +Best practices: +- Use fixtures instead of setup/teardown methods +- Use tmp_path fixture for temporary files +- Use monkeypatch for modifying environment +- Scope fixtures appropriately (function, class, module, session) + +> How can I apply this to the book app's test file? + +# Copilot ahora conoce los patrones oficiales de pytest +# y puede aplicarlos a samples/book-app-project/tests/test_books.py +``` + +
+
+
+---
+
+## Flujos de trabajo con múltiples servidores
+
+Estos flujos de trabajo muestran por qué los desarrolladores dicen "Nunca quiero trabajar sin esto de nuevo." Cada ejemplo combina varios servidores MCP en una sola sesión.
+
+Más allá de lo básico - Servidor personalizado y uso de web_fetch
+ + +### Más allá de lo básico + +**Servidor MCP personalizado**: Si construiste el servidor de búsqueda de libros a partir de la [Guía de servidor MCP personalizado](mcp-custom-server.md), puedes consultar tu colección de libros directamente: + +```bash +copilot + +> Look up information about "1984" using the book lookup server. Search for books by George Orwell +``` + +**Microsoft Learn MCP**: Si instalaste el [servidor MCP de Microsoft Learn](#servidor-mcp-de-microsoft-learn), puedes consultar la documentación oficial de Microsoft directamente: + +```bash +copilot + +> How do I configure managed identity for an Azure Function? Search Microsoft Learn. +``` + +**Web Fetch**: Usa la herramienta integrada `web_fetch` para obtener contenido de cualquier URL: + +```bash +copilot + +> Fetch and summarize the README from https://github.com/facebook/react +``` + +
+
+*Flujo MCP completo: el MCP de GitHub recupera datos del repo, el MCP del sistema de archivos encuentra código, el MCP Context7 proporciona mejores prácticas y Copilot realiza el análisis*
+
+Cada ejemplo a continuación es autónomo. **Elige uno que te interese o léelos todos.**
+
+| Quiero ver... | Ir a |
+|---|---|
+| Varios servidores trabajando juntos | [Exploración multi-servidor](#multi-server-exploration) |
+| Ir de issue a PR en una sesión | [Flujo Issue a PR](#flujo-issue-a-pr-en-tu-propio-repo) |
+| Un chequeo rápido de salud del proyecto | [Panel de estado](#panel-de-estado-de-book-app) |
+
+
+
+
+Exploración multi-servidor - Combina el MCP del sistema de archivos, GitHub y Context7 en una sesión
+ + +#### Explorando la aplicación Book App con múltiples servidores MCP + +```bash +copilot + +# Paso 1: Use el MCP del sistema de archivos para explorar la aplicación de libros +> List all Python files in samples/book-app-project/ and summarize +> what each file does + +Found 3 Python files: +- book_app.py: CLI entry point with command routing (list, add, remove, find) +- books.py: BookCollection class with data persistence via JSON +- utils.py: Helper functions for user input and display + +# Paso 2: Use el MCP de GitHub para comprobar los cambios recientes +> What were the last 3 commits that touched files in samples/book-app-project/? + +Recent commits affecting book app: +1. abc1234 - Add test fixtures for BookCollection (2 days ago) +2. def5678 - Add find_by_author method (5 days ago) +3. ghi9012 - Initial book app setup (1 week ago) + +# Paso 3: Use el MCP de Context7 para las mejores prácticas +> What are Python best practices for JSON data persistence? + +From Python Documentation: +- Use context managers (with statements) for file I/O +- Handle JSONDecodeError for corrupted files +- Use dataclasses for structured data +- Consider atomic writes to prevent data corruption + +# Paso 4: Sintetice una recomendación +> Based on the book app code and these best practices, +> what improvements would you suggest? + +Suggestions: +1. Add input validation in add_book() for empty strings and invalid years +2. Consider atomic writes in save_books() to prevent data corruption +3. Add type hints to utils.py functions (get_user_choice, get_book_details) +``` + +
+
+
+**El resultado**: Exploración de código → revisión de historial → búsqueda de mejores prácticas → plan de mejoras. **Todo desde una sesión de terminal, usando tres servidores MCP juntos.**
+
+🎬 ¡Mira el flujo MCP en acción!
+ + + +*La salida de la demo varía. Tu modelo, herramientas y respuestas diferirán de lo mostrado aquí.* + +
+
+
+Flujo Issue a PR - Pasa de una issue de GitHub a un pull request sin salir del terminal
+ + +#### Flujo Issue a PR (en tu propio repo) + +Esto funciona mejor en tu propio fork o repositorio donde tengas acceso de escritura: + +> 💡 **No te preocupes si no puedes probarlo ahora mismo.** Si estás en un clon de solo lectura, practicarás esto en la asignación. Por ahora, solo lee para entender el flujo. + +```bash +copilot + +> Get the details of GitHub issue #1 + +Issue #1: Agregar validación de entrada para el año del libro +Status: Open +Description: The add_book function accepts any year value... + +> @samples/book-app-project/books.py Fix the issue described in issue #1 + +[Copilot implements year validation in add_book()] + +> Run the tests to make sure the fix works + +All 8 tests passed ✓ + +> Create a pull request titled "Add year validation to book app" + +✓ Created PR #2: Agregar validación del año a la aplicación de libros +``` + +**Cero copiar-pegar. Cero cambio de contexto. Una sesión de terminal.** + +
+
+
+---
+
+# Practice
+
+Panel de estado - Obtén un chequeo rápido del estado del proyecto usando múltiples servidores
+ + +#### Panel de estado de Book App + +```bash +copilot + +> Give me a health report for the book app project: +> 1. List all functions across the Python files in samples/book-app-project/ +> 2. Check which functions have type hints and which don't +> 3. Show what tests exist in samples/book-app-project/tests/ +> 4. Check the recent commit history for this directory + +Book App Health Report +====================== + +📊 Functions Found: +- books.py: 8 methods in BookCollection (all have type hints ✓) +- book_app.py: 6 functions (4 have type hints, 2 missing) +- utils.py: 3 functions (1 has type hints, 2 missing) + +🧪 Test Coverage: +- test_books.py: 8 test functions covering BookCollection +- Missing: no tests for book_app.py CLI functions +- Missing: no tests for utils.py helper functions + +📝 Recent Activity: +- 3 commits in the last week +- Most recent: added test fixtures + +Recommendations: +- Add type hints to utils.py functions +- Add tests for book_app.py CLI handlers +- All files well-sized (<100 lines) - good structure! +``` + +**El resultado**: Múltiples fuentes de datos agregadas en segundos. Manualmente, esto implicaría ejecutar grep, contar líneas, comprobar git log y revisar archivos de pruebas. Fácilmente 15+ minutos de trabajo. + +
+
+**🎉 ¡Ahora conoces lo esencial!** Entiendes MCP, has visto cómo configurar servidores y has visto flujos de trabajo reales en acción. Ahora es hora de probarlo tú mismo.
+
+---
+
+## ▶️ Pruébalo tú mismo
+
+¡Ahora es tu turno! Completa estos ejercicios para practicar el uso de servidores MCP con el proyecto de la aplicación de libros.
+
+### Ejercicio 1: Comprueba el estado de tu MCP
+
+Comienza viendo qué servidores MCP están disponibles:
+
+```bash
+copilot
+
+> /mcp show
+```
+
+Deberías ver el servidor de GitHub listado como habilitado. Si no, ejecuta `/login` para autenticarte.
+
+---
+
+### Ejercicio 2: Explora la aplicación de libros con el MCP del sistema de archivos
+
+Si has configurado el servidor del sistema de archivos, úsalo para explorar la aplicación de libros:
+
+```bash
+copilot
+
+> How many Python files are in samples/book-app-project/?
+> What functions are defined in each file?
+```
+
+**Resultado esperado**: Copilot lista `book_app.py`, `books.py` y `utils.py` con sus funciones.
+
+> 💡 **¿Aún no tienes configurado el MCP del sistema de archivos?** Crea el archivo de configuración desde la sección [Configuración completa](#archivo-de-configuración-completo) arriba. Luego reinicia Copilot.
+
+---
+
+### Ejercicio 3: Consulta el historial del repositorio con el MCP de GitHub
+
+Usa el MCP de GitHub incorporado para explorar este repositorio del curso:
+
+```bash
+copilot
+
+> List the last 5 commits in this repository
+
+> What branches exist in this repository?
+```
+
+**Resultado esperado**: Copilot muestra mensajes de commits recientes y nombres de ramas del remoto de GitHub.
+
+> ⚠️ **¿En un Codespace?** Esto funciona automáticamente. La autenticación se hereda. Si estás en un clon local, asegúrate de que `gh auth status` muestre que has iniciado sesión.
+
+---
+
+### Ejercicio 4: Combina varios servidores MCP
+
+Ahora combina el MCP del sistema de archivos y el MCP de GitHub en una sola sesión:
+
+```bash
+copilot
+
+> Read samples/book-app-project/data.json and tell me what books are
+> in the collection. Then check the recent commits to see when this
+> file was last modified.
+```
+
+**Resultado esperado**: Copilot lee el archivo JSON (MCP del sistema de archivos), lista los 5 libros incluyendo "The Hobbit", "1984", "Dune", "To Kill a Mockingbird", y "Mysterious Book", luego consulta GitHub por el historial de commits.
+
+**Autocomprobación**: Comprendes MCP cuando puedas explicar por qué "Check my repo's commit history" es mejor que ejecutar manualmente `git log` y pegar la salida en tu prompt.
+
+---
+
+## 📝 Asignación
+
+### Desafío principal: Exploración MCP de la aplicación de libros
+
+Practica el uso de servidores MCP juntos en el proyecto de la aplicación de libros. Completa estos pasos en una sola sesión de Copilot:
+
+1. **Verifica que MCP funcione**: Ejecuta `/mcp show` y confirma que al menos el servidor de GitHub esté habilitado
+2. **Configura el MCP del sistema de archivos** (si no está hecho): Crea `~/.copilot/mcp-config.json` con la configuración del servidor del sistema de archivos
+3. **Explora el código**: Pide a Copilot que use el servidor del sistema de archivos para:
+ - Listar todas las funciones en `samples/book-app-project/books.py`
+ - Comprobar qué funciones en `samples/book-app-project/utils.py` faltan de anotaciones de tipo
+ - Leer `samples/book-app-project/data.json` e identificar cualquier problema de calidad de datos (pista: mira la última entrada)
+4. **Comprueba la actividad del repositorio**: Pide a Copilot que use el MCP de GitHub para:
+ - Listar commits recientes que tocaron archivos en `samples/book-app-project/`
+ - Comprobar si hay issues abiertas o pull requests
+5. **Combina servidores**: En un solo prompt, pide a Copilot que:
+ - Leer el archivo de pruebas en `samples/book-app-project/tests/test_books.py`
+ - Comparar las funciones probadas con todas las funciones en `books.py`
+ - Resumir qué cobertura de pruebas falta
+
+**Criterios de éxito**: Puedes combinar sin problemas los datos del MCP del sistema de archivos y de GitHub en una sola sesión de Copilot, y puedes explicar qué contribuyó cada servidor MCP a la respuesta.
+
+
+
+
+### Desafío adicional: Construye un servidor MCP personalizado
+
+¿Listo para profundizar? Sigue la [Guía de servidor MCP personalizado](mcp-custom-server.md) para construir tu propio servidor MCP en Python que se conecte a cualquier API.
+
+---
+
+💡 Sugerencias (haz clic para expandir)
+ +**Paso 1: Verifica MCP** +```bash +copilot +> /mcp show +# Debería mostrar "github" como habilitado +# Si no, ejecuta: /login +``` + +**Paso 2: Crea el archivo de configuración** + +Usa el JSON de la sección [Configuración completa](#archivo-de-configuración-completo) arriba y guárdalo como `~/.copilot/mcp-config.json`. + +**Paso 3: Problema de calidad de datos a buscar** + +El último libro en `data.json` es: +```json +{ + "title": "Mysterious Book", + "author": "", + "year": 0, + "read": false +} +``` +Un autor vacío y año 0. ¡Ese es el problema de calidad de datos! + +**Paso 5: Comparación de cobertura de pruebas** + +Las pruebas en `test_books.py` cubren: `add_book`, `mark_as_read`, `remove_book`, `get_unread_books` y `find_book_by_title`. Funciones como `load_books`, `save_books` y `list_books` no tienen pruebas directas. Las funciones de CLI en `book_app.py` y las utilidades en `utils.py` no tienen pruebas en absoluto. + +**Si MCP no funciona:** Reinicia Copilot después de editar el archivo de configuración. + +
+
+Si un servidor está deshabilitado, consulte los [comandos adicionales `/mcp`](#-additional-mcp-commands) a continuación para ver cómo volver a habilitarlo.
+
+
+
+---
+
+🔧 Errores comunes y solución de problemas (haz clic para expandir)
+ +### Errores comunes + +| Error | Qué sucede | Solución | +|---------|--------------|-----| +| No saber que el MCP de GitHub está integrado | Intentar instalar/configurarlo manualmente | El MCP de GitHub está incluido por defecto. Simplemente prueba: "Lista los commits recientes en este repo" | +| Buscar la config en la ubicación equivocada | No puedes encontrar o editar la configuración MCP | La configuración a nivel de usuario está en `~/.copilot/mcp-config.json`, la de proyecto está en `.mcp.json` en la raíz del proyecto | +| JSON inválido en el archivo de configuración | Los servidores MCP no se cargan | Usa `/mcp show` para comprobar la configuración; valida la sintaxis JSON | +| Olvidar autenticar los servidores MCP | Errores de "Authentication failed" | Algunos MCP requieren autenticación separada. Revisa los requisitos de cada servidor | + +### Solución de problemas + +**"MCP server not found"** - Comprueba que: +1. El paquete npm existe: `npm view @modelcontextprotocol/server-github` +2. Tu configuración es JSON válido +3. El nombre del servidor coincide con tu config + +Usa `/mcp show` para ver la configuración actual. + +**"GitHub authentication failed"** - El MCP de GitHub integrado usa tus credenciales de `/login`. Prueba: + +```bash +copilot +> /login +``` + +Esto te volverá a autenticar con GitHub. Si los problemas persisten, verifica que tu cuenta de GitHub tenga los permisos necesarios para el repositorio al que intentas acceder. + +**"MCP server failed to start"** - Comprueba los logs del servidor: +```bash +# Ejecute manualmente el comando del servidor para ver los errores +npx -y @modelcontextprotocol/server-github +``` + +**MCP tools no disponibles** - Asegúrate de que el servidor esté habilitado: +```bash +copilot + +> /mcp show +# Comprobar si el servidor está listado y habilitado +``` + +
+` | Editar la configuración de un servidor existente |
+| `/mcp enable ` | Habilitar un servidor deshabilitado (persiste entre sesiones) |
+| `/mcp disable ` | Deshabilitar un servidor (persiste entre sesiones) |
+| `/mcp delete ` | Eliminar un servidor permanentemente |
+| `/mcp auth ` | Reautenticarse con un servidor MCP que usa OAuth (por ejemplo, después de cambiar de cuenta) |
+
+### Opción 2: comando `copilot mcp` (desde su terminal)
+
+También puede administrar los servidores MCP directamente desde su terminal sin iniciar primero una sesión de chat:
+
+```bash
+# Listar todos los servidores MCP configurados
+copilot mcp list
+
+# Habilitar un servidor
+copilot mcp enable filesystem
+
+# Deshabilitar un servidor
+copilot mcp disable context7
+```
+
+> 💡 **¿Cuándo usar cuál?** Utilice los comandos slash `/mcp` cuando ya esté en una sesión de chat. Utilice `copilot mcp` desde la terminal cuando quiera comprobar o cambiar rápidamente la configuración de su servidor antes de iniciar una sesión.
+
+Para la mayor parte de este curso, `/mcp show` es todo lo que necesita. Los otros comandos resultan útiles a medida que gestiona más servidores con el tiempo.
+
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **MCP** conecta Copilot con servicios externos (GitHub, sistema de archivos, documentación)
+2. **GitHub MCP está integrado** - no se necesita configuración, solo `/login`
+3. **Filesystem y Context7** se configuran mediante `~/.copilot/mcp-config.json`
+4. **Flujos de trabajo con varios servidores** combinan datos de múltiples fuentes en una sola sesión
+5. **Administre servidores de dos maneras**: utilice comandos slash `/mcp` dentro de una sesión de chat, o `copilot mcp` desde la terminal
+6. **Servidores personalizados** le permiten conectar cualquier API (opcional, cubierto en la guía del apéndice)
+
+> 📋 **Referencia rápida**: Consulte la [referencia de comandos CLI de GitHub Copilot](https://docs.github.com/en/copilot/reference/cli-command-reference) para obtener una lista completa de comandos y atajos.
+
+---
+
+## ➡️ ¿Qué sigue?
+
+Ahora tiene todos los elementos: modos, contexto, flujos de trabajo, agentes, habilidades y MCP. Es hora de juntarlos.
+
+En **[Capítulo 07: Juntándolo todo](../07-putting-it-together/README.md)**, aprenderá:
+
+- Combinar agentes, habilidades y MCP en flujos de trabajo unificados
+- Desarrollo completo de una función desde la idea hasta el PR fusionado
+- Automatización con hooks
+- Mejores prácticas para entornos de equipo
+
+---
+
+**[← Volver al Capítulo 05](../05-skills/README.md)** | **[Continuar al Capítulo 07 →](../07-putting-it-together/README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/06-mcp-servers/mcp-custom-server.md b/translations/es/06-mcp-servers/mcp-custom-server.md
new file mode 100644
index 00000000..28956a19
--- /dev/null
+++ b/translations/es/06-mcp-servers/mcp-custom-server.md
@@ -0,0 +1,183 @@
+# Creando un servidor MCP personalizado
+
+> ⚠️ **Este contenido es completamente opcional.** Puedes ser muy productivo con Copilot CLI usando únicamente los servidores MCP preconstruidos (GitHub, filesystem, Context7). Esta guía es para desarrolladores que quieren conectar Copilot a APIs internas personalizadas. Consulta el [curso MCP para principiantes](https://github.com/microsoft/mcp-for-beginners) para más detalles.
+>
+> **Requisitos:**
+> - Cómodo con Python
+> - Comprensión de los patrones `async`/`await`
+> - `pip` disponible en tu sistema (incluido en este contenedor de desarrollo)
+>
+> **[← Volver al Capítulo 06: Servidores MCP](README.md)**
+
+---
+
+¿Quieres conectar Copilot a tus propias APIs? Aquí tienes cómo construir un servidor MCP simple en Python que busca información de libros, enlazando con el proyecto de la aplicación de libros que has estado usando a lo largo de este curso.
+
+## Configuración del proyecto
+
+```bash
+mkdir book-lookup-mcp-server
+cd book-lookup-mcp-server
+pip install mcp
+```
+
+> 💡 **¿Qué es el paquete `mcp`?** Es el SDK oficial de Python para construir servidores MCP. Maneja los detalles del protocolo para que puedas centrarte en tus herramientas.
+
+## Implementación del servidor
+
+Crea un archivo llamado `server.py`:
+
+```python
+# server.py
+import json
+from mcp.server.fastmcp import FastMCP
+
+# Crear el servidor MCP
+mcp = FastMCP("book-lookup")
+
+# Ejemplo de base de datos de libros (en un servidor real, esto podría consultar una API o una base de datos)
+BOOKS_DB = {
+ "978-0-547-92822-7": {
+ "title": "The Hobbit",
+ "author": "J.R.R. Tolkien",
+ "year": 1937,
+ "genre": "Fantasy",
+ },
+ "978-0-451-52493-5": {
+ "title": "1984",
+ "author": "George Orwell",
+ "year": 1949,
+ "genre": "Dystopian Fiction",
+ },
+ "978-0-441-17271-9": {
+ "title": "Dune",
+ "author": "Frank Herbert",
+ "year": 1965,
+ "genre": "Science Fiction",
+ },
+}
+
+
+@mcp.tool()
+def lookup_book(isbn: str) -> str:
+ """Look up a book by its ISBN and return title, author, year, and genre."""
+ book = BOOKS_DB.get(isbn)
+ if book:
+ return json.dumps(book, indent=2)
+ return f"No book found with ISBN: {isbn}"
+
+
+@mcp.tool()
+def search_books(query: str) -> str:
+ """Search for books by title or author. Returns all matching results."""
+ query_lower = query.lower()
+ results = [
+ {**book, "isbn": isbn}
+ for isbn, book in BOOKS_DB.items()
+ if query_lower in book["title"].lower()
+ or query_lower in book["author"].lower()
+ ]
+ if results:
+ return json.dumps(results, indent=2)
+ return f"No books found matching: {query}"
+
+
+@mcp.tool()
+def list_all_books() -> str:
+ """List all books in the database with their ISBNs."""
+ books_list = [
+ {"isbn": isbn, "title": book["title"], "author": book["author"]}
+ for isbn, book in BOOKS_DB.items()
+ ]
+ return json.dumps(books_list, indent=2)
+
+
+if __name__ == "__main__":
+ mcp.run()
+```
+
+**¿Qué está sucediendo aquí?**
+
+| Parte | Qué hace |
+|------|-------------|
+| `FastMCP("book-lookup")` | Crea un servidor llamado "book-lookup" |
+| `@mcp.tool()` | Registra una función como una herramienta que Copilot puede invocar |
+| Anotaciones de tipo + docstrings | Indican a Copilot qué hace cada herramienta y qué parámetros necesita |
+| `mcp.run()` | Inicia el servidor y escucha las solicitudes |
+
+> 💡 **¿Por qué decoradores?** El decorador `@mcp.tool()` es todo lo que necesitas. El SDK de MCP lee automáticamente el nombre de tu función, las anotaciones de tipo y el docstring para generar el esquema de la herramienta. ¡No es necesario un esquema JSON manual!
+
+## Configuración
+
+Agrega a tu `~/.copilot/mcp-config.json`:
+
+```json
+{
+ "mcpServers": {
+ "book-lookup": {
+ "type": "local",
+ "command": "python3",
+ "args": ["./book-lookup-mcp-server/server.py"],
+ "tools": ["*"]
+ }
+ }
+}
+```
+
+## Uso
+
+```bash
+copilot
+
+> Look up the book with ISBN 978-0-547-92822-7
+
+{
+ "title": "The Hobbit",
+ "author": "J.R.R. Tolkien",
+ "year": 1937,
+ "genre": "Fantasy"
+}
+
+> Search for books by Orwell
+
+[
+ {
+ "title": "1984",
+ "author": "George Orwell",
+ "year": 1949,
+ "genre": "Dystopian Fiction",
+ "isbn": "978-0-451-52493-5"
+ }
+]
+
+> List all available books
+
+[Shows all books in the database with ISBNs]
+```
+
+## Próximos pasos
+
+Una vez que hayas construido un servidor básico, puedes:
+
+1. **Agregar más herramientas** - Cada función `@mcp.tool()` se convierte en una herramienta que Copilot puede invocar
+2. **Conectar APIs reales** - Reemplaza la base de datos simulada `BOOKS_DB` con llamadas API reales o consultas a bases de datos
+3. **Agregar autenticación** - Maneja las claves de API y tokens de forma segura
+4. **Compartir tu servidor** - Publícalo en PyPI para que otros puedan instalarlo con `pip`
+
+## Recursos
+
+- [SDK de MCP para Python](https://github.com/modelcontextprotocol/python-sdk)
+- [SDK de MCP para TypeScript](https://github.com/modelcontextprotocol/typescript-sdk)
+- [Servidores MCP de ejemplo](https://github.com/modelcontextprotocol/servers)
+- [Curso MCP para principiantes](https://github.com/microsoft/mcp-for-beginners)
+
+---
+
+**[← Volver al Capítulo 06: Servidores MCP](README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/07-putting-it-together/README.md b/translations/es/07-putting-it-together/README.md
new file mode 100644
index 00000000..357b9316
--- /dev/null
+++ b/translations/es/07-putting-it-together/README.md
@@ -0,0 +1,519 @@
+
+
+> **Todo lo que aprendiste se combina aquí. Pasa de la idea a un PR fusionado en una sola sesión.**
+
+En este capítulo, juntarás todo lo que has aprendido en flujos de trabajo completos. Construirás funciones usando colaboración multiagente, configurarás hooks de pre-commit que detecten problemas de seguridad antes de que se cometan, integrarás Copilot en pipelines de CI/CD y pasarás de la idea de la función a un PR fusionado en una única sesión de terminal. Aquí es donde GitHub Copilot CLI se convierte en un verdadero multiplicador de fuerza.
+
+> 💡 **Nota**: Este capítulo muestra cómo combinar todo lo que aprendiste. **No necesitas agentes, skills, ni MCP para ser productivo (aunque pueden ser muy útiles).** El flujo de trabajo central — describir, planear, implementar, probar, revisar, enviar — funciona solo con las funciones integradas de los Capítulos 00-03.
+
+## 🎯 Objetivos de aprendizaje
+
+Al final de este capítulo, serás capaz de:
+
+- Combinar agentes, habilidades y MCP (Protocolo de Contexto de Modelo) en flujos de trabajo unificados
+- Construir funciones completas usando enfoques multi-herramienta
+- Configurar automatización básica con hooks
+- Aplicar buenas prácticas para desarrollo profesional
+
+> ⏱️ **Tiempo estimado**: ~75 minutos (15 min de lectura + 60 min prácticos)
+
+---
+
+## 🧩 Analogía del mundo real: La orquesta
+
+📚 Comandos MCP adicionales (haga clic para expandir)
+ + +Puede administrar los servidores MCP de dos maneras: usando **comandos slash dentro de una sesión de chat**, o usando el **comando `copilot mcp` directamente en su terminal** (no se necesita iniciar una sesión de chat). + +### Opción 1: Comandos slash (dentro de una sesión de chat) + +Estos funcionan cuando ya estás dentro de `copilot`: + +| Comando | Qué hace | +|---------|--------------| +| `/mcp show` | Mostrar todos los servidores MCP configurados y su estado | +| `/mcp add` | Configuración interactiva para agregar un nuevo servidor | +| `/mcp edit
+
+Una orquesta sinfónica tiene muchas secciones:
+- **Cuerdas** proporcionan la base (como tus flujos de trabajo principales)
+- **Metales** añaden potencia (como agentes con experiencia especializada)
+- **Vientos** añaden color (como habilidades que extienden capacidades)
+- **Percusión** mantiene el ritmo (como MCP conectando con sistemas externos)
+
+Individualmente, cada sección suena limitada. Juntas, bien dirigidas, crean algo magnífico.
+
+**¡Esto es lo que enseña este capítulo!**+*Como un director con una orquesta, orquestas agentes, habilidades y MCP en flujos de trabajo unificados* + +Comencemos recorriendo un escenario que modifica código, genera pruebas, lo revisa y crea un PR - todo en una sesión. + +--- + +## De la idea a un PR fusionado en una sesión + +En lugar de cambiar entre tu editor, terminal, runner de pruebas, docs y la UI de GitHub y perder contexto cada vez, puedes combinar todas tus herramientas en una sesión de terminal. Desglosaremos este patrón en la sección [El patrón de integración](#el-patrón-de-integración) más abajo. + +```bash +# Iniciar Copilot en modo interactivo +copilot + +> I need to add a "list unread" command to the book app that shows only +> books where read is False. What files need to change? + +# Copilot crea un plan de alto nivel... + +# CAMBIAR AL AGENTE PYTHON-REVIEWER +> /agent +# Seleccionar "python-reviewer" + +> @samples/book-app-project/books.py Design a get_unread_books method. +> What is the best approach? + +# El agente python-reviewer produce: +# - Firma del método y tipo de retorno +# - Implementación del filtro usando comprensión de listas +# - Manejo de casos límite para colecciones vacías + +# CAMBIAR AL AGENTE PYTEST-HELPER +> /agent +# Seleccionar "pytest-helper" + +> @samples/book-app-project/tests/test_books.py Design test cases for +> filtering unread books. + +# El agente pytest-helper produce: +# - Casos de prueba para colecciones vacías +# - Casos de prueba con libros leídos/no leídos mezclados +# - Casos de prueba con todos los libros leídos + +# IMPLEMENTAR +> Add a get_unread_books method to BookCollection in books.py +> Add a "list unread" command option in book_app.py +> Update the help text in the show_help function + +# PROBAR +> Generate comprehensive tests for the new feature + +# Se generan múltiples pruebas similares a las siguientes: +# - Camino feliz (3 pruebas) — filtra correctamente, excluye los leídos, incluye los no leídos +# - Casos límite (4 pruebas) — colección vacía, todos leídos, ninguno leído, libro único +# - Parametrizados (5 casos) — variando las proporciones leído/no leído vía @pytest.mark.parametrize +# - Integración (4 pruebas) — interacción con mark_as_read, remove_book, add_book e integridad de datos + +# Revisar los cambios +> /review + +# Si la revisión pasa, usa /pr para operar en el pull request de la rama actual +> /pr [view|create|fix|auto] + +# O pide de forma natural si quieres que Copilot lo redacte desde la terminal +> Create a pull request titled "Feature: Add list unread books command" +``` + +**Enfoque tradicional**: Cambiar entre editor, terminal, runner de pruebas, documentación y la UI de GitHub. Cada cambio provoca pérdida de contexto y fricción. + +**La idea clave**: Dirigiste especialistas como un arquitecto. Ellos manejaron los detalles. Tú manejaste la visión. + +> 💡 **Ir más allá**: Para planes grandes con múltiples pasos como este, prueba `/fleet` para permitir que Copilot ejecute subtareas independientes en paralelo. Consulta la [documentación oficial](https://docs.github.com/copilot/concepts/agents/copilot-cli/fleet) para más detalles. + +--- + +# Flujos de trabajo adicionales + +
+
+Para usuarios avanzados que completaron los Capítulos 04-06, estos flujos de trabajo muestran cómo agentes, habilidades y MCP multiplican tu efectividad.
+
+## El patrón de integración
+
+Aquí está el modelo mental para combinar todo:
+
+
+
+---
+
+## Flujo de trabajo 1: Investigación y corrección de errores
+
+Corrección de errores del mundo real con integración completa de herramientas:
+
+```bash
+copilot
+
+# FASE 1: Entender el error desde GitHub (MCP proporciona esto)
+> Get the details of issue #1
+
+# Aprender: "find_by_author no funciona con nombres parciales"
+
+# FASE 2: Investigar las mejores prácticas (investigación profunda con fuentes web + GitHub)
+> /research Best practices for Python case-insensitive string matching
+
+# FASE 3: Encontrar el código relacionado
+> @samples/book-app-project/books.py Show me the find_by_author method
+
+# FASE 4: Obtener análisis de expertos
+> /agent
+# Seleccionar "python-reviewer"
+
+> Analyze this method for issues with partial name matching
+
+# El agente identifica: el método usa igualdad exacta en lugar de coincidencia por subcadena
+
+# FASE 5: Corregir con la guía del agente
+> Implement the fix using lowercase comparison and 'in' operator
+
+# FASE 6: Generar pruebas
+> /agent
+# Seleccionar "pytest-helper"
+
+> Generate pytest tests for find_by_author with partial matches
+> Include test cases: partial name, case variations, no matches
+
+# FASE 7: Realizar commit y pull request
+> Generate a commit message for this fix
+
+> Create a pull request linking to issue #1
+```
+
+---
+
+## Flujo de trabajo 2: Automatización de revisión de código (Opcional)
+
+> 💡 **Esta sección es opcional.** Los hooks de pre-commit son útiles para equipos pero no son necesarios para ser productivo. Omite esto si recién comienzas.
+>
+> ⚠️ **Nota sobre rendimiento**: Este hook llama a `copilot -p` por cada archivo staged, lo que toma varios segundos por archivo. Para commits grandes, considera limitarlo a archivos críticos o ejecutar revisiones manualmente con `/review` en su lugar.
+
+Un **git hook** es un script que Git ejecuta automáticamente en ciertos puntos, por ejemplo, justo antes de un commit. Puedes usar esto para ejecutar comprobaciones automáticas sobre tu código. Aquí tienes cómo configurar una revisión automática de Copilot en tus commits:
+
+```bash
+# Crear un hook de pre-commit
+cat > .git/hooks/pre-commit << 'EOF'
+#!/bin/bash
+
+# Obtener archivos preparados (solo archivos Python)
+STAGED=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.py$')
+
+if [ -n "$STAGED" ]; then
+ echo "Running Copilot review on staged files..."
+
+ for file in $STAGED; do
+ echo "Reviewing $file..."
+
+ # Usar un tiempo de espera para evitar que se quede colgado (60 segundos por archivo)
+ # --allow-all aprueba automáticamente lecturas/escrituras de archivos para que el hook pueda ejecutarse sin supervisión.
+ # Usar esto solo en scripts automatizados. En sesiones interactivas, deje que Copilot solicite permiso.
+ REVIEW=$(timeout 60 copilot --allow-all -p "Quick security review of @$file - critical issues only" 2>/dev/null)
+
+ # Comprobar si se produjo un tiempo de espera
+ if [ $? -eq 124 ]; then
+ echo "Warning: Review timed out for $file (skipping)"
+ continue
+ fi
+
+ if echo "$REVIEW" | grep -qi "CRITICAL"; then
+ echo "Critical issues found in $file:"
+ echo "$REVIEW"
+ exit 1
+ fi
+ done
+
+ echo "Review passed"
+fi
+EOF
+
+chmod +x .git/hooks/pre-commit
+```
+
+> ⚠️ **Usuarios de macOS**: El comando `timeout` no está incluido por defecto en macOS. Instálalo con `brew install coreutils` o reemplaza `timeout 60` por una invocación simple sin protección de timeout.
+
+> 📚 **Documentación oficial**: [Use hooks](https://docs.github.com/copilot/how-tos/copilot-cli/use-hooks) y [Hooks configuration reference](https://docs.github.com/copilot/reference/hooks-configuration) para la API completa de hooks.
+>
+> 💡 **Alternativa integrada**: Copilot CLI también tiene un sistema de hooks integrado (`copilot hooks`) que puede ejecutarse automáticamente en eventos como pre-commit. El git hook manual anterior te da control completo, mientras que el sistema integrado es más sencillo de configurar. Revisa la documentación anterior para decidir qué enfoque se ajusta a tu flujo de trabajo.
+
+Ahora cada commit recibe una rápida revisión de seguridad:
+
+```bash
+git add samples/book-app-project/books.py
+git commit -m "Update book collection methods"
+
+# Salida:
+# Ejecutando la revisión de Copilot en los archivos preparados...
+# Revisando samples/book-app-project/books.py...
+# Se encontraron problemas críticos en samples/book-app-project/books.py:
+# - Línea 15: Vulnerabilidad de inyección de ruta de archivo en load_from_file
+#
+# Corrige el problema e inténtalo de nuevo.
+```
+
+---
+
+## Flujo de trabajo 3: Incorporación a una nueva base de código
+
+Al unirte a un nuevo proyecto, combina contexto, agentes y MCP para subirte rápido:
+
+```bash
+# Iniciar Copilot en modo interactivo
+copilot
+
+# FASE 1: Obtener la visión general con contexto
+> @samples/book-app-project/ Explain the high-level architecture of this codebase
+
+# FASE 2: Comprender un flujo específico
+> @samples/book-app-project/book_app.py Walk me through what happens
+> when a user runs "python book_app.py add"
+
+# FASE 3: Obtener un análisis experto con un agente
+> /agent
+# Seleccionar "python-reviewer"
+
+> @samples/book-app-project/books.py Are there any design issues,
+> missing error handling, or improvements you would recommend?
+
+# FASE 4: Encontrar algo en lo que trabajar (MCP proporciona acceso a GitHub)
+> List open issues labeled "good first issue"
+
+# FASE 5: Comenzar a contribuir
+> Pick the simplest open issue and outline a plan to fix it
+```
+
+Este flujo de trabajo combina el contexto `@`, agentes y MCP en una sola sesión de incorporación, exactamente el patrón de integración visto antes en este capítulo.
+
+---
+
+# Mejores prácticas y automatización
+
+Patrones y hábitos que hacen tus flujos de trabajo más efectivos.
+
+---
+
+## Mejores prácticas
+
+### 1. Comienza con contexto antes del análisis
+
+Siempre reúne contexto antes de pedir un análisis:
+
+```bash
+# Bueno
+> Get the details of issue #42
+> /agent
+# Seleccionar python-reviewer
+> Analyze this issue
+
+# Menos eficaz
+> /agent
+# Seleccionar python-reviewer
+> Fix login bug
+# El agente no tiene contexto del problema
+```
+
+### 2. Conoce la diferencia: Agentes, habilidades e instrucciones personalizadas
+
+Cada herramienta tiene su punto fuerte:
+
+```bash
+# Agentes: Personas especializadas que activas explícitamente
+> /agent
+# Selecciona python-reviewer
+> Review this authentication code for security issues
+
+# Habilidades: Capacidades modulares que se activan automáticamente cuando tu prompt
+# coincide con la descripción de la habilidad (debes crearlas primero — ver Cap. 05)
+> Generate comprehensive tests for this code
+# Si tienes una habilidad de pruebas configurada, se activa automáticamente
+
+# Instrucciones personalizadas (.github/copilot-instructions.md): Siempre activas
+# guía que se aplica a cada sesión sin cambiar ni activarse
+```
+
+> 💡 **Punto clave**: Los agentes y las habilidades pueden tanto analizar COMO generar código. La verdadera diferencia es **cómo se activan** — los agentes son explícitos (`/agent`), las habilidades son automáticas (coinciden con el prompt), y las instrucciones personalizadas están siempre activas.
+
+### 3. Mantén las sesiones enfocadas
+
+Usa `/rename` para etiquetar tu sesión (facilita encontrarla en el historial) y `/exit` para cerrarla limpiamente:
+
+```bash
+# Bien: Una característica por sesión
+> /rename list-unread-feature
+# Trabajar en la lista de no leídos
+> /exit
+
+copilot
+> /rename export-csv-feature
+# Trabajar en la exportación a CSV
+> /exit
+
+# Menos efectivo: Todo en una sola sesión larga
+```
+
+### 4. Haz los flujos de trabajo reutilizables con Copilot
+
+En lugar de solo documentar flujos de trabajo en una wiki, incorpóralos directamente en tu repo donde Copilot pueda usarlos:
+
+- **Instrucciones personalizadas** (`.github/copilot-instructions.md`): Guía siempre activa para estándares de codificación, reglas de arquitectura y pasos de build/test/deploy. Cada sesión las sigue automáticamente.
+- **Archivos de prompt** (`.github/prompts/`): Prompts reutilizables y parametrizados que tu equipo puede compartir — como plantillas para revisiones de código, generación de componentes o descripciones de PR.
+- **Agentes personalizados** (`.github/agents/`): Codifica personas especializadas (por ejemplo, un revisor de seguridad o un redactor de docs) que cualquiera del equipo puede activar con `/agent`.
+- **Habilidades personalizadas** (`.github/skills/`): Empaqueta instrucciones paso a paso de flujo de trabajo que se activan automáticamente cuando son relevantes.
+
+> 💡 **El beneficio**: Los nuevos miembros del equipo obtienen tus flujos de trabajo gratis — están integrados en el repo, no encerrados en la cabeza de alguien.
+
+---
+
+## Bonus: Patrones para producción
+
+Estos patrones son opcionales pero valiosos para entornos profesionales.
+
+### Generador de descripción de PR
+
+```bash
+# Generar descripciones completas de PR
+BRANCH=$(git branch --show-current)
+COMMITS=$(git log main..$BRANCH --oneline)
+
+copilot -p "Generate a PR description for:
+Branch: $BRANCH
+Commits:
+$COMMITS
+
+Include: Summary, Changes Made, Testing Done, Screenshots Needed"
+```
+
+### Integración CI/CD
+
+Para equipos con pipelines CI/CD existentes, puedes automatizar revisiones de Copilot en cada pull request usando GitHub Actions. Esto incluye publicar comentarios de revisión automáticamente y filtrar por problemas críticos.
+
+> 📖 **Aprende más**: Consulta [CI/CD Integration](../appendices/ci-cd-integration.md) para workflows completos de GitHub Actions, opciones de configuración y consejos para resolver problemas.
+
+---
+
+# Práctica
+
+
+
+Pon el flujo de trabajo completo en práctica.
+
+---
+
+## ▶️ Pruébalo tú mismo
+
+Después de completar las demostraciones, prueba estas variaciones:
+
+1. **Desafío de extremo a extremo**: Elige una pequeña función (por ejemplo, "listar libros no leídos" o "exportar a CSV"). Usa el flujo de trabajo completo:
+ - Planifica con `/plan`
+ - Diseña con agentes (python-reviewer, pytest-helper)
+ - Implementa
+ - Genera pruebas
+ - Crea PR
+
+2. **Desafío de automatización**: Configura el hook de pre-commit del flujo de trabajo de Automatización de revisión de código. Haz un commit con una vulnerabilidad intencionada en la ruta de un archivo. ¿Se bloquea?
+
+3. **Tu flujo de trabajo de producción**: Diseña tu propio flujo de trabajo para una tarea común que realices. Escríbelo como una lista de verificación. ¿Qué partes podrían automatizarse con skills, agentes o hooks?
+
+**Autoevaluación**: Has completado el curso cuando puedas explicar a un colega cómo agentes, habilidades y MCP funcionan juntos — y cuándo usar cada uno.
+
+---
+
+## 📝 Tarea
+
+### Desafío principal: Función de extremo a extremo
+
+Los ejemplos prácticos mostraron cómo construir la función "listar libros no leídos". Ahora practica el flujo de trabajo completo con una función diferente: **buscar libros por rango de años**:
+
+1. Inicia Copilot y reúne contexto: `@samples/book-app-project/books.py`
+2. Planifica con `/plan Add a "search by year" command that lets users find books published between two years`
+3. Implementa un método `find_by_year_range(start_year, end_year)` en `BookCollection`
+4. Agrega una función `handle_search_year()` en `book_app.py` que solicite al usuario los años de inicio y fin
+5. Genera pruebas: `@samples/book-app-project/books.py @samples/book-app-project/tests/test_books.py Generate tests for find_by_year_range() including edge cases like invalid years, reversed range, and no results.`
+6. Revisa con `/review`
+7. Actualiza el README: `@samples/book-app-project/README.md Add documentation for the new "search by year" command.`
+8. Genera un mensaje de commit
+
+Documenta tu flujo de trabajo mientras avanzas.
+
+**Criterios de éxito**: Has completado la función desde la idea hasta el commit usando Copilot CLI, incluyendo planificación, implementación, pruebas, documentación y revisión.
+
+> 💡 **Bonus**: Si tienes agentes configurados desde el Capítulo 04, intenta crear y usar agentes personalizados. Por ejemplo, un agente manejador de errores para revisión de implementación y un agente redactor de docs para la actualización del README.
+
+
+
+
+---
+
+💡 Pistas (haz clic para expandir)
+ +**Sigue el patrón del ejemplo ["De la idea a un PR fusionado"](#de-la-idea-a-un-pr-fusionado-en-una-sesión)** en la parte superior de este capítulo. Los pasos clave son: + +1. Reúne contexto con `@samples/book-app-project/books.py` +2. Planifica con `/plan Add a "search by year" command` +3. Implementa el método y el manejador de comando +4. Genera pruebas con casos límite (entrada inválida, resultados vacíos, rango invertido) +5. Revisa con `/review` +6. Actualiza README con `@samples/book-app-project/README.md` +7. Genera el mensaje de commit con `-p` + +**Casos límite para pensar:** +- ¿Qué pasa si el usuario ingresa "2000" y "1990" (rango invertido)? +- ¿Qué pasa si ningún libro coincide con el rango? +- ¿Qué pasa si el usuario ingresa datos no numéricos? + +**La clave es practicar el flujo de trabajo completo** desde idea → contexto → plan → implementación → pruebas → documentación → commit. + +
+
+
+---
+
+# Resumen
+
+## 🔑 Puntos clave
+
+1. **Integración > Aislamiento**: Combina herramientas para máximo impacto
+2. **Contexto primero**: Reúne siempre el contexto requerido antes del análisis
+3. **Los agentes analizan, las habilidades ejecutan**: Usa la herramienta adecuada para cada tarea
+4. **Automatiza lo repetitivo**: Hooks y scripts multiplican tu efectividad
+5. **Documenta los flujos de trabajo**: Los patrones compartibles benefician a todo el equipo
+
+> 📋 **Referencia rápida**: Consulta la [referencia de comandos de GitHub Copilot CLI](https://docs.github.com/en/copilot/reference/cli-command-reference) para una lista completa de comandos y atajos.
+
+---
+
+## 🎓 ¡Curso completo!
+
+¡Felicidades! Has aprendido:
+
+| Capítulo | Lo que aprendiste |
+|---------|-------------------|
+| 00 | Instalación de Copilot CLI e Inicio rápido |
+| 01 | Tres modos de interacción |
+| 02 | Gestión del contexto con la sintaxis @ |
+| 03 | Flujos de trabajo de desarrollo |
+| 04 | Agentes especializados |
+| 05 | Habilidades extensibles |
+| 06 | Conexiones externas con MCP |
+| 07 | Flujos de trabajo de producción unificados |
+
+Ahora estás equipado para usar GitHub Copilot CLI como un auténtico multiplicador de fuerza en tu flujo de trabajo de desarrollo.
+
+## ➡️ ¿Qué sigue?
+
+Tu aprendizaje no se detiene aquí:
+
+1. **Practica a diario**: Usa Copilot CLI para trabajo real
+2. **Crea herramientas personalizadas**: Crea agentes y habilidades para tus necesidades específicas
+3. **Comparte conocimiento**: Ayuda a tu equipo a adoptar estos flujos de trabajo
+4. **Mantente al día**: Sigue las actualizaciones de GitHub Copilot para nuevas funciones
+
+### Recursos
+
+- [Documentación de GitHub Copilot CLI](https://docs.github.com/copilot/concepts/agents/about-copilot-cli)
+- [Registro de servidores MCP](https://github.com/modelcontextprotocol/servers)
+- [Habilidades comunitarias](https://github.com/topics/copilot-skill)
+
+---
+
+**¡Buen trabajo! Ahora ve y construye algo increíble.**
+
+**[← Volver al Capítulo 06](../06-mcp-servers/README.md)** | **[Volver al inicio del curso →](../README.md)**
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/AGENTS.md b/translations/es/AGENTS.md
new file mode 100644
index 00000000..768d0689
--- /dev/null
+++ b/translations/es/AGENTS.md
@@ -0,0 +1,46 @@
+# AGENTS.md
+
+Curso amigable para principiantes que enseña GitHub Copilot CLI. Contenido educativo, no software.
+
+## Estructura
+
+| Path | Propósito |
+|------|---------|
+| `00-07/` | Capítulos: analogía → conceptos → práctico → tarea → siguiente |
+| `samples/book-app-project/` | **Muestra principal**: Aplicación CLI en Python para colección de libros utilizada en todos los capítulos |
+| `samples/book-app-project-cs/` | Versión en C# de la aplicación de colección de libros |
+| `samples/book-app-project-js/` | Versión en JavaScript de la aplicación de colección de libros |
+| `samples/book-app-buggy/` | **Errores intencionales** para ejercicios de depuración (Ch 03) |
+| `samples/agents/` | Ejemplos de plantillas de agentes (python-reviewer, pytest-helper, hello-world) |
+| `samples/skills/` | Ejemplos de plantillas de skills (code-checklist, pytest-gen, commit-message, hello-world) |
+| `samples/mcp-configs/` | Ejemplos de configuración del servidor MCP |
+| `samples/buggy-code/` | **Extra opcional**: Código con errores enfocado en seguridad (JS y Python) |
+| `samples/src/` | **Extra opcional**: Ejemplos heredados de JS/React de una versión anterior del curso |
+| `appendices/` | Material de referencia suplementario |
+
+## Hacer
+
+- Mantén las explicaciones aptas para principiantes; explica la jerga de IA/ML cuando se use
+- Asegúrate de que los ejemplos de bash estén listos para copiar y pegar
+- Tono: amigable, alentador, práctico
+- Usa las rutas `samples/book-app-project/` en todos los ejemplos principales
+- Usa el contexto Python/pytest para los ejemplos de código
+
+## No
+
+- No arregles los errores en `samples/book-app-buggy/` o `samples/buggy-code/` — son intencionales
+- No añadas capítulos sin actualizar la tabla del curso en README.md
+- No asumas que los lectores conocen la terminología de IA/ML
+
+## Construir
+
+```bash
+npm install && npm run release
+```
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/CODE_OF_CONDUCT.md b/translations/es/CODE_OF_CONDUCT.md
new file mode 100644
index 00000000..32dd59f0
--- /dev/null
+++ b/translations/es/CODE_OF_CONDUCT.md
@@ -0,0 +1,134 @@
+# Código de conducta de Contributor Covenant
+
+## Nuestro Compromiso
+
+Nosotros, como miembros, contribuyentes y líderes, nos comprometemos a hacer que la participación en nuestra
+comunidad sea una experiencia libre de acoso para todas las personas, independientemente de la edad, el tamaño
+del cuerpo, una discapacidad visible o invisible, la etnia, las características sexuales, la identidad y
+expresión de género, el nivel de experiencia, la educación, el estatus socioeconómico,
+la nacionalidad, la apariencia personal, la raza, la religión o la identidad
+y orientación sexual.
+
+Nos comprometemos a actuar e interactuar de maneras que contribuyan a una comunidad abierta, acogedora,
+diversa, inclusiva y saludable.
+
+## Nuestros estándares
+
+Ejemplos de conductas que contribuyen a un entorno positivo para nuestra
+comunidad incluyen:
+
+* Demostrar empatía y amabilidad hacia otras personas
+* Ser respetuoso con opiniones, puntos de vista y experiencias diferentes
+* Dar y aceptar con gracia comentarios constructivos
+* Aceptar la responsabilidad y disculparse con quienes se han visto afectados por nuestros errores,
+ y aprender de la experiencia
+* Enfocarse en lo que es mejor no solo para nosotros como individuos, sino para la
+ comunidad en general
+
+Ejemplos de comportamiento inaceptable incluyen:
+
+* El uso de lenguaje o imágenes sexualizadas, y atención o
+ avances sexuales de cualquier tipo
+* Trolleo, comentarios insultantes o despectivos, y ataques personales o políticos
+* Acoso público o privado
+* Publicar información privada de otras personas, como una dirección física o de correo electrónico,
+ sin su permiso explícito
+* Otra conducta que razonablemente pueda considerarse inapropiada en un
+ entorno profesional
+
+## Responsabilidades de aplicación
+
+Los líderes de la comunidad son responsables de clarificar y hacer cumplir nuestros estándares de
+comportamiento aceptable y tomarán medidas correctivas apropiadas y justas en
+respuesta a cualquier comportamiento que consideren inapropiado, amenazante, ofensivo
+o dañino.
+
+Los líderes de la comunidad tienen el derecho y la responsabilidad de eliminar, editar o rechazar
+comentarios, commits, código, ediciones de la wiki, issues y otras contribuciones que no estén
+alineadas con este Código de Conducta, y comunicarán las razones de las decisiones de moderación
+cuando sea apropiado.
+
+## Alcance
+
+Este Código de Conducta se aplica dentro de todos los espacios de la comunidad, y también se aplica cuando
+un individuo representa oficialmente a la comunidad en espacios públicos.
+Ejemplos de representar a nuestra comunidad incluyen usar una dirección de correo electrónico oficial,
+publicar a través de una cuenta oficial de redes sociales, o actuar como un representante designado
+en un evento en línea o presencial.
+
+## Aplicación
+
+Los casos de comportamiento abusivo, acosador o de otro tipo inaceptable pueden ser
+reportados a los líderes de la comunidad responsables de la aplicación en
+GitHub.
+Todas las quejas serán revisadas e investigadas de manera pronta y justa.
+
+Todos los líderes de la comunidad están obligados a respetar la privacidad y la seguridad del
+informante de cualquier incidente.
+
+## Directrices de aplicación
+
+Los líderes de la comunidad seguirán estas Directrices de Impacto en la Comunidad al determinar
+las consecuencias de cualquier acción que consideren en violación de este Código de Conducta:
+
+### 1. Correction
+
+**Impacto en la comunidad**: Uso de lenguaje inapropiado u otro comportamiento considerado
+poco profesional o no bienvenido en la comunidad.
+
+**Consecuencia**: Una advertencia privada y por escrito por parte de los líderes de la comunidad, proporcionando
+claridad sobre la naturaleza de la violación y una explicación de por qué el
+comportamiento fue inapropiado. Se puede solicitar una disculpa pública.
+
+### 2. Warning
+
+**Impacto en la comunidad**: Una violación a través de un incidente único o una serie
+de acciones.
+
+**Consecuencia**: Una advertencia con consecuencias por la continuación del comportamiento. No
+interacción con las personas involucradas, incluida la interacción no solicitada con
+quienes hacen cumplir el Código de Conducta, por un período de tiempo especificado. Esto
+incluye evitar interacciones en los espacios de la comunidad así como canales externos
+como las redes sociales. Violar estos términos puede llevar a una prohibición temporal o
+permanente.
+
+### 3. Temporary Ban
+
+**Impacto en la comunidad**: Una violación grave de los estándares de la comunidad, incluyendo
+comportamiento inapropiado sostenido.
+
+**Consecuencia**: Una prohibición temporal de cualquier tipo de interacción o comunicación pública
+con la comunidad por un período de tiempo especificado. No se permite ninguna interacción pública o
+privada con las personas involucradas, incluida la interacción no solicitada con
+quienes hacen cumplir el Código de Conducta, durante este periodo.
+Violar estos términos puede llevar a una prohibición permanente.
+
+### 4. Permanent Ban
+
+**Impacto en la comunidad**: Demostrar un patrón de violación de los estándares de la comunidad,
+incluido comportamiento inapropiado sostenido, acoso a un
+individuo, o agresión hacia o menosprecio de clases de individuos.
+
+**Consecuencia**: Una prohibición permanente de cualquier tipo de interacción pública dentro
+de la comunidad.
+
+## Atribución
+
+Este Código de Conducta está adaptado de [Contributor Covenant][homepage],
+versión 2.0, disponible en
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Las Directrices de Impacto en la Comunidad se inspiraron en [la escalera de aplicación del código de conducta de Mozilla](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+Para respuestas a preguntas comunes sobre este código de conducta, vea las preguntas frecuentes en
+https://www.contributor-covenant.org/faq. Las traducciones están disponibles en
+https://www.contributor-covenant.org/translations.
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/CONTRIBUTING.md b/translations/es/CONTRIBUTING.md
new file mode 100644
index 00000000..43558096
--- /dev/null
+++ b/translations/es/CONTRIBUTING.md
@@ -0,0 +1,17 @@
+## Contribuir
+
+[fork]: https://github.com/github/REPO/fork
+[pr]: https://github.com/github/REPO/compare
+
+¡Hola! Nos entusiasma que quieras contribuir a este proyecto. Tu ayuda es esencial para mantenerlo genial.
+
+Las contribuciones a este proyecto se [publican](https://help.github.com/articles/github-terms-of-service/#6-contributions-under-repository-license) al público bajo la [licencia de código abierto del proyecto](../../LICENSE.txt).
+
+Tenga en cuenta que este proyecto se publica con un [Código de Conducta para Contribuidores](CODE_OF_CONDUCT.md). Al participar en este proyecto, acepta cumplir con sus términos.
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/GLOSSARY.md b/translations/es/GLOSSARY.md
new file mode 100644
index 00000000..aaa68586
--- /dev/null
+++ b/translations/es/GLOSSARY.md
@@ -0,0 +1,170 @@
+# Glosario
+
+Referencia rápida de términos técnicos usados a lo largo de este curso. No te preocupes por memorizarlos ahora - consúltalos según lo necesites.
+
+---
+
+## A
+
+### Agent
+
+Una personalidad de IA especializada con experiencia en el dominio (p. ej., frontend, seguridad). Definida en archivos `.agent.md` con frontmatter YAML que contiene como mínimo un campo `description`.
+
+### API
+
+Interfaz de Programación de Aplicaciones. Una forma para que los programas se comuniquen entre sí.
+
+---
+
+## C
+
+### CI/CD
+
+Integración Continua/Despliegue Continuo. Canalizaciones automatizadas de pruebas y despliegue.
+
+### CLI
+
+Interfaz de Línea de Comandos. Una forma basada en texto para interactuar con el software (¡como esta herramienta!).
+
+### Context Window
+
+La cantidad de texto que una IA puede considerar a la vez. Como un escritorio que solo puede sostener cierta cantidad. Cuando añades archivos, historial de conversación y mensajes del sistema, todos ocupan espacio en esta ventana.
+
+### Context Manager
+
+Una construcción de Python que usa la sentencia `with` y que maneja automáticamente la configuración y la limpieza (como abrir y cerrar archivos). Ejemplo: `with open("file.txt") as f:` garantiza que el archivo se cierre incluso si ocurre un error.
+
+### Conventional Commit
+
+Un formato de mensaje de commit que sigue una estructura estandarizada: `type(scope): description`. Los tipos comunes incluyen `feat` (nueva funcionalidad), `fix` (corrección de errores), `docs` (documentación), `refactor` y `test`. Ejemplo: `feat(auth): add password reset flow`.
+
+### Dataclass
+
+Un decorador de Python (`@dataclass`) que genera automáticamente `__init__`, `__repr__` y otros métodos para clases que principalmente almacenan datos. Usado en la aplicación de libros para definir la clase `Book` con campos como `title`, `author`, `year` y `read`.
+
+---
+
+## F
+
+### Frontmatter
+
+Metadatos en la parte superior de un archivo Markdown encerrados entre delimitadores `---`. Usados en archivos de agent y skill para definir propiedades como `description` y `name` en formato YAML.
+
+---
+
+## G
+
+### Glob Pattern
+
+Un patrón que usa comodines para coincidir con rutas de archivos (p. ej., `*.py` coincide con todos los archivos Python, `*.js` coincide con todos los archivos JavaScript).
+
+---
+
+## J
+
+### JWT
+
+JSON Web Token. Una forma segura de transmitir información de autenticación entre sistemas.
+
+---
+
+## M
+
+### MCP
+
+Model Context Protocol. Un estándar para conectar asistentes de IA a fuentes de datos externas.
+
+---
+
+## N
+
+### npx
+
+Una herramienta de Node.js que ejecuta paquetes npm sin instalarlos globalmente. Usada en las configuraciones de servidor MCP para lanzar servidores (p. ej., `npx @modelcontextprotocol/server-filesystem`).
+
+---
+
+## O
+
+### OWASP
+
+Open Web Application Security Project. Una organización que publica mejores prácticas de seguridad y mantiene la lista "OWASP Top 10" de los riesgos de seguridad de aplicaciones web más críticos.
+
+---
+
+## P
+
+### PEP 8
+
+Python Enhancement Proposal 8. La guía de estilo oficial para código Python, que cubre convenciones de nombres (snake_case para funciones, PascalCase para clases), indentación (4 espacios) y disposición del código. Seguir PEP 8 hace que el código Python sea consistente y legible.
+
+### Pre-commit Hook
+
+Un script que se ejecuta automáticamente antes de cada `git commit`. Puede usarse para ejecutar revisiones de seguridad de Copilot o comprobaciones de calidad de código antes de que se realice el commit del código.
+
+### pytest
+
+Un framework de pruebas de Python popular, conocido por su sintaxis sencilla, fixtures potentes y un rico ecosistema de plugins. Utilizado a lo largo de este curso para probar la aplicación de libros. Las pruebas se ejecutan con `python -m pytest tests/`.
+
+### Programmatic Mode
+
+Ejecutar Copilot con la bandera `-p` para comandos individuales sin interacción.
+
+---
+
+## R
+
+### Rate Limiting
+
+Restricciones sobre cuántas solicitudes puedes hacer a una API dentro de un periodo de tiempo. Copilot puede limitar temporalmente las respuestas si excedes la cuota de uso de tu plan.
+
+---
+
+## S
+
+### Session
+
+Una conversación con Copilot que mantiene el contexto y puede reanudarse más tarde.
+
+### Skill
+
+Una carpeta con instrucciones que Copilot carga automáticamente cuando son relevantes para tu prompt. Definidas en archivos `SKILL.md` con frontmatter YAML.
+
+### Slash Command
+
+Comandos que comienzan con `/` que controlan Copilot (p. ej., `/help`, `/clear`, `/model`).
+
+---
+
+## T
+
+### Token
+
+Una unidad de texto que los modelos de IA procesan. Aproximadamente 4 caracteres o 0.75 palabras. Usado para medir tanto la entrada (tus indicaciones y contexto) como la salida (respuestas de la IA).
+
+### Type Hints
+
+Anotaciones de Python que indican los tipos esperados de los parámetros de función y valores de retorno (p. ej., `def add_book(title: str, year: int) -> Book:`). No hacen cumplir los tipos en tiempo de ejecución pero ayudan con la claridad del código, el soporte del IDE y herramientas de análisis estático como mypy.
+
+---
+
+## W
+
+### WCAG
+
+Web Content Accessibility Guidelines. Normas publicadas por el W3C para hacer el contenido web accesible a personas con discapacidades. WCAG 2.1 AA es un objetivo de cumplimiento común.
+
+---
+
+## Y
+
+### YAML
+
+YAML Ain't Markup Language. Un formato de datos legible por humanos usado para configuración. En este curso, YAML aparece en el frontmatter de agent y skill (el bloque delimitado por `---` en la parte superior de los archivos `.agent.md` y `SKILL.md`).
+
+---
+
+
+**Descargo de responsabilidad**:
+Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción.
+
\ No newline at end of file
diff --git a/translations/es/README.md b/translations/es/README.md
new file mode 100644
index 00000000..a99bfea1
--- /dev/null
+++ b/translations/es/README.md
@@ -0,0 +1,111 @@
+
+
+[](../../LICENSE)
+[](https://codespaces.new/github/copilot-cli-for-beginners?hide_repo_select=true&ref=main&quickstart=true)
+[](https://docs.github.com/en/copilot/how-tos/copilot-cli)
+[](https://aka.ms/foundry/discord)
+
+🎯 [Qué aprenderás](#qué-aprenderás) ✅ [Requisitos](#requisitos) 🤖 [Comprender la familia GitHub Copilot](#comprender-la-familia-github-copilot) 📚 [Estructura del curso](#estructura-del-curso) 📋 [Referencia de comandos](#referencia-de-comandos-del-github-copilot-cli)
+
+# GitHub Copilot CLI para principiantes
+
+> **✨ Aprende a potenciar tu flujo de trabajo de desarrollo con asistencia en la línea de comandos impulsada por IA.**
+
+GitHub Copilot CLI lleva la asistencia de IA directamente a tu terminal. En lugar de cambiar a un navegador o editor de código, puedes hacer preguntas, generar aplicaciones completas, revisar código, generar pruebas y depurar problemas sin salir de la línea de comandos.
+
+Piensa en ello como tener un colega experto disponible 24/7 que puede leer tu código, explicar patrones confusos y ayudarte a trabajar más rápido.
+
+> 📘 **¿Prefieres una experiencia web?** Puedes seguir este curso aquí mismo en GitHub, o verlo en [Awesome Copilot](https://awesome-copilot.github.com/learning-hub/cli-for-beginners/) para una experiencia de navegación más tradicional.
+
+Este curso está diseñado para:
+
+- **Desarrolladores de software** que quieren usar IA desde la línea de comandos
+- **Usuarios de terminal** que prefieren flujos de trabajo impulsados por teclado en lugar de integraciones con IDE
+- **Equipos que buscan estandarizar** prácticas de revisión de código y desarrollo asistidos por IA
+
+## 🎯 Qué aprenderás
+
+Este curso práctico te lleva de cero a productivo con GitHub Copilot CLI. Trabajarás con una única aplicación de colección de libros en Python a lo largo de todos los capítulos, mejorándola progresivamente usando flujos de trabajo asistidos por IA. Al final, usarás con confianza la IA para revisar código, generar pruebas, depurar problemas y automatizar flujos de trabajo: todo desde tu terminal.
+
+**No se requiere experiencia previa en IA.** Si sabes usar una terminal, puedes aprender esto.
+
+**Perfecto para:** Desarrolladores, estudiantes y cualquier persona con experiencia en desarrollo de software.
+
+## ✅ Requisitos
+
+Antes de comenzar, asegúrate de tener:
+
+- **Cuenta de GitHub**: [Crea una gratis](https://github.com/signup)🔧 Errores comunes (haz clic para expandir)
+ +| Error | Qué ocurre | Solución | +|---------|--------------|-----| +| Saltar directamente a la implementación | Se pierden problemas de diseño que son costosos de arreglar después | Usa `/plan` primero para pensar en el enfoque | +| Usar una sola herramienta cuando varias ayudarían | Resultados más lentos y menos exhaustivos | Combina: Agente para análisis → Habilidad para ejecución → MCP para integración | +| No revisar antes de commitear | Problemas de seguridad o bugs pasan desapercibidos | Ejecuta siempre `/review` o usa un [pre-commit hook](#codeblock1) | +| Olvidar compartir los flujos de trabajo con el equipo | Cada persona reinventa la rueda | Documenta patrones en agentes, skills e instrucciones compartidas | + ++- **Acceso a GitHub Copilot**: [Oferta gratuita](https://github.com/features/copilot/plans), [Suscripción mensual](https://github.com/features/copilot/plans), o [Gratis para estudiantes/profesores](https://education.github.com/pack)
+- **Conceptos básicos de terminal**: Cómodo con `cd`, `ls`, ejecutar comandos + +## 🤖 Comprender la familia GitHub Copilot + +GitHub Copilot ha evolucionado hasta convertirse en una familia de herramientas impulsadas por IA. Aquí es dónde vive cada una: + +| Producto | Dónde se ejecuta | Descripción | +|---------|---------------|----------| +| [**GitHub Copilot CLI**](https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started)
(este curso) | Tu terminal | Asistente de codificación con IA nativo del terminal | +| [**GitHub Copilot**](https://docs.github.com/copilot) | VS Code, Visual Studio, JetBrains, etc. | Modo agente, chat, sugerencias en línea | +| [**Copilot on GitHub.com**](https://github.com/copilot) | GitHub | Chat inmersivo sobre tus repositorios, crear agentes y más | +| [**GitHub Copilot cloud agent**](https://docs.github.com/copilot/using-github-copilot/using-copilot-coding-agent-to-work-on-tasks) | GitHub | Asignar issues a agentes y recibir PRs de vuelta | + +Este curso se centra en **GitHub Copilot CLI**, que trae asistencia de IA directamente a tu terminal. + +## 📚 Estructura del curso + + + +| Capítulo | Título | Qué construirás | +|:-------:|-------|-------------------| +| 00 | 🚀 [Inicio rápido](./00-quick-start/README.md) | Instalación y verificación | +| 01 | 👋 [Primeros pasos](./01-setup-and-first-steps/README.md) | Demostraciones en vivo + tres modos de interacción | +| 02 | 🔍 [Contexto y conversaciones](./02-context-conversations/README.md) | Análisis de proyectos con varios archivos | +| 03 | ⚡ [Flujos de trabajo de desarrollo](./03-development-workflows/README.md) | Revisión de código, depuración, generación de pruebas | +| 04 | 🤖 [Crear asistentes de IA especializados](./04-agents-custom-instructions/README.md) | Agentes personalizados para tu flujo de trabajo | +| 05 | 🛠️ [Automatizar tareas repetitivas](./05-skills/README.md) | Skills que se cargan automáticamente | +| 06 | 🔌 [Conéctate a GitHub, bases de datos y APIs](./06-mcp-servers/README.md) | Integración del servidor MCP | +| 07 | 🎯 [Integrándolo todo](./07-putting-it-together/README.md) | Flujos de trabajo completos | + +## 📖 Cómo funciona este curso + +Cada capítulo sigue el mismo patrón: + +1. **Analogía del mundo real**: Entiende el concepto a través de comparaciones familiares +2. **Conceptos clave**: Aprende los conocimientos esenciales +3. **Ejemplos prácticos**: Ejecuta comandos reales y ve los resultados +4. **Ejercicio**: Practica lo que aprendiste +5. **Qué sigue**: Vista previa del siguiente capítulo + +**Los ejemplos de código son ejecutables.** Cada bloque de texto de copilot en este curso puede copiarse y ejecutarse en tu terminal. + +## 📋 Referencia de comandos del GitHub Copilot CLI + +La **[GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/reference/cli-command-reference)** te ayuda a encontrar comandos y atajos de teclado para usar Copilot CLI de forma eficaz. + +## 🙋 Obtener ayuda + +- 🐛 **¿Encontraste un bug?** [Open an Issue](https://github.com/github/copilot-cli-for-beginners/issues) +- 📚 **Documentación oficial:** [GitHub Copilot CLI Documentation](https://docs.github.com/copilot/concepts/agents/about-copilot-cli) + +## Contribuir + +> **Nota**: El código utilizado en el curso está diseñado para generar tipos específicos de salida durante revisiones, explicaciones y depuración, por lo que no podemos aceptar PRs que cambien el código existente. + +**Cómo contribuir:** + +1. Haz un fork de este repositorio y clónalo en tu máquina +2. Crea una rama de características (`git checkout -b my-improvement`) +3. Realiza tus cambios +4. Envía un pull request + +## License + +This project is licensed under the terms of the MIT open source license. Please refer to the [LICENSE](../../LICENSE) file for the full terms. + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/SECURITY.md b/translations/es/SECURITY.md new file mode 100644 index 00000000..f314e24e --- /dev/null +++ b/translations/es/SECURITY.md @@ -0,0 +1,38 @@ +Gracias por ayudar a que GitHub sea seguro para todos. + +# Seguridad + +GitHub se toma en serio la seguridad de nuestros productos y servicios de software, incluidos todos los repositorios de código abierto gestionados a través de nuestras organizaciones de GitHub, como [GitHub](https://github.com/GitHub). + +Aunque [los repositorios de código abierto están fuera del alcance de nuestro programa de recompensas por errores](https://bounty.github.com/index.html#scope) y por lo tanto no son elegibles para recompensas, nos aseguraremos de que su hallazgo sea remitido a los mantenedores apropiados para su corrección. + +## Informar problemas de seguridad + +Si cree que ha encontrado una vulnerabilidad de seguridad en cualquier repositorio propiedad de GitHub, repórtela a través de divulgación coordinada. + +**Por favor, no informe vulnerabilidades de seguridad mediante issues públicos de GitHub, discusiones o pull requests.** + +En su lugar, envíe un correo electrónico a opensource-security[@]github.com. + +Por favor incluya tanta información de la lista siguiente como pueda para ayudarnos a comprender y resolver el problema: + + * El tipo de problema (por ejemplo, desbordamiento de búfer, inyección SQL o cross-site scripting) + * Rutas completas de los archivos fuente relacionados con la manifestación del problema + * La ubicación del código fuente afectado (tag/branch/commit o direct URL) + * Cualquier configuración especial necesaria para reproducir el problema + * Instrucciones paso a paso para reproducir el problema + * Código de prueba de concepto o exploit (si es posible) + * Impacto del problema, incluyendo cómo un atacante podría explotarlo + +Esta información nos ayudará a evaluar su informe más rápidamente. + +## Política + +Consulte [la Política de Safe Harbor de GitHub](https://docs.github.com/en/site-policy/security-policies/github-bug-bounty-program-legal-safe-harbor#1-safe-harbor-terms) + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/SUPPORT.md b/translations/es/SUPPORT.md new file mode 100644 index 00000000..f6b8d43c --- /dev/null +++ b/translations/es/SUPPORT.md @@ -0,0 +1,18 @@ +# Soporte + +## Cómo presentar incidencias y obtener ayuda + +Este proyecto utiliza las incidencias de GitHub para rastrear errores y solicitudes de funciones. Por favor, busque las incidencias existentes antes de presentar nuevas incidencias para evitar duplicados. Para nuevas incidencias, presente su informe de error o solicitud de función como una nueva incidencia. + +Para ayuda o preguntas sobre el uso de este proyecto, por favor abra una incidencia. + +## Política de soporte de GitHub + +El soporte para este proyecto se limita a los recursos enumerados arriba. + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/appendices/README.md b/translations/es/appendices/README.md new file mode 100644 index 00000000..2e8ced76 --- /dev/null +++ b/translations/es/appendices/README.md @@ -0,0 +1,19 @@ +# Apéndices + +Estos apéndices cubren temas adicionales que amplían el contenido principal del curso. Son lecturas opcionales para cuando necesites estas capacidades específicas. + +| Apéndice | Descripción | Requisito previo | +|----------|-------------|--------------| +| [Funciones de contexto adicionales](additional-context.md) | Trabajo con imágenes y permisos en múltiples directorios | Capítulo 02 | +| [Integración de CI/CD](ci-cd-integration.md) | Flujos de trabajo de GitHub Actions para revisiones automatizadas | Capítulo 07 | + +--- + +**[← Volver al inicio del curso](../README.md)** + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/appendices/additional-context.md b/translations/es/appendices/additional-context.md new file mode 100644 index 00000000..d07f2f33 --- /dev/null +++ b/translations/es/appendices/additional-context.md @@ -0,0 +1,147 @@ +# Características adicionales de contexto + +> 📖 **Requisito previo**: Completa [Capítulo 02: Contexto y conversaciones](../02-context-conversations/README.md) antes de leer este apéndice. + +Este apéndice cubre dos características adicionales de contexto: trabajar con imágenes y gestionar permisos en múltiples directorios. + +--- + +## Trabajar con imágenes + +Puedes incluir imágenes en tus conversaciones usando la sintaxis `@`. Copilot puede analizar capturas de pantalla, maquetas, diagramas y otro contenido visual. + +### Referencia básica de imagen + +```bash +copilot + +> @screenshot.png What's happening in this UI? + +# Copilot analiza la imagen y responde + +> @mockup.png @current-design.png Compare these two designs + +# También puedes arrastrar y soltar imágenes o pegar desde el portapapeles +``` + +### Formatos de imagen compatibles + +| Format | Best For | +|--------|----------| +| PNG | Capturas de pantalla, maquetas de UI, diagramas | +| JPG/JPEG | Fotos, imágenes complejas | +| GIF | Diagramas simples (solo primer fotograma) | +| WebP | Capturas de pantalla web | + +### Casos prácticos de uso de imágenes + +**1. Depuración de IU** +```bash +> @bug-screenshot.png The button doesn't align properly. What CSS might cause this? +``` + +**2. Implementación de diseño** +```bash +> @figma-export.png Write the HTML and Tailwind CSS to match this design +``` + +**3. Análisis de errores** +```bash +> @error-screenshot.png What does this error mean and how do I fix it? +``` + +**4. Revisión de arquitectura** +```bash +> @whiteboard-diagram.png Convert this architecture diagram to a Mermaid diagram I can put in docs +``` + +**5. Comparación antes/después** +```bash +> @before.png @after.png What changed between these two versions of the UI? +``` + +### Combinar imágenes con código + +Las imágenes se vuelven aún más poderosas cuando se combinan con contexto de código: + +```bash +copilot + +> @screenshot-of-bug.png @src/components/Header.jsx +> The header looks wrong in the screenshot. What's causing it in the code? +``` + +### Consejos sobre imágenes + +- **Recorta las capturas de pantalla** para mostrar solo las porciones relevantes (ahorra tokens de contexto) +- **Usa alto contraste** para los elementos de la interfaz que quieres analizar +- **Anota si es necesario** - circunda o resalta las áreas problemáticas antes de subir +- **Una imagen por concepto** - varias imágenes funcionan, pero mantente enfocado + +--- + +## Patrones de permisos + +Por defecto, Copilot puede acceder a archivos en tu directorio actual. Para archivos en otras ubicaciones, necesitas otorgar acceso. + +### Agregar directorios + +```bash +# Agregar un directorio a la lista permitida +copilot --add-dir /path/to/other/project + +# Agregar varios directorios +copilot --add-dir ~/workspace --add-dir /tmp +``` + +### Permitir todas las rutas + +```bash +# Desactivar por completo las restricciones de rutas (usar con precaución) +copilot --allow-all-paths +``` + +### Dentro de una sesión + +```bash +copilot + +> /add-dir /path/to/other/project +# Ahora puedes hacer referencia a archivos de ese directorio + +> /list-dirs +# Ver todos los directorios permitidos + +> /yolo +# Alias rápido para /allow-all activado — aprueba automáticamente todas las solicitudes de permiso +``` + +### Para automatización + +```bash +# Permitir todos los permisos para scripts no interactivos +copilot -p "Review @src/" --allow-all + +# O usa el alias memorable +copilot -p "Review @src/" --yolo +``` + +### Cuando necesitas acceso a múltiples directorios + +Escenarios comunes donde necesitarás estos permisos: + +1. **Trabajo en monorepo** - Comparando código entre paquetes +2. **Refactorización entre proyectos** - Actualizando bibliotecas compartidas +3. **Proyectos de documentación** - Referenciando múltiples bases de código +4. **Trabajo de migración** - Comparando implementaciones antiguas y nuevas + +--- + +**[← Volver al Capítulo 02](../02-context-conversations/README.md)** | **[Volver a los apéndices](README.md)** + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/appendices/ci-cd-integration.md b/translations/es/appendices/ci-cd-integration.md new file mode 100644 index 00000000..535db0a7 --- /dev/null +++ b/translations/es/appendices/ci-cd-integration.md @@ -0,0 +1,206 @@ +# Integración CI/CD + +> 📖 **Requisito previo**: Completa [Capítulo 07: Poniéndolo todo junto](../07-putting-it-together/README.md) antes de leer este apéndice. +> +> ⚠️ **Este apéndice es para equipos con pipelines CI/CD existentes.** Si eres nuevo en GitHub Actions o en conceptos de CI/CD, empieza con el enfoque más sencillo del hook pre-commit en la sección [Automatización de revisión de código](../07-putting-it-together/README.md#workflow-3-code-review-automation-optional) del Capítulo 07. + +Este apéndice muestra cómo integrar GitHub Copilot CLI en tus pipelines CI/CD para revisiones de código automatizadas en pull requests. + +--- + +## Flujo de trabajo de GitHub Actions + +Este flujo de trabajo revisa automáticamente los archivos modificados cuando se abre o actualiza un pull request: + +```yaml +# .github/workflows/copilot-review.yml +name: Copilot Review + +on: + pull_request: + types: [opened, synchronize] + +jobs: + review: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 # Needed to compare with main branch + + - name: Install Copilot CLI + run: npm install -g @github/copilot + + - name: Review Changed Files + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + run: | + # Get list of changed JS/TS files + FILES=$(git diff --name-only origin/main...HEAD | grep -E '\.(js|ts|jsx|tsx)$' || true) + + if [ -z "$FILES" ]; then + echo "No JavaScript/TypeScript files changed" + exit 0 + fi + + echo "# Copilot Code Review" > review.md + echo "" >> review.md + + for file in $FILES; do + echo "Reviewing $file..." + echo "## $file" >> review.md + echo "" >> review.md + + # Use --silent to suppress progress output + copilot --allow-all -p "Quick security and quality review of @$file. List only critical issues." --silent >> review.md 2>/dev/null || echo "Review skipped" >> review.md + echo "" >> review.md + done + + - name: Post Review Comment + uses: actions/github-script@v7 + with: + script: | + const fs = require('fs'); + const review = fs.readFileSync('review.md', 'utf8'); + + // Only post if there's meaningful content + if (review.includes('CRITICAL') || review.includes('HIGH')) { + github.rest.issues.createComment({ + issue_number: context.issue.number, + owner: context.repo.owner, + repo: context.repo.repo, + body: review + }); + } else { + console.log('No critical issues found, skipping comment'); + } +``` + +--- + +## Opciones de configuración + +### Limitar el alcance de la revisión + +Puedes centrar la revisión en tipos específicos de problemas: + +```yaml +# Security-only review +copilot --allow-all -p "Security review of @$file. Check for: SQL injection, XSS, hardcoded secrets, authentication issues." --silent + +# Performance-only review +copilot --allow-all -p "Performance review of @$file. Check for: N+1 queries, memory leaks, blocking operations." --silent +``` + +### Gestión de PRs grandes + +Para PRs con muchos archivos, considera agruparlos o limitar: + +```yaml +# Limit to first 10 files +FILES=$(git diff --name-only origin/main...HEAD | grep -E '\.(js|ts)$' | head -10) + +# Or set a timeout per file +timeout 60 copilot --allow-all -p "Review @$file" --silent || echo "Review timed out" +``` + +### Configuración del equipo + +Para revisiones consistentes en todo el equipo, crea una configuración compartida: + +```json +// .copilot/config.json (committed to repo) +{ + "model": "claude-sonnet-4.5", + "permissions": { + "allowedPaths": ["src/**/*", "tests/**/*"], + "deniedPaths": [".env*", "secrets/**/*", "*.min.js"] + } +} +``` + +--- + +## Alternativa: Bot de revisión de PR + +Para flujos de trabajo de revisión más sofisticados, considera usar el agente en la nube de GitHub Copilot: + +```yaml +# .github/workflows/copilot-agent-review.yml +name: Request Copilot Review + +on: + pull_request: + types: [opened, ready_for_review] + +jobs: + request-review: + runs-on: ubuntu-latest + steps: + - name: Request Copilot Review + uses: actions/github-script@v7 + with: + script: | + await github.rest.pulls.requestReviewers({ + owner: context.repo.owner, + repo: context.repo.repo, + pull_number: context.issue.number, + reviewers: ['copilot[bot]'] + }); +``` + +--- + +## Mejores prácticas para la integración CI/CD + +1. **Usa el indicador `--silent`** - Suprime la salida de progreso para registros más limpios +2. **Establece límites de tiempo** - Evita que revisiones bloqueadas detengan tu pipeline +3. **Filtra tipos de archivos** - Revisa solo los archivos relevantes (omite código generado, dependencias) +4. **Ten en cuenta los límites de tasa** - Espacia las revisiones para PRs grandes +5. **Gestiona fallos de forma elegante** - No bloquees las fusiones por fallos en la revisión; registra y continúa + +--- + +## Solución de problemas + +### "Autenticación fallida" en CI + +Asegúrate de que tu flujo de trabajo tenga los permisos correctos: + +```yaml +permissions: + contents: read + pull-requests: write + issues: write +``` + +### Revisiones que agotan el tiempo de espera + +Aumenta el tiempo de espera o reduce el alcance: + +```bash +timeout 120 copilot --allow-all -p "Quick review of @$file - critical issues only" --silent +``` + +### Límites de token en archivos grandes + +Omitir archivos muy grandes: + +```bash +if [ $(wc -l < "$file") -lt 500 ]; then + copilot --allow-all -p "Review @$file" --silent +else + echo "Skipping $file (too large)" +fi +``` + +--- + +**[← Volver al Capítulo 07](../07-putting-it-together/README.md)** | **[Volver a los apéndices](README.md)** + +--- + + +**Descargo de responsabilidad**: +Este documento ha sido traducido utilizando el servicio de traducción automática [Co-op Translator](https://github.com/Azure/co-op-translator). Aunque nos esforzamos por la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o inexactitudes. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional humana. No somos responsables de cualquier malentendido o interpretación errónea que surja del uso de esta traducción. + \ No newline at end of file diff --git a/translations/es/samples/agents/README.md b/translations/es/samples/agents/README.md new file mode 100644 index 00000000..6644253d --- /dev/null +++ b/translations/es/samples/agents/README.md @@ -0,0 +1,113 @@ +# Sample Agent Definitions + +This folder contains some simple agent templates for GitHub Copilot CLI intended to help you get started using agents. + +## Quick Start + +```bash +# Copia un agente en tu carpeta personal de agentes +cp hello-world.agent.md ~/.copilot/agents/ + +# O cópialo en tu proyecto para compartirlo con el equipo +cp python-reviewer.agent.md .github/agents/ +``` + +## Sample Files in This Folder + +| File | Description | Best For | +|------|-------------|----------| +| `hello-world.agent.md` | Minimal example (11 lines) | Learning the format | +| `python-reviewer.agent.md` | Python code quality reviewer | Code reviews, PEP 8, type hints | +| `pytest-helper.agent.md` | Pytest testing specialist | Test generation, fixtures, edge cases | + +## Finding More Agents + +- **[github/awesome-copilot](https://github.com/github/awesome-copilot)** - Recursos oficiales de GitHub con agentes comunitarios e instrucciones + +--- + +## Agent File Format + +Each agent file requires YAML frontmatter with at least a `description` field: + +```markdown +--- +name: my-agent +description: Brief description of what this agent does +tools: ["read", "edit", "search"] # Optional: limit available tools +--- + +# Agent Name + +Agent instructions go here... +``` + +**Propiedades YAML disponibles:** + +| Property | Required | Description | +|----------|----------|-------------| +| `description` | **Sí** | Lo que hace el agente | +| `name` | No | Nombre a mostrar (por defecto, el nombre de archivo) | +| `tools` | No | Lista de herramientas permitidas (omitir = todas). Ver alias abajo. | +| `target` | No | Limitar solo a `vscode` o `github-copilot` | + +**Alias de herramientas**: `read`, `edit`, `search`, `execute` (shell), `web`, `agent` + +> 💡 **Nota**: La propiedad `model` funciona en VS Code pero aún no es compatible con Copilot CLI. +> +> 📖 **Documentación oficial**: [Configuración de agentes personalizados](https://docs.github.com/copilot/reference/custom-agents-configuration) + +## Agent File Locations + +Los agentes pueden almacenarse en: +- `~/.copilot/agents/` - Agentes globales disponibles en todos los proyectos +- `.github/agents/` - Agentes específicos del proyecto +- `.agent.md` archivos - Formato compatible con VS Code + +Each agent is a separate file with the `.agent.md` extension. + +--- + +## Usage Examples + +```bash +# Comienza con un agente específico +copilot --agent python-reviewer + +# O selecciona un agente de forma interactiva durante una sesión +copilot +> /agent +# Selecciona "python-reviewer" de la lista + +# La experiencia del agente se aplica a tus indicaciones +> @samples/book-app-project/books.py Review this code for quality issues + +# Cambia a un agente diferente +> /agent +# Selecciona "pytest-helper" + +> @samples/book-app-project/tests/test_books.py What additional tests should we add? +``` + +--- + +## Creating Your Own Agents + +1. Create a new file in `~/.copilot/agents/` with `.agent.md` extension +2. Add YAML frontmatter with at least a `description` field +3. Add a descriptive header (e.g., `# Security Agent`) +4. Define the agent's expertise, standards, and behaviors +5. Use the agent with `/agent` or `--agent
Patrones @ adicionales y comandos de sesión
diff --git a/translations/es/03-development-workflows/README.md b/translations/es/03-development-workflows/README.md index 78964b32..3a708cfa 100644 --- a/translations/es/03-development-workflows/README.md +++ b/translations/es/03-development-workflows/README.md @@ -42,15 +42,15 @@ Este capítulo cubre cinco flujos de trabajo que los desarrolladores suelen usar
-| I want to... | Jump to |
+| Quiero... | Ir a |
|---|---|
-| Review code before merging | [Workflow 1: Code Review](#workflow-1-code-review) |
-| Clean up messy or legacy code | [Workflow 2: Refactoring](#workflow-2-refactoring) |
-| Track down and fix a bug | [Workflow 3: Debugging](#workflow-3-debugging) |
-| Generate tests for my code | [Workflow 4: Test Generation](#workflow-4-test-generation) |
-| Write better commits and PRs | [Workflow 5: Git Integration](#workflow-5-git-integration) |
-| Research before coding | [Quick Tip: Research Before You Plan or Code](#revisar-antes-del-push) |
-| See a full bug-fix workflow end to end | [Putting It All Together](#usar-delegate-para-tareas-en-segundo-plano) |
+| Revisar código antes de fusionar | [Flujo de trabajo 1: Revisión de código](#workflow-1-code-review) |
+| Limpiar código desordenado o heredado | [Flujo de trabajo 2: Refactorización](#workflow-2-refactoring) |
+| Localizar y corregir un error | [Flujo de trabajo 3: Depuración](#workflow-3-debugging) |
+| Generar pruebas para mi código | [Flujo de trabajo 4: Generación de pruebas](#workflow-4-test-generation) |
+| Escribir mejores commits y pull requests | [Flujo de trabajo 5: Integración con Git](#workflow-5-git-integration) |
+| Investigar antes de codificar | [Consejo rápido: Investigar antes de planificar o codificar](#revisar-antes-del-push) |
+| Ver un flujo de trabajo completo de corrección de errores de principio a fin | [Poniéndolo todo junto](#usar-delegate-para-tareas-en-segundo-plano) |
**Selecciona un flujo de trabajo abajo para expandirlo** y ver cómo GitHub Copilot CLI puede mejorar tu proceso de desarrollo en esa área.
diff --git a/translations/es/05-skills/README.md b/translations/es/05-skills/README.md
index 5c3273e3..2279bf27 100644
--- a/translations/es/05-skills/README.md
+++ b/translations/es/05-skills/README.md
@@ -4,7 +4,7 @@
En este capítulo aprenderás sobre Agent Skills: carpetas de instrucciones que Copilot carga automáticamente cuando son relevantes para tu tarea. Mientras que los agentes cambian *cómo* piensa Copilot, las skills le enseñan *formas específicas de completar tareas*. Crearás una skill de auditoría de seguridad que Copilot aplicará siempre que preguntes sobre seguridad, construirás criterios de revisión estándar del equipo que garanticen calidad de código coherente y aprenderás cómo funcionan las skills en Copilot CLI, VS Code y el agente en la nube de GitHub Copilot.
-## 🎯 Learning Objectives
+## 🎯 Objetivos de aprendizaje
Al final de este capítulo, podrás:
@@ -37,7 +37,7 @@ Las skills funcionan de la misma manera. Igual que cambiar brocas para diferente
---
-# How Skills Work
+# Cómo funcionan las Skills
@@ -60,7 +60,7 @@ Aprende qué son las skills, por qué importan y en qué se diferencian de los a
3. **Entiende el concepto principal:** Las skills son instrucciones específicas de tareas que Copilot carga *automáticamente* cuando tu prompt coincide con la descripción de la skill. No necesitas activarlas, solo pregunta de forma natural.
-## Understanding Skills
+## Entendiendo las Skills
Agent Skills son carpetas que contienen instrucciones, scripts y recursos que Copilot **carga automáticamente cuando son relevantes** para tu tarea. Copilot lee tu prompt, comprueba si alguna skill coincide y aplica las instrucciones relevantes automáticamente.
diff --git a/translations/es/README.md b/translations/es/README.md
index a99bfea1..b86601af 100644
--- a/translations/es/README.md
+++ b/translations/es/README.md
@@ -41,7 +41,7 @@ Antes de comenzar, asegúrate de tener:
## 🤖 Comprender la familia GitHub Copilot
-GitHub Copilot ha evolucionado hasta convertirse en una familia de herramientas impulsadas por IA. Aquí es dónde vive cada una:
+GitHub Copilot ha evolucionado hasta convertirse en una familia de herramientas impulsadas por IA. Aquí es dónde se encuentra cada una:
| Producto | Dónde se ejecuta | Descripción |
|---------|---------------|----------|
@@ -99,7 +99,7 @@ La **[GitHub Copilot CLI command reference](https://docs.github.com/en/copilot/r
3. Realiza tus cambios
4. Envía un pull request
-## License
+## Licencia
This project is licensed under the terms of the MIT open source license. Please refer to the [LICENSE](../../LICENSE) file for the full terms.
From 3816ef945f7933405d0c08be52021a141765ce90 Mon Sep 17 00:00:00 2001
From: Dan Wahlin
@@ -34,7 +34,7 @@ Para proporcionar contexto a Copilot CLI usa *la sintaxis `@`* para indicarle ar
---
-# Essential: Basic Context
+# Esencial: Contexto básico
@@ -42,13 +42,13 @@ Esta sección cubre todo lo que necesitas para trabajar de forma efectiva con el
---
-## The @ Syntax
+## La sintaxis @
El símbolo `@` referencia archivos y directorios en tus mensajes. Es la forma de decirle a Copilot CLI "mira este archivo."
> 💡 **Nota**: Todos los ejemplos de este curso usan la carpeta `samples/` incluida en este repositorio, así que puedes probar cada comando directamente.
-### Try It Now (No Setup Required)
+### Pruébalo ahora (sin configuración necesaria)
Puedes probar esto con cualquier archivo en tu computadora:
@@ -68,7 +68,7 @@ copilot
> > What does @test.py do?
> ```
-### Basic @ Patterns
+### Patrones @ básicos
| Pattern | Qué hace | Ejemplo de uso |
|---------|--------------|-------------|
@@ -76,7 +76,7 @@ copilot
| `@folder/` | Referencia todos los archivos en un directorio | `Review @samples/book-app-project/` |
| `@file1.py @file2.py` | Referencia múltiples archivos | `Compare @samples/book-app-project/book_app.py @samples/book-app-project/books.py` |
-### Reference a Single File
+### Referenciar un solo archivo
```bash
copilot
@@ -97,7 +97,7 @@ copilot
---
-### Reference Multiple Files
+### Referenciar múltiples archivos
```bash
copilot
@@ -105,7 +105,7 @@ copilot
> Compare @samples/book-app-project/book_app.py and @samples/book-app-project/books.py for consistency
```
-### Reference an Entire Directory
+### Referenciar un directorio completo
```bash
copilot
@@ -115,13 +115,13 @@ copilot
---
-## Cross-File Intelligence
+## Inteligencia entre archivos
Aquí es donde el contexto se convierte en una superpotencia. El análisis de un solo archivo es útil. El análisis entre archivos es transformador.
-### Demo: Find Bugs That Span Multiple Files
+### Demo: Encontrar errores que abarcan múltiples archivos
```bash
copilot
@@ -183,7 +183,7 @@ Cross-Module Analysis
---
-### Demo: Understand a Codebase in 60 Seconds
+### Demo: Comprender una base de código en 60 segundos
@@ -214,9 +214,9 @@ Priority fix: Consolidate duplicate display functions and add input validation.
---
-## Practical Examples
+## Ejemplos prácticos
-### Example 1: Code Review with Context
+### Ejemplo 1: Revisión de código con contexto
```bash
copilot
@@ -232,7 +232,7 @@ copilot
# Ahora revisando book_app.py, pero aún consciente del contexto de books.py
```
-### Example 2: Understanding a Codebase
+### Ejemplo 2: Comprender una base de código
```bash
copilot
@@ -259,7 +259,7 @@ copilot
@@ -436,19 +436,19 @@ Sin volver a explicar. Sin volver a leer archivos. Simplemente continúa trabaja
---
-# Optional: Going Deeper
+# Opcional: Profundizar
-Estos temas se basan en lo esencial anterior. **Elige lo que te interese, o salta a [Práctica](#el-espectro-de-especificidad).**
+Estos temas se basan en lo esencial anterior. **Elige lo que te interese, o salta a [Práctica](#práctica).**
| Quiero aprender sobre... | Ir a |
|---|---|
-| Patrones comodín y comandos de sesión avanzados | [Patrones @ adicionales y comandos de sesión](#check-and-manage-context) |
-| Construir contexto a través de múltiples prompts | [Conversaciones conscientes del contexto](#patrones-adicionales) |
-| Límites de tokens y `/compact` | [Entendiendo las ventanas de contexto](#compartir-tu-sesión) |
-| Cómo elegir los archivos correctos para referenciar | [Elegir qué referenciar](#el-comando-compact) |
-| Analizar capturas de pantalla y maquetas | [Trabajar con imágenes](#qué-incluir-vs-excluir) |
+| Patrones comodín y comandos de sesión avanzados | [Patrones @ adicionales y comandos de sesión](#patrones-adicionales) |
+| Construir contexto a través de múltiples prompts | [Conversaciones conscientes del contexto](#conversaciones-conscientes-del-contexto) |
+| Límites de tokens y `/compact` | [Comprender las ventanas de contexto](#comprender-las-ventanas-de-contexto) |
+| Cómo elegir los archivos correctos para referenciar | [Elegir qué referenciar](#eligiendo-qué-referenciar) |
+| Analizar capturas de pantalla y maquetas | [Trabajar con imágenes](#trabajar-con-imágenes) |