Prompting efectivo para programadores: guia práctica

Por qué importa el prompting para desarrolladores?

La diferencia entre un prompt mediocre y uno excelente puede ser la diferencia entre código que funciona a medias y código de producción. Como desarrolladores, tenemos una ventaja: pensamos de forma estructurada y podemos aplicar esa habilidad al prompting.

Este articulo te ensenara técnicas especificas de prompting optimizadas para tareas de programación.

Principios fundamentales

1. Se específico con el contexto

Los modelos de lenguaje no pueden leer tu mente. Cuanto más contexto proporciones, mejor será el resultado.

Prompt debil:

Crea un formulario de login

Prompt fuerte:

Crea un componente Angular standalone de login con reactive forms. Debe tener campos de email y password con validaciones (email válido, password mínimo 8 caracteres). Usa signals para el estado de loading. Implementa OnPush change detection. El formulario debe mostrar mensajes de error inline debajo de cada campo.

2. Define las restricciones

Especificar que NO quieres es tan importante como especificar que quieres.

Requisitos:
- TypeScript estricto, sin 'any'
- Sin dependencias externas
- Compatible con Node.js 20+
- Manejo de errores completo

Restricciones:
- NO uses clases, solo funciones
- NO uses callbacks, solo async/await
- NO uses console.log en producción

3. Proporciona ejemplos (Few-shot)

Mostrar el patrón que esperas es más efectivo que describir el patrón.

Tecnicas avanzadas

Chain of Thought (Cadena de pensamiento)

Pide al modelo que razone paso a paso antes de generar código:

Necesito una función que determine si un string es un palindromo.

Antes de escribir el código:
1. Define que es un palindromo
2. Considera edge cases (espacios, mayusculas, caracteres especiales)
3. Evalua diferentes enfoques y su complejidad
4. Elige el mejor enfoque

Luego implementa la función en TypeScript.

Esta técnica es especialmente útil para problemas algoritmicos y decisiones de arquitectura.

Role prompting

Asignar un rol específico al modelo mejora significativamente la calidad:

Actua como un ingeniero senior de software con 10 años de experiencia
en Angular y TypeScript. Tu prioridad es código mantenible,
con tipos estrictos y tests. Prefieres composicion sobre herencia
y funciones puras sobre efectos secundarios.

Prompt incremental (Iterativo)

Para tareas complejas, construye la solucion en pasos:

1. Paso 1: Define la interfaz/tipos
2. Paso 2: Implementa la lógica core
3. Paso 3: Agrega manejo de errores
4. Paso 4: Agrega tests
5. Paso 5: Optimiza y refactoriza

Template de prompt para code review

Revisa el siguiente código considerando:

1. **Bugs**: Errores logicos o runtime errors potenciales
2. **Seguridad**: Vulnerabilidades (XSS, injection, etc.)
3. **Performance**: Operaciones costosas o innecesarias
4. **Tipos**: Uso correcto del sistema de tipos de TypeScript
5. **Legibilidad**: Nombres, estructura, comentarios

Formato de respuesta:
- Severidad: CRITICO | ALTO | MEDIO | BAJO
- Linea(s) afectada(s)
- Descripcion del problema
- Sugerencia de fix con código

[Pega tu código aquí]

Prompts para tareas comunes de desarrollo

Generar interfaces TypeScript

A partir de esta respuesta JSON de API:
[pegar JSON]

Genera interfaces TypeScript que:
- Usen tipos estrictos (no any)
- Manejen campos opcionales correctamente
- Incluyan JSDoc con descripción de cada campo
- Usen nombres descriptivos en PascalCase

Refactorizar código legacy

Refactoriza este código Angular de la versión antigua a la moderna:

Requisitos:
- Migrar de NgModules a standalone components
- Migrar de constructor injection a inject()
- Migrar de decorators (@Input/@Output) a input()/output()
- Migrar de BehaviorSubject a signals
- Migrar de *ngIf/*ngFor a @if/@for

Mantener la misma funcionalidad. Explicar cada cambio.

[Pegar código]

Escribir documentación

Genera documentación técnica para esta función/clase:

Incluye:
1. Descripcion general (1-2 oraciones)
2. Parametros con tipos y descripción
3. Valor de retorno
4. Ejemplo de uso básico
5. Ejemplo con edge cases
6. Throws/errores posibles

Formato: TSDoc compatible

[Pegar código]

Antipatrones: lo que NO debes hacer

1. Prompts vagos

Evita: "Haz un CRUD". No específica tecnologia, estructura, validaciones ni manejo de errores.

2. Pedir todo de golpe

Un prompt de 50 requisitos producira resultados mediocres. Divide en pasos.

3. No validar el output

Siempre revisa y prueba el código generado. Los modelos pueden generar código que se ve correcto pero tiene bugs sutiles.

4. Copiar sin entender

Si no entiendes el código generado, no lo uses. Pide explicaciones.

Construyendo un system prompt para tu equipo

Un system prompt bien disenado puede estandarizar la calidad del código generado para todo tu equipo.

Elementos clave

• Stack tecnologico: Versiones especificas de frameworks y librerias
• Convenciones de código: Naming, estructura de archivos, patrones
• Restricciones: Lo que NO se debe usar
• Formato de respuesta: Estructura esperada del output

Conclusion

El prompting efectivo para programadores se reduce a tres cosas: contexto claro, restricciones explicitas y ejemplos concretos. Invierte tiempo en construir buenos prompts y templates reutilizables para tu equipo.

La IA es tan buena como las instrucciones que le das. Un desarrollador que domina el prompting multiplica su productividad de forma significativa.

// System prompt para un asistente de código
const systemPrompt = `Eres un asistente experto en TypeScript y Angular.

Reglas:
1. Usa strict typing, nunca uses 'any'
2. Prefiere signals sobre BehaviorSubject
3. Usa standalone components
4. Implementa OnPush change detection
5. Sigue el principio de responsabilidad única

Formato de respuesta:
- Primero explica el enfoque brevemente
- Luego muestra el código
- Finalmente lista consideraciones importantes`;

const response = await fetch('https://api.anthropic.com/v1/messages', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'x-api-key': process.env.ANTHROPIC_API_KEY ?? '',
    'anthropic-versión': '2023-06-01'
  },
  body: JSON.stringify({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2048,
    system: systemPrompt,
    messages: [{
      role: 'user',
      content: 'Crea un servicio de autenticación con Google OAuth'
    }]
  })
});

# Few-shot prompting para generar tests

Genera tests unitarios siguiendo este patrón:

## Ejemplo 1:
Función: `function add(a: number, b: number): number`
Test:
```typescript
describe('add', () => {
  it('should add two positive numbers', () => {
    expect(add(2, 3)).toBe(5);
  });
  it('should handle negative numbers', () => {
    expect(add(-1, 1)).toBe(0);
  });
  it('should handle zero', () => {
    expect(add(0, 5)).toBe(5);
  });
});
```

## Ahora genera tests para:
Función: `function divide(a: number, b: number): number`