10. Prompting para programadores

Las IAs pueden generar código, encontrar bugs, explicar conceptos complejos y refactorizar. La calidad del código que obtienes depende de cómo formules tus prompts.

Principios específicos para código

1. Especifica lenguaje y versión:

Crea una función en Python 3.11 que ordene un array de números enteros. Usa type hints y docstrings según PEP 257.

2. Menciona el contexto del proyecto:

Estoy trabajando en una API REST con FastAPI. Necesito añadir validación de email a mi modelo Pydantic de usuario. El email debe ser único en la base de datos. Usa validators de Pydantic y maneja el error apropiadamente.

3. Especifica restricciones:

Las IAs necesitan saber bibliotecas permitidas, restricciones de rendimiento, estándares de código del equipo y compatibilidad requerida.

Generar código desde cero

Ejemplo básico: función simple

Prompt débil:

Haz una función de Fibonacci.

Prompt profesional:

Crea una función en Python que calcule el n-ésimo número de Fibonacci.

Requisitos:

• Usa memoización para optimizar rendimiento
• Incluye type hints (Python 3.10+)
• Añade docstring con ejemplos de uso
• Maneja casos edge (n=0, n=1, n negativo)
• Si n es negativo, lanza ValueError

Formato:

• Nombre: fibonacci
• Parámetro: n (int)
• Retorno: int

Ejemplo esperado: fibonacci(10) -> 55

Ejemplo avanzado: clase completa

Crea una clase Stack (pila) en TypeScript con las siguientes especificaciones:

Requisitos funcionales:

• Métodos: push, pop, peek, isEmpty, size
• Debe ser genérica (soportar cualquier tipo)
• push: añade elemento al tope
• pop: remueve y retorna elemento del tope (lanza error si está vacía)
• peek: retorna elemento del tope sin removerlo
• isEmpty: retorna boolean
• size: retorna número de elementos

Requisitos técnicos:

• Usa array privado interno
• Implementa con TypeScript strict mode
• Todos los métodos deben tener tipos explícitos
• Añade JSDoc comments a cada método
• Incluye ejemplo de uso al final comentado

Manejo de errores:

• pop en pila vacía: lanzar Error con mensaje "Stack is empty"
• peek en pila vacía: lanzar Error con mensaje "Stack is empty"

Depuración

Prompt efectivo:

Tengo un bug en este código Python:

<codigo> import csv

def process_csv(filename): with open(filename) as f: reader = csv.reader(f) for row in reader: print(row[3]) </codigo>

<error> IndexError: list index out of range </error>

Contexto:

• Algunos CSV tienen 3 columnas, otros 5
• Necesito procesar solo la columna 4 cuando existe
• Python 3.10

Proporciona:

1. <diagnostico>Explicación del error</diagnostico>
2. <solucion>Código corregido</solucion>
3. <mejoras>Sugerencias para hacerlo más robusto</mejoras>

Explicar código

Explica este código paso a paso. Soy desarrollador junior.

<codigo> const debounce = (func, delay) => { let timeoutId; return (...args) => { clearTimeout(timeoutId); timeoutId = setTimeout(() => func(...args), delay); }; }; </codigo>

Necesito:

1. Explicación línea por línea
2. Qué problema resuelve (debouncing)
3. Ejemplo de uso práctico
4. Por qué se usan closures

Usa lenguaje simple, evita jerga innecesaria.

Refactorización

Refactorizar para mejor estructura:

Refactoriza este código JavaScript siguiendo principios SOLID y clean code:

<codigo> function processUser(user) { if (user.age >= 18) { if (user.country === "ES") { if (user.hasLicense) { console.log("Can rent car"); return true; } } } console.log("Cannot rent car"); return false; } </codigo>

Objetivos:

• Reducir niveles de anidación
• Mejorar legibilidad
• Hacer código más mantenible
• Early returns cuando sea apropiado
• Añadir constantes para valores mágicos

Proporciona: <refactorizado>Código mejorado</refactorizado> <explicacion>Cambios realizados y por qué mejoran el código</explicacion>

Modernizar código legacy:

Tengo código JavaScript ES5 que necesita actualizarse a ES6+:

<codigo> var calculateTotal = function(items) { var total = 0; for (var i = 0; i < items.length; i++) { total += items[i].price; } return total; }; </codigo>

Moderniza usando:

• const/let en lugar de var
• Arrow functions
• Métodos de array modernos (map, reduce, filter, etc.)
• Template literals si aplica

Incluye comentario breve explicando qué características modernas usaste.

Escribir tests

Generar tests unitarios:

Necesito tests unitarios completos para esta función:

<codigo> function divide(a, b) { if (b === 0) { throw new Error("Division by zero"); } return a / b; } </codigo>

Framework: Jest Lenguaje: JavaScript

Genera tests que cubran:

• Casos normales (división válida)
• División por cero (debe lanzar error)
• Números negativos
• División que resulta en decimal
• Edge cases (0/5, números muy grandes)

Incluye:

• describe block apropiado
• test cases con nombres descriptivos
• expects apropiados
• Comentarios explicando qué prueba cada test

Tests de integración:

Tengo esta función que llama a una API externa:

<codigo> async function fetchUserData(userId) { const response = await fetch(https://api.example.com/users/${userId}); if (!response.ok) { throw new Error(HTTP error! status: ${response.status}); } return await response.json(); } </codigo>

Framework: Jest con node-fetch Lenguaje: JavaScript/Node.js

Genera tests que:

• Mockeen la llamada fetch
• Prueben respuesta exitosa (200)
• Prueben error 404
• Prueben error 500
• Verifiquen que se parsea JSON correctamente

Incluye:

• Setup de mocks con jest.mock()
• beforeEach para reset de mocks si necesario
• Tests completos y descriptivos

Code review

Pide a la IA que revise tu código antes de enviarlo a revisión humana.

Prompt para revisión de código:

Actúa como senior developer haciendo code review.

Revisa este código con ojo crítico:

<codigo> class UserService: def init(self): self.users = []

def add_user(self, name, email, age):
    user = {
        "name": name,
        "email": email,
        "age": age
    }
    self.users.append(user)
    return user

def get_user_by_email(self, email):
    for user in self.users:
        if user["email"] == email:
            return user

</codigo>

Lenguaje: Python 3.11 Contexto: Aplicación web Flask, será usada en producción

Revisa:

1. Posibles bugs o edge cases no manejados
2. Problemas de seguridad
3. Mejoras de rendimiento
4. Mejores prácticas de Python no seguidas
5. Sugerencias de diseño (OOP, SOLID, etc.)

Formato: <problemas> [Lista de problemas encontrados, priorizados por severidad] </problemas>

<codigo_mejorado> [Versión mejorada del código] </codigo_mejorado>

<explicacion> [Explicación de cada cambio] </explicacion>

Mejores prácticas específicas

1. Siempre especifica el entorno:

Framework: React 18 con TypeScript 5.0 Estado: Redux Toolkit Estilo: Tailwind CSS

Crea un componente de formulario...

Proporciona código relacionado:

Tengo estos tipos TypeScript:

<tipos> interface User { id: string; name: string; role: "admin" | "user"; } </tipos>

Necesito crear una función que filtre usuarios por rol...

3. Especifica el nivel de optimización:

Genera una función de búsqueda binaria en Python.

Prioridad: Claridad del código > Performance extrema Audiencia: Desarrolladores junior que están aprendiendo

Incluye:

• Comentarios explicativos abundantes
• Nombres de variables descriptivos
• No optimizaciones prematuras que dificulten lectura

O alternativamente:

Genera una función de búsqueda binaria en Python.

Prioridad: Máximo rendimiento Contexto: Procesará millones de registros

Optimiza para:

• Mínimas operaciones
• Uso eficiente de memoria
• Puedes sacrificar legibilidad por performance

4. Pide alternativas cuando existan:

Necesito ordenar un array de objetos por fecha en JavaScript.

Proporciona 2 enfoques diferentes:

1. Usando sort() nativo
2. Usando una biblioteca (date-fns o similar)

Para cada uno incluye:

• Código
• Pros y contras
• Cuándo usar cada enfoque

Casos de uso avanzados

Generar regex complejas:

Necesito una expresión regular en JavaScript para validar contraseñas.

Requisitos:

• Mínimo 8 caracteres
• Al menos una mayúscula
• Al menos una minúscula
• Al menos un número
• Al menos un carácter especial (@$!%*?&)
• No espacios

Proporciona:

1. La regex
2. Explicación de cada parte de la regex
3. Función de validación completa con ejemplos
4. Tests con casos válidos e inválidos

Optimización de consultas:

Tengo esta consulta SQL que es muy lenta:

<sql> SELECT u.name, COUNT(o.id) as order_count FROM users u LEFT JOIN orders o ON u.id = o.user_id WHERE u.created_at > '2024-01-01' GROUP BY u.id ORDER BY order_count DESC; </sql>

Base de datos: PostgreSQL 15 Tabla users: 1 millón de registros Tabla orders: 5 millones de registros

La consulta tarda 8 segundos. Necesito optimizarla.

Proporciona:

1. Análisis del problema de rendimiento
2. Versión optimizada de la consulta
3. Índices recomendados con comandos CREATE INDEX
4. Explicación de por qué cada cambio mejora el rendimiento

Valida siempre el código

Nunca confíes ciegamente en código generado por IA. Siempre:

• Revísalo línea por línea
• Ejecútalo en entorno de prueba
• Verifica edge cases
• Asegúrate que sigue estándares de tu proyecto
• Comprueba vulnerabilidades de seguridad

Las IAs son asistentes poderosos para desarrollo, pero son asistentes, no reemplazos del pensamiento crítico de un programador.

Aplicar prompting al desarrollo de software requiere especificaciones técnicas claras: lenguaje, versión, contexto del proyecto, restricciones y estándares de código. Con prompts bien construidos, puedes generar código, depurar, refactorizar y escribir tests con calidad profesional.

Has dominado las técnicas fundamentales y visto su aplicación al código. Para cerrar el curso, en la siguiente lección verás casos prácticos del mundo real: desde redactar correos delicados hasta analizar datos y crear contenido, consolidando todo lo aprendido en situaciones concretas.