Curso de Github Copilot para Ingeniería de Datos

Comprensión de la diferencia entre repositorios públicos, privados e internos y del impacto que tiene cada contexto sobre el trabajo con Copilot.

Revisión de permisos de organización, repositorio, branch y entorno antes de permitir que agentes o herramientas modifiquen recursos.

Aplicación del principio de mínimo privilegio a usuarios, agentes, tokens, herramientas MCP y workflows automatizados.

Protección de passwords, connection strings, claves API, tokens, certificados y secretos mediante GitHub Secrets y mecanismos específicos en lugar de incorporarlos al código.

Identificación de datos personales, información confidencial, datasets regulados y metadatos que no deben trasladarse innecesariamente al contexto del modelo.

Aplicación de anonimización, pseudonimización y generación de datos sintéticos para desarrollar y probar pipelines sin utilizar datos productivos.

Diferenciación entre código del proyecto, documentación pública, librerías externas y propiedad intelectual de terceros.

Revisión de sugerencias que puedan reproducir patrones inseguros, dependencias vulnerables o código incompatible con políticas corporativas.

Utilización de controles de coincidencia con código público y políticas centralizadas de GitHub como parte del gobierno corporativo de Copilot.

Comprensión de que GitHub no utiliza datos de clientes Copilot Business o Enterprise para entrenar modelos de IA.

Identificación de riesgos de prompt injection cuando agentes reciben contenido procedente de documentación, Issues, repositorios o herramientas externas.

Restricción de comandos y herramientas capaces de borrar datos, modificar infraestructura, ejecutar DDL destructivo o acceder a entornos sensibles.

Revisión humana obligatoria antes de merges, despliegues, migraciones de esquema, operaciones destructivas o modificaciones de seguridad.

Conservación de trazabilidad mediante commits, Pull Requests, Actions, logs y artefactos de validación.

Construcción de una política de uso seguro de GitHub Copilot específica para repositorios y pipelines de datos.

Diseño de prompts técnicos mediante objetivo, contexto, restricciones, stack, formato, criterios de aceptación y validaciones esperadas.

Diferenciación entre preguntar por una línea de código y proporcionar contexto suficiente para razonar sobre un pipeline completo.

Selección deliberada de archivos, modelos, esquemas, tests, documentación y configuraciones que deben formar parte del contexto.

Uso de referencias explícitas al código para reducir respuestas genéricas y orientar a Copilot hacia implementaciones existentes.

Solicitud de explicación de un repositorio desconocido antes de modificarlo para reconstruir arquitectura, dependencias y flujo del dato.

Identificación de entry points, fuentes, transformaciones, sinks, configuraciones, contratos y tests dentro de un proyecto existente.

Utilización de Copilot para reconstruir data flows y dependencias a partir del código sin asumir que su interpretación es automáticamente correcta.

Diseño de prompts para analizar logs, stack traces y errores de ejecución aportando únicamente el contexto relevante.

Uso de restricciones explícitas sobre versión de Python, SQL dialect, framework, coste o compatibilidad para evitar propuestas inaplicables.

Creación de solicitudes que obliguen a Copilot a explicar supuestos y señalar información ausente antes de generar cambios.

Utilización de Plan Mode para investigar una tarea y producir un plan revisable antes de permitir modificaciones en el código.

Uso de Copilot Spaces para agrupar contexto e instrucciones relacionados con un dominio, pipeline o iniciativa de datos y fundamentar mejor las conversaciones.

Diferenciación entre contexto persistente del proyecto y contexto específico que solo debe aportarse para una tarea.

Refinamiento iterativo de solicitudes mediante pruebas, errores y feedback del código generado.

Construcción de una biblioteca de prompts especializados en análisis, generación, debugging, testing, documentación y optimización de pipelines.

Configuración de `.github/copilot-instructions.md` para proporcionar a Copilot convenciones y reglas que deben respetarse en todo el repositorio.

Definición de instrucciones sobre stack, versiones, arquitectura, nomenclatura, testing, seguridad, logging y tratamiento de errores.

Creación de instrucciones específicas por ruta para aplicar criterios diferentes a SQL, Python, dbt, tests, notebooks o infraestructura.

Uso de `AGENTS.md` para aportar a agentes contexto adicional sobre estructura, arquitectura, validaciones y comportamiento esperado del proyecto.

Diferenciación entre instrucciones persistentes y prompts puntuales para evitar archivos de instrucciones excesivamente largos o contradictorios.

Creación de Prompt Files `.prompt.md` para encapsular tareas recurrentes como crear tests, analizar un pipeline o revisar una consulta SQL.

Uso de variables, referencias y contexto dentro de Prompt Files para reutilizar la misma metodología con diferentes componentes.

Diseño de Agent Skills que agrupen instrucciones, scripts y recursos necesarios para ejecutar workflows técnicos repetibles.

Creación de Skills para validación de modelos, análisis de errores de CI, generación de documentación o revisión de calidad del dato.

Definición de Custom Agents especializados con instrucciones, contexto y herramientas restringidas para tareas concretas.

Diseño de un agente SQL Reviewer limitado a análisis y revisión frente a un agente Pipeline Engineer con capacidades de edición y ejecución.

Restricción deliberada de herramientas disponibles para cada agente según el principio de mínimo privilegio.

Introducción a Hooks para ejecutar validaciones, logging o controles obligatorios antes y después de determinadas acciones de un agente.

Uso de Plugins para empaquetar agentes, Skills, hooks y configuraciones relacionadas y distribuirlas de forma coherente entre equipos.

Construcción de una capa de personalización del repositorio que permita a distintos ingenieros obtener resultados más consistentes con los estándares del equipo.

Uso de sugerencias inline y Chat para acelerar implementación sin delegar la comprensión del comportamiento final del código.

Generación de funciones Python a partir de requisitos claros sobre entradas, salidas, tipos, excepciones y efectos secundarios.

Uso de type hints y estructuras explícitas para proporcionar a Copilot mayor contexto y mejorar mantenibilidad.

Generación de código para lectura y escritura de CSV, JSON, Parquet, bases de datos y APIs dentro de pipelines de ingestión.

Diseño de conexiones a bases de datos utilizando configuración externa y gestión segura de credenciales.

Generación y revisión de consultas SQL complejas con joins, CTE, funciones ventana, agregaciones y lógica condicional.

Adaptación de consultas a dialectos concretos evitando asumir compatibilidad sintáctica entre motores.

Explicación de queries legacy y reconstrucción de la intención de transformaciones SQL difíciles de mantener.

Refactoring de SQL repetitivo en componentes más legibles sin modificar el resultado funcional esperado.

Revisión de problemas habituales de rendimiento como `SELECT *`, filtros tardíos, joins innecesarios o operaciones costosas.

Generación de código parametrizable evitando concatenaciones inseguras y valores hardcoded.

Creación de transformaciones idempotentes que puedan reejecutarse sin duplicar o corromper información.

Tratamiento explícito de errores, timeouts, retries y recursos externos en código de acceso a datos.

Comparación entre propuestas generadas y selección razonada de la alternativa más comprensible, eficiente y mantenible.

Verificación del código mediante tests y ejecución real antes de aceptar una sugerencia como solución terminada.

Utilización de Copilot dentro de notebooks para explorar datasets sin convertir el notebook en un conjunto desordenado de celdas imposibles de reproducir.

Generación de código para carga, inspección y comprensión inicial de datos tabulares.

Análisis de tipos, cardinalidad, valores nulos, duplicados, distribuciones y rangos antes de comenzar transformaciones.

Creación de perfiles que permitan detectar problemas de calidad antes de integrar una fuente en un pipeline.

Utilización de Copilot para explicar errores de parsing, tipos incompatibles, encoding o formatos de fecha.

Diseño de transformaciones con Pandas y APIs DataFrame manteniendo claridad sobre cada modificación aplicada al dataset.

Normalización de strings, fechas, categorías, identificadores y valores numéricos mediante transformaciones reproducibles.

Detección y tratamiento explícito de outliers, registros incompletos y datos anómalos según reglas de negocio.

Generación de visualizaciones exploratorias orientadas a comprender el dato y no únicamente a producir gráficos.

Comparación de varios datasets para localizar diferencias estructurales, registros ausentes o problemas de reconciliación.

Documentación dentro del notebook de supuestos, decisiones y criterios utilizados durante la exploración.

Refactoring de código exploratorio hacia funciones y módulos reutilizables una vez validada la lógica.

Separación entre experimentación, código de producción y artefactos temporales para evitar incorporar accidentalmente lógica no controlada.

Reproducción del notebook desde cero para detectar dependencias ocultas derivadas del orden de ejecución.

Conversión de un análisis exploratorio en especificaciones claras para el pipeline productivo que se desarrollará posteriormente.

Diseño de pipelines a partir de contratos explícitos sobre origen, destino, frecuencia, volumen, latencia y comportamiento ante errores.

Diferenciación entre ETL y ELT y selección del patrón en función de plataforma, volumen, coste y capacidad del sistema destino.

Desarrollo asistido de ingestiones desde APIs, archivos, bases de datos y otras fuentes manteniendo separación entre configuración y lógica.

Implementación de cargas completas e incrementales evitando utilizar una estrategia full refresh cuando no resulta necesaria.

Uso de timestamps, watermarks, IDs crecientes u otros mecanismos para controlar procesamiento incremental.

Diseño de checkpoints que permitan reanudar una carga después de un fallo sin comenzar todo el proceso de nuevo.

Aplicación de idempotencia para garantizar que la repetición de una ejecución no genere registros duplicados.

Tratamiento de paginación, rate limits, timeouts y errores temporales al consumir servicios externos.

Configuración de retries con backoff y límites explícitos para evitar bucles incontrolados.

Gestión de schema drift y cambios inesperados de estructura sin ocultar incompatibilidades potencialmente críticas.

Separación entre zonas raw, staging y datos transformados para conservar trazabilidad y facilitar reprocesamiento.

Incorporación de metadatos técnicos como fecha de ingestión, origen, lote y versión del pipeline.

Diseño de cuarentenas para registros inválidos en lugar de descartar silenciosamente información problemática.

Generación de logging estructurado que permita reconstruir volumen procesado, errores y duración de cada etapa.

Construcción con Copilot de un pipeline incremental completo y posterior revisión manual de su comportamiento ante reruns y fallos parciales.

Traducción de requisitos analíticos en modelos de datos que mantengan separadas las necesidades del negocio y los detalles físicos de almacenamiento.

Revisión de conceptos de hechos, dimensiones, granularidad y claves antes de pedir a Copilot que genere modelos analíticos.

Diseño de modelos dimensionales evitando mezclar granularidades incompatibles dentro de una misma tabla de hechos.

Uso de Copilot para generar SQL de staging manteniendo una convención clara de nombres y transformaciones.

Construcción de modelos dbt intermedios y finales con responsabilidades explícitas y dependencias comprensibles.

Diseño de modelos incrementales y análisis de las condiciones necesarias para que su actualización sea correcta.

Generación de macros cuando existe una transformación repetitiva suficientemente estable para justificar su abstracción.

Uso de `ref` y `source` para declarar dependencias y mejorar trazabilidad frente a referencias físicas hardcoded.

Preparación de archivos YAML para documentar modelos, columnas, fuentes y tests.

Generación de tests dbt para `not_null`, `unique`, relaciones y valores aceptados a partir de reglas de negocio.

Creación de tests personalizados cuando una regla de calidad no puede expresarse mediante validaciones genéricas.

Tratamiento de Slowly Changing Dimensions y cambios históricos según las necesidades del modelo.

Revisión de SQL generado para detectar duplicaciones de lógica, modelos excesivamente complejos y costes innecesarios.

Utilización de documentación y lineage de dbt como contexto adicional para que Copilot comprenda mejor el proyecto.

Refactoring de un conjunto de transformaciones SQL hacia un proyecto dbt estructurado, documentado y probado.

Comprensión de por qué un código correcto sobre pequeños datasets puede comportarse de forma muy diferente cuando se ejecuta de forma distribuida.

Generación de transformaciones PySpark utilizando DataFrames y funciones nativas en lugar de trasladar directamente patrones ineficientes de Python.

Diferenciación entre transformations y actions para comprender cuándo se construye el plan y cuándo se inicia realmente el procesamiento.

Análisis del lazy evaluation para interpretar correctamente errores y tiempos de ejecución.

Diseño de joins considerando volumen, cardinalidad y distribución de los datos y no únicamente corrección sintáctica.

Identificación de shuffles y de su impacto sobre tiempo, red y coste de ejecución.

Selección y tratamiento de particiones para evitar tanto archivos excesivamente pequeños como particiones inmanejables.

Detección de data skew cuando una distribución desigual de claves degrada de forma significativa determinadas tareas.

Uso razonado de broadcast joins cuando el tamaño de una de las relaciones permite evitar movimientos de datos innecesarios.

Aplicación de cache o persistencia únicamente cuando existe reutilización suficiente para compensar su coste.

Evitación de UDFs Python cuando existe una función nativa equivalente más eficiente.

Análisis con Copilot de planes y código para localizar operaciones potencialmente costosas sin asumir que sus recomendaciones sustituyen profiling real.

Generación de transformaciones parametrizables y reutilizables para cargas batch.

Diseño de pruebas con datasets pequeños que reproduzcan edge cases antes de ejecutar cargas de gran volumen.

Optimización progresiva de un pipeline PySpark basándose en evidencia de ejecución y no únicamente en recomendaciones teóricas generadas por IA.

Tratamiento de calidad como parte del diseño del pipeline y no como una comprobación posterior realizada únicamente cuando aparecen problemas.

Traducción de reglas de negocio a controles concretos sobre nulidad, unicidad, rangos, formatos, relaciones y consistencia.

Generación de Unit Tests para funciones Python de transformación utilizando casos normales, límites y situaciones de error.

Preparación de Integration Tests para validar conexiones y comportamiento entre componentes reales del pipeline.

Creación de fixtures y datasets sintéticos que permitan reproducir defectos sin utilizar información productiva.

Uso de Copilot para proponer casos de prueba adicionales y revisión manual de si representan realmente riesgos relevantes.

Construcción de tests dbt sobre modelos y fuentes para detectar cambios inesperados antes de publicar información incorrecta.

Introducción a Data Contracts para explicitar esquema, semántica, ownership y expectativas entre productor y consumidor.

Validación de schema evolution para detectar cambios incompatibles antes de que afecten a consumidores downstream.

Incorporación de controles de freshness para identificar fuentes que han dejado de actualizarse.

Diseño de métricas sobre volumen, registros rechazados, duración, retraso y porcentaje de errores.

Correlación de logs y métricas para diferenciar problemas de infraestructura, fuente, transformación y calidad.

Preparación de mensajes de error suficientemente ricos para permitir diagnóstico sin exponer información sensible.

Utilización de Copilot para investigar fallos a partir de logs manteniendo la comprobación sobre la causa raíz real.

Construcción de una estrategia de calidad y observabilidad que permita impedir que un pipeline aparentemente exitoso publique datos incorrectos.

Comprensión del papel de un orquestador para coordinar dependencias, calendarios, retries y estados sin incorporar lógica de negocio innecesaria al propio workflow.

Diseño de dependencias explícitas entre ingestión, validación, transformación, publicación y controles posteriores.

Uso de Copilot para generar y revisar definiciones de DAGs y workflows a partir de requisitos previamente especificados.

Aplicación de buenas prácticas trasladables a Apache Airflow, Fabric Data Factory, Azure Data Factory, Databricks Workflows y otros orquestadores.

Diferenciación entre lógica del pipeline y configuración específica del motor de orquestación para facilitar portabilidad y testing.

Diseño de parámetros y configuración por entorno evitando duplicar workflows completos para desarrollo, test y producción.

Preparación de retries, timeouts, dependencias y mecanismos de recovery adecuados al comportamiento del proceso.

Gestión de backfills y reprocesamientos históricos sin afectar indebidamente a las cargas ordinarias.

Integración conceptual con plataformas de datos como Microsoft Fabric, Azure, Databricks, Snowflake, BigQuery y servicios equivalentes.

Revisión de patrones de integración con Kafka y sistemas event-driven cuando el procesamiento deja de ser exclusivamente batch.

Generación de adapters o wrappers que aíslen APIs específicas de proveedores del núcleo de transformación.

Uso de Copilot para comprender SDKs y APIs externas manteniendo la documentación oficial como fuente de verdad.

Preparación de scripts de operación para lanzar, inspeccionar o recuperar pipelines desde herramientas autorizadas.

Identificación de qué información de sistemas externos puede exponerse al contexto de Copilot y qué datos deben permanecer protegidos.

Diseño de una arquitectura de integración que permita utilizar Copilot sin introducir dependencias artificiales con una única plataforma de datos.

Uso de GitHub Actions para convertir validaciones manuales en controles reproducibles antes de integrar cambios.

Creación asistida de workflows YAML entendiendo triggers, jobs, steps, runners y dependencias en lugar de aceptar configuraciones opacas.

Ejecución automática de linting, formateo y análisis estático sobre código Python y SQL.

Ejecución de Unit Tests e Integration Tests como condición previa al merge.

Validación de proyectos dbt mediante compilación, tests y otras comprobaciones antes de publicar cambios.

Uso de cachés para reducir tiempos de instalación manteniendo criterios claros de invalidación.

Gestión de artefactos y resultados de pruebas para conservar evidencias del pipeline de CI.

Uso de GitHub Secrets y variables de entorno sin incorporar credenciales a repositorios o logs.

Construcción de imágenes Docker reproducibles para empaquetar dependencias y reducir diferencias entre entornos.

Revisión con Copilot de Dockerfiles para detectar capas innecesarias, dependencias excesivas o configuraciones inseguras.

Separación entre workflows de validación y workflows capaces de desplegar o modificar recursos productivos.

Aplicación de environments, protecciones y aprobaciones antes de ejecutar acciones sobre entornos sensibles.

Generación de documentación del workflow para que el proceso de despliegue no dependa exclusivamente de conocimiento tácito.

Investigación con Copilot de fallos de GitHub Actions utilizando logs, cambios recientes y configuración relacionada.

Construcción de un pipeline CI/CD completo para validar y empaquetar una solución de ingeniería de datos antes de promoverla.

Creación de ramas y commits con alcance reducido para facilitar revisión y rollback de cambios.

Uso de Copilot para elaborar mensajes de commit y descripciones de Pull Request basadas en el cambio real realizado.

Preparación de Pull Requests que expliquen problema, solución, impacto, pruebas y riesgos y no únicamente enumeren archivos modificados.

Utilización de Copilot Code Review para identificar bugs, problemas de mantenibilidad y posibles mejoras antes de solicitar la revisión definitiva de otra persona.

Personalización de Code Review mediante instrucciones de repositorio y por ruta para revisar de manera diferente Python, SQL, dbt e infraestructura.

Verificación manual de los comentarios de Copilot antes de aceptar cualquier modificación sugerida.

Uso de Code Review sobre cambios sin commit para obtener feedback temprano antes de abrir una Pull Request.

Revisión específica de queries buscando cambios involuntarios de granularidad, duplicación de registros o pérdida de filtros.

Revisión de transformaciones Python y Spark considerando comportamiento, coste y edge cases además de estilo.

Generación y mantenimiento de README, diagramas conceptuales, documentación de pipelines y guías de ejecución.

Creación de runbooks para diagnóstico y recuperación de pipelines sin depender del desarrollador original.

Documentación de decisiones relevantes mediante ADRs cuando una elección técnica condiciona significativamente la evolución del sistema.

Incorporación de lineage, ownership y descripción funcional suficiente para que otros equipos comprendan los datasets generados.

Uso de Issues como unidades de trabajo con contexto y criterios de aceptación suficientes para soportar posteriormente delegación agentic.

Construcción de un flujo colaborativo donde Copilot acelere preparación y revisión sin sustituir los mecanismos de responsabilidad técnica del equipo.

Uso de Plan Mode para investigar cambios complejos y revisar una estrategia antes de permitir modificaciones sobre varios componentes.

Utilización de Agent Mode para tareas multietapa donde Copilot necesita editar varios archivos, ejecutar comandos, observar errores e iterar sobre la solución.

Definición de criterios de aceptación suficientemente precisos para que un agente pueda comprobar cuándo ha completado realmente una tarea.

Supervisión de comandos de terminal antes de permitir operaciones con impacto sobre datos, filesystem o servicios externos.

Uso de subagents para delegar subtareas aisladas como investigación del repositorio, generación de tests o análisis de documentación.

Selección de Custom Agents especializados en SQL, Python, calidad, documentación o revisión según la naturaleza de cada subtarea.

Utilización de GitHub Copilot CLI para interactuar con Copilot directamente desde terminal y trabajar sobre código, comandos y workflows.

Configuración del GitHub MCP Server para consultar y actuar sobre repositorios, Issues y Pull Requests directamente desde experiencias agentic.

Uso de MCP para conectar de forma controlada herramientas de ingeniería de datos y fuentes externas que necesiten contexto o acciones específicas.

Evaluación de permisos y superficie de riesgo antes de conceder a un agente herramientas capaces de ejecutar queries o modificar sistemas.

Delegación de Issues bien acotadas a Copilot cloud agent para que investigue el repositorio, implemente cambios y genere una Pull Request para revisión.

Diferenciación entre agente local supervisado y cloud agent que realiza el trabajo en un entorno separado y devuelve cambios mediante GitHub.

Uso de Hooks para bloquear operaciones peligrosas, ejecutar secret scanning o exigir validaciones durante el ciclo de un agente.

Diseño de workflows agentic recurrentes para investigación de errores de CI, mantenimiento o tareas técnicas repetibles sin eliminar la revisión humana.

Construcción de una estrategia de delegación progresiva donde la autonomía del agente aumente únicamente cuando la tarea, tests y controles permiten verificar objetivamente el resultado.

Análisis de un repositorio de ingeniería de datos que contiene ingestión, transformación, modelado, testing, documentación y automatización.

Creación de instrucciones de repositorio y reglas específicas para Python, SQL, dbt y workflows de GitHub Actions.

Diseño de Prompt Files reutilizables para generación de tests, revisión SQL, documentación y diagnóstico de errores.

Preparación de un Copilot Space con contexto técnico suficiente para comprender arquitectura, convenciones y objetivos del proyecto.

Implementación mediante Python de una ingestión incremental con configuración externa, logging, retries e idempotencia.

Desarrollo de transformaciones SQL y modelos dbt con documentación, dependencias y tests de calidad.

Incorporación de una transformación PySpark y análisis de su comportamiento ante particiones, joins y volumen.

Creación de datasets sintéticos y tests automatizados para validar escenarios normales, límites y errores.

Definición de controles de calidad, freshness, esquema y observabilidad sobre los principales datasets.

Diseño de la orquestación que conecte ingestión, validación, transformación y publicación con mecanismos de recovery.

Construcción de un workflow GitHub Actions que ejecute validaciones, tests y empaquetado de la solución.

Apertura de una Pull Request y revisión mediante Copilot Code Review, justificando qué sugerencias se aceptan o descartan.

Uso de Plan Mode y Agent Mode para realizar un cambio transversal sobre varios componentes sin perder control sobre el alcance.

Creación de un agente o Skill especializado en una tarea repetitiva de ingeniería de datos e integración de una herramienta mediante MCP.

Delegación de una Issue acotada al cloud agent y evaluación final de código, tests, seguridad, rendimiento, trazabilidad, documentación y criterios necesarios antes de considerar el cambio apto para producción.