Curso de PromptTest

Crear entorno Python con virtualenv, venv, pyenv, uv o herramienta equivalente según el equipo.

Instalar PromptTest con `pip` en un entorno aislado y verificable.

Inicializar un proyecto PromptTest con configuración base y estructura de carpetas.

Revisar archivos generados, convenciones, rutas, prompts, tests e informes.

Configurar variables de entorno para proveedores LLM y evitar exponer claves en el repositorio.

Ejecutar la primera prueba desde terminal y revisar el resultado en consola.

Localizar informes Markdown generados tras la ejecución.

Configurar el proyecto en Visual Studio Code con terminal, extensiones YAML y Markdown preview.

Resolver errores iniciales de instalación, permisos, versiones de Python, dependencias o API key.

Crear repositorio Git inicial con `.gitignore`, README, estructura y primer commit.

Crear prompts `.txt` separados del código para poder versionarlos, revisarlos y probarlos.

Dividir prompts en secciones como sistema, usuario, instrucciones, contexto, restricciones y formato.

Usar variables entre llaves para reutilizar el prompt con distintos inputs.

Evitar prompts monolíticos difíciles de mantener, comparar y evaluar.

Diseñar prompts con instrucciones claras, objetivo, audiencia, tono, formato y criterios de rechazo.

Separar reglas obligatorias de recomendaciones opcionales para facilitar evaluación.

Documentar supuestos del prompt: idioma, dominio, límites, datos disponibles y comportamiento esperado.

Crear prompts preparados para tareas de generación, clasificación, extracción, resumen y análisis.

Identificar qué partes del prompt son críticas para la calidad y deben tener tests específicos.

Realizar ejercicio de transformación de un prompt informal en prompt testable.

Crear archivos `.yml` de prueba con configuración, prompt asociado, inputs y criterios.

Definir tests con identificadores claros, legibles y útiles para depuración.

Especificar inputs representativos usando variables alineadas con el prompt.

Redactar criterios en lenguaje natural de forma precisa, observable y evaluable.

Diferenciar criterios funcionales, criterios de tono, criterios de contenido y criterios de formato.

Evitar criterios vagos como “la respuesta debe ser buena” o “debe sonar profesional”.

Crear criterios que indiquen qué debe incluir, qué debe evitar y cómo debe estructurarse la respuesta.

Agrupar tests por caso de uso, tipo de entrada, riesgo, versión o área funcional.

Mantener tests pequeños y específicos para localizar fallos con rapidez.

Realizar ejercicio de creación de suite YAML para un prompt de atención al cliente.

Diseñar inputs realistas que representen usuarios, productos, mensajes, documentos, tickets o casos de negocio.

Crear casos normales, casos límite, casos ambiguos, casos incompletos y casos maliciosos.

Usar variables para probar el mismo prompt con diferentes datos y escenarios.

Diseñar datasets pequeños para desarrollo rápido y datasets amplios para evaluación completa.

Evitar suites de prueba formadas solo por ejemplos felices.

Crear datos anonimizados para evitar exponer información real de clientes o empleados.

Preparar inputs multilingües, con faltas, abreviaturas, ruido, lenguaje informal y formatos inesperados.

Identificar qué variables afectan más al comportamiento del prompt.

Separar datos de test de prompts y criterios para facilitar mantenimiento.

Realizar ejercicio de construcción de dataset de pruebas para un asistente corporativo.

Ejecutar todas las pruebas del proyecto desde la CLI.

Ejecutar tests concretos por archivo, carpeta o identificador cuando se investiga un fallo.

Interpretar resultados pass/fail en consola y localizar tests fallidos.

Revisar informes Markdown con detalle de entrada, respuesta, criterio y evaluación.

Analizar si un fallo corresponde al prompt, al criterio, al input, al modelo o a la variabilidad esperada.

Repetir pruebas para detectar inestabilidad y resultados inconsistentes.

Registrar fallos significativos como issues o tareas de mejora.

Comparar el resultado de ejecución local con resultados en CI.

Evitar aprobar cambios de prompt solo porque una ejecución aislada haya pasado.

Realizar laboratorio de depuración de una suite con varios fallos provocados.

Convertir requisitos de producto en criterios de aceptación evaluables por PromptTest.

Crear rubricas con dimensiones como exactitud, completitud, formato, tono, seguridad y utilidad.

Definir niveles de calidad: excelente, aceptable, insuficiente y fallo crítico.

Incluir criterios negativos para evitar respuestas prohibidas, datos inventados o promesas no autorizadas.

Diferenciar criterios estrictos de criterios flexibles según la tarea.

Involucrar a product owners, negocio, legal, compliance o soporte en criterios de calidad.

Evitar que el equipo técnico defina calidad sin entender el contexto del usuario final.

Crear plantillas de criterio por tipo de prompt: resumen, clasificación, extracción, generación y respuesta.

Revisar rubricas periódicamente cuando cambia el producto o el riesgo.

Realizar ejercicio de creación de rubrica para evaluación LLM-as-a-judge.

Comprender cómo un modelo puede actuar como evaluador de la salida de otro modelo.

Diseñar instrucciones de evaluación claras para reducir subjetividad del juez.

Separar respuesta evaluada, criterio, input y razonamiento de evaluación.

Controlar sesgos del juez por tono, longitud, estilo, modelo o formulación del criterio.

Usar criterios concretos para reducir falsos positivos y falsos negativos.

Comparar evaluación automática con revisión humana en casos críticos.

Establecer cuándo LLM-as-a-judge es suficiente y cuándo se necesita evaluación determinista.

Revisar inconsistencias entre jueces o entre ejecuciones del mismo juez.

Crear conjunto de calibración con outputs buenos, malos y dudosos.

Realizar ejercicio de ajuste de criterios para mejorar fiabilidad del juez.

Diferenciar pruebas exactas, pruebas por propiedades, pruebas por criterio y pruebas semánticas.

Usar validaciones deterministas cuando la salida debe cumplir formato, JSON, campos o palabras obligatorias.

Usar evaluación semántica cuando la salida puede variar pero debe cumplir objetivo.

Diseñar pruebas mixtas combinando formato estricto y calidad flexible.

Identificar tareas donde una comparación exacta de texto no tiene sentido.

Validar estructura JSON, listas, tablas Markdown, número de elementos y presencia de campos clave.

Diseñar tolerancias para salidas razonablemente distintas pero válidas.

Evitar tests demasiado frágiles que fallan por variaciones irrelevantes.

Evitar tests demasiado blandos que aprueban respuestas mediocres.

Realizar ejercicio de batería de tests para salidas estructuradas y respuestas libres.

Entender la regresión como pérdida de comportamiento válido tras modificar prompt, modelo o configuración.

Crear baseline de comportamiento para prompts críticos.

Ejecutar pruebas antes y después de cambios en instrucciones, variables, contexto o ejemplos.

Documentar qué cambio se hizo, por qué, qué pruebas pasaron y qué riesgos quedan.

Comparar versiones de prompts mediante Git y revisar diferencias relevantes.

Evitar cambios grandes de prompt sin pruebas incrementales.

Crear tests para bugs encontrados en producción y evitar que reaparezcan.

Diseñar estrategia de versionado semántico de prompts: cambios menores, mayores y breaking changes.

Preparar checklist de revisión antes de mergear prompts a rama principal.

Realizar ejercicio de detección de regresión tras optimizar un prompt.

Versionar prompts, tests, criterios, datasets y reportes relevantes en Git.

Crear ramas para experimentar con nuevos prompts sin afectar producción.

Revisar cambios de prompts en pull requests igual que se revisa código.

Añadir comentarios funcionales sobre criterios, casos no cubiertos y riesgos de comportamiento.

Evitar que los prompts se mantengan como texto oculto en una plataforma sin trazabilidad.

Crear plantillas de pull request para cambios de prompts y evaluaciones.

Vincular fallos de PromptTest con issues, tareas o bugs de producto.

Establecer responsables de aprobación: técnico, producto, negocio, legal o compliance según riesgo.

Mantener historial de decisiones sobre versiones de prompts y criterios.

Realizar ejercicio de workflow Git con cambio de prompt, tests y revisión.

Ejecutar PromptTest automáticamente en pipelines de GitHub Actions, GitLab CI, Azure DevOps o Jenkins.

Configurar variables secretas para API keys sin exponerlas en logs.

Definir quality gates para bloquear despliegues cuando fallan tests críticos.

Separar tests rápidos de smoke testing y suites completas más costosas.

Gestionar costes y tiempos de ejecución de pruebas LLM en CI.

Crear matrices de ejecución por prompt, modelo, entorno o área funcional.

Guardar reportes como artefactos de pipeline para revisión posterior.

Diseñar estrategia de reintentos controlados ante variabilidad de modelos.

Evitar pipelines inestables por tests mal diseñados o criterios demasiado ambiguos.

Realizar ejercicio de CI/CD con PromptTest como gate antes de desplegar un prompt.

Probar el mismo prompt contra distintos modelos para evaluar calidad, coste, latencia y estabilidad.

Comparar versiones de modelo cuando un proveedor actualiza capacidades o comportamiento.

Evaluar impacto de temperatura, top_p, max tokens, system prompt y configuración de salida.

Crear matriz de comparación por tarea: clasificación, generación, resumen, extracción o análisis.

Identificar modelos que responden bien en pruebas simples pero fallan en casos límite.

Evaluar coste por suite, coste por test y coste por caso de uso en producción.

Documentar decisión de modelo con criterios técnicos, funcionales, económicos y de riesgo.

Evitar cambiar de modelo en producción sin ejecutar pruebas de regresión.

Crear informe de recomendación de modelo para un caso de negocio.

Realizar laboratorio de benchmark funcional con varios modelos o configuraciones.

Diseñar prompts que devuelvan JSON válido, estable y parseable.

Crear criterios para validar campos obligatorios, tipos, arrays, enums y estructuras anidadas.

Detectar salidas con texto adicional, JSON inválido, campos omitidos o tipos incorrectos.

Probar entradas con caracteres especiales, idiomas, formatos raros y datos incompletos.

Crear tests para extracción de entidades, clasificación, etiquetado, normalización y transformación.

Validar que el modelo no inventa campos ni rellena datos no presentes.

Diseñar estrategia de recuperación ante salida inválida.

Comparar validación mediante criterios en lenguaje natural y validación programática adicional.

Preparar contratos de salida para integraciones con APIs, CRMs, ERPs o sistemas internos.

Realizar ejercicio de extractor JSON probado con PromptTest.

Crear tests para saludos, preguntas frecuentes, escalado, tono, límites y políticas de respuesta.

Probar conversaciones con usuarios satisfechos, confusos, enfadados, maliciosos o fuera de alcance.

Diseñar criterios para comprobar empatía, brevedad, precisión y no invención.

Validar que el asistente no promete acciones que no puede realizar.

Probar casos con información insuficiente donde el asistente debe pedir aclaración.

Validar respuestas en varios idiomas o registros según público objetivo.

Crear tests para evitar marketing excesivo, respuestas largas o desviaciones del objetivo.

Evaluar consistencia entre respuestas a preguntas similares.

Documentar fallos de comportamiento conversacional y convertirlos en tests de regresión.

Realizar ejercicio de suite para chatbot de soporte o atención al cliente.

Diseñar pruebas para asistentes que responden usando documentos, bases de conocimiento o contenido recuperado.

Diferenciar fallo de recuperación, fallo de generación y fallo de evaluación.

Crear criterios que obliguen a responder solo con información de la fuente disponible.

Validar que la respuesta cite, mencione o respete fragmentos del documento cuando el sistema lo permite.

Probar documentos contradictorios, obsoletos, incompletos o con ruido.

Diseñar tests para “no sé” cuando la respuesta no está en el contexto.

Evitar que el modelo complete huecos con conocimiento general no autorizado.

Crear datasets de preguntas esperadas por documento, área o proceso.

Comparar comportamiento antes y después de cambiar chunking, embeddings, retrieval o prompt.

Realizar ejercicio de evaluación de asistente RAG con PromptTest.

Diseñar pruebas para agentes que usan herramientas, APIs, búsquedas, calculadoras o sistemas internos.

Diferenciar evaluación de respuesta final y evaluación de trayectoria o acción ejecutada.

Crear criterios para validar selección correcta de herramienta, argumentos y límites de actuación.

Probar casos donde el agente debe pedir aprobación humana antes de actuar.

Validar que el agente no ejecuta acciones prohibidas ni usa herramientas fuera de contexto.

Crear tests para errores de herramienta, timeouts, datos ausentes y respuestas parciales.

Registrar outputs intermedios cuando sea necesario para depuración.

Diseñar pruebas para agentes de soporte, datos, compras, legal, DevOps o automatización interna.

Evitar confiar en agentes que pasan tests de texto pero fallan en acciones reales.

Realizar ejercicio de evaluación de workflow agentic con criterios funcionales y de seguridad.

Crear pruebas con entradas ambiguas, incompletas, contradictorias o mal redactadas.

Probar prompts frente a intentos de ignorar instrucciones, cambiar rol o saltarse restricciones.

Diseñar casos con datos sensibles simulados, información no autorizada y solicitudes fuera de política.

Validar que el modelo mantiene límites aunque el usuario insista o use lenguaje persuasivo.

Probar entradas largas, ruido, mezclas de idiomas, tablas, errores tipográficos y formatos inesperados.

Crear tests de abuso para asistentes que generan recomendaciones, respuestas legales, médicas, financieras o técnicas.

Diferenciar robustez funcional de red teaming profundo.

Documentar qué fallos deben bloquear despliegue y cuáles pueden quedar como riesgo aceptado.

Crear conjunto mínimo de pruebas adversarias por prompt crítico.

Realizar ejercicio de hardening de un prompt mediante tests de robustez.

Identificar datos que no deben usarse en pruebas: datos personales reales, secretos, contratos, credenciales o información sensible.

Crear datasets anonimizados, sintéticos o minimizados para pruebas.

Evitar almacenar outputs con información sensible en reportes Markdown o artefactos de CI.

Gestionar API keys en variables de entorno, secrets y herramientas corporativas.

Revisar logs, informes y repositorios para evitar fugas de prompts internos o datos del cliente.

Crear política de retención para reportes de evaluación y datasets.

Evaluar proveedores LLM desde privacidad, seguridad, residencia de datos y uso para entrenamiento.

Aplicar criterios de confidencialidad a prompts que contienen reglas internas, pricing o procesos estratégicos.

Incluir pruebas de no revelación de información no autorizada.

Realizar ejercicio de revisión de seguridad de una suite PromptTest.

Definir métricas útiles: porcentaje de tests superados, fallos críticos, estabilidad, coste, latencia y cobertura.

Diferenciar métricas técnicas de métricas de producto y negocio.

Crear informes comprensibles para desarrollo, QA, producto, dirección y compliance.

Usar reportes Markdown como evidencia de evaluación y soporte de decisiones.

Resumir resultados por prompt, versión, modelo, área funcional y criticidad.

Identificar tendencias: mejora, degradación, inestabilidad o aumento de coste.

Evitar usar una única métrica como garantía de calidad total.

Preparar dashboard o cuadro de seguimiento de calidad de prompts.

Comunicar fallos de forma accionable: input, criterio, output, impacto y recomendación.

Realizar ejercicio de informe ejecutivo de evaluación de prompts.

Revisar tests obsoletos cuando cambia producto, política, tono, modelo o caso de uso.

Eliminar duplicados, criterios contradictorios y ejemplos que ya no representan usuarios reales.

Añadir tests cada vez que se detecta un fallo en producción.

Separar suites por criticidad: smoke, regresión completa, seguridad, RAG, agentes y negocio.

Crear owners de prompts, owners de tests y responsables de aprobación.

Mantener changelog de prompts, criterios, datasets y configuración.

Controlar coste de mantenimiento para que la suite no bloquee la evolución del producto.

Crear calendario de revisión mensual o trimestral según criticidad.

Evitar suites enormes que nadie ejecuta por coste o lentitud.

Realizar ejercicio de refactorización de una suite PromptTest desordenada.

Crear inventario de prompts críticos usados en productos, procesos y automatizaciones.

Clasificar prompts por riesgo: bajo, medio, alto, sensible, regulado o crítico.

Definir política de cambios: quién puede modificar, quién revisa, qué tests pasan y cómo se despliega.

Crear repositorio central de prompts, tests, criterios, datasets y documentación.

Establecer estándares de naming, versionado, estructura, comentarios y reporting.

Integrar testing de prompts con gobierno de IA, seguridad, legal, compliance y producto.

Diseñar aprobaciones específicas para prompts que afectan a clientes, empleados o decisiones sensibles.

Documentar límites conocidos, riesgos aceptados y medidas de mitigación.

Crear modelo operativo de calidad de prompts para equipos empresariales.

Realizar ejercicio de diseño de gobierno de prompts para una organización.

Situar PromptTest dentro del ecosistema de herramientas de evaluación y testing de prompts.

Comparar enfoques CLI simples frente a plataformas completas de evals, observabilidad y experimentación.

Diferenciar PromptTest de promptfoo, DeepEval, LangSmith, Braintrust, OpenAI Evals, PromptBench u otras alternativas.

Evaluar cuándo conviene una herramienta ligera y cuándo una plataforma más integrada.

Diseñar interoperabilidad entre PromptTest, pytest, CI/CD, observabilidad y sistemas internos.

Evitar dependencia de una sola herramienta cuando el equipo necesita varias capas de evaluación.

Crear criterios de selección: coste, ergonomía, equipo, reporting, red teaming, integración y gobierno.

Preparar una estrategia gradual: empezar simple, medir valor y escalar si el proyecto lo exige.

Documentar ventajas y límites de PromptTest para el cliente o equipo interno.

Realizar ejercicio de recomendación de herramienta para distintos escenarios.

Integrar PromptTest en sprints, refinamiento, definición de preparado y definición de terminado.

Convertir historias de usuario en criterios de evaluación de prompts.

Involucrar a producto, UX, soporte y negocio en la creación de casos de prueba.

Revisar resultados de PromptTest durante demos, QA y aprobaciones de release.

Crear flujo de bug report cuando una respuesta LLM falla en producción.

Priorizar mejoras de prompts según impacto de usuario y criticidad de fallo.

Usar tests como documentación viva del comportamiento esperado.

Evitar que el testing de prompts quede aislado como tarea puramente técnica.

Medir calidad por valor de producto, no solo por número de tests pasados.

Realizar ejercicio de incorporación de PromptTest en un equipo Scrum/Kanban.

Seleccionar una aplicación LLM empresarial: chatbot, asistente interno, RAG, extractor, clasificador o agente.

Inventariar prompts existentes, variables, formatos de entrada, salidas esperadas y riesgos funcionales.

Crear estructura de proyecto PromptTest con prompts, tests, datasets, reportes y documentación.

Diseñar prompts testables con secciones, variables, reglas, límites y formatos de salida.

Crear suite YAML con casos normales, casos límite, casos ambiguos y casos adversarios.

Definir criterios de evaluación claros para contenido, tono, formato, seguridad y utilidad.

Ejecutar pruebas desde CLI y analizar resultados en consola e informes Markdown.

Ajustar prompts a partir de fallos reales sin romper comportamientos que ya funcionaban.

Crear tests de regresión para los fallos más importantes detectados durante el proyecto.

Validar outputs estructurados como JSON, tablas Markdown, listas o informes cortos.

Incluir pruebas de privacidad, no invención, no revelación y límites de actuación.

Comparar al menos dos versiones de prompt o dos configuraciones de modelo.

Integrar ejecución de PromptTest en un pipeline CI/CD con reporte como artefacto.

Crear política de versionado de prompts y pull request para cambios futuros.

Diseñar dashboard o resumen ejecutivo con tasa de paso, fallos críticos, coste y recomendaciones.

Preparar documentación de uso para desarrolladores, QA, producto y negocio.

Crear modelo de mantenimiento de la suite: owners, frecuencia, criterios, datasets y escalado.

Presentar la solución final defendiendo cobertura, calidad, riesgos, métricas, CI/CD y gobierno de prompts.