Prompting efectivo: por qué 'eres un senior developer' no funciona y qué sí lo hace

El síndrome del prompt elaborado

Tu deadline se acerca. Decides ser estratégico con la IA y escribes un prompt "profesional":

"Actúa como un desarrollador frontend senior con 15 años de experiencia, especializado en JavaScript, TypeScript, React, Vue, con conocimientos profundos en arquitectura de software, metodologías ágiles, y experiencia liderando equipos y aniquilando la maldad del mundo… Por favor, necesito una función para validar emails."

Resultado después de 50 tokens de setup:

function validateEmail(email) {
  const re = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  return re.test(email);
}

Exactamente el mismo código que con "crea función para validar emails".

Los dos problemas del prompting inefectivo

Problema 1: Role prompting innecesario

Role prompting es asignar roles específicos a la IA. Útil en algunos contextos, contraproducente cuando sustituye información técnica real.

Los prompts elaborados con roles cometen errores fundamentales:

• Desperdician tokens: Tu context window es limitado. Cada token en "eres un experto en..." es un token no usado en examples útiles.
• No añaden especificidad técnica: "15 años de experiencia" no le dice qué patterns usar o cómo integrar con tu proyecto.
• Crean expectativas falsas: La IA responde por patterns estadísticos, no por curriculum inventado.

Problema 2: Ausencia de context injection

Context injection es proporcionar información específica de tu proyecto: patrones, convenciones, y requirements técnicos.

Sin context injection, obtienes código genérico que no pertenece a tu proyecto:

// Prompt: "Crea validador de email"
function validateEmail(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

Problemas:

• No sigue convenciones del proyecto.
• No maneja errores como tu código.
• No se integra con patterns establecidos.
• Requiere adaptación manual.

Context injection: la técnica que funciona

En lugar de roles elaborados, proporciona contexto específico:

// Prompt con context injection:
"Crea validador de email siguiendo nuestro patrón:

const validateName = (name) => ({
  isValid: name.length >= 2,
  error: name.length < 2 ? 'El nombre debe tener al menos 2 caracteres' : null
});

Debe rechazar dominios temporales como tempmail.com."

// Resultado integrado:
const validateEmail = (email) => {
  const prohibitedDomains = ['tempmail.com', '10minutemail.com'];
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  if (!email || typeof email !== 'string') {
    return {
      isValid: false,
      error: 'El email es obligatorio'
    };
  }

  if (!emailRegex.test(email)) {
    return {
      isValid: false,
      error: 'Formato de email inválido'
    };
  }

  const domain = email.split('@')[1]?.toLowerCase();
  if (prohibitedDomains.includes(domain)) {
    return {
      isValid: false,
      error: 'No se permiten emails temporales'
    };
  }

  return {
    isValid: true,
    error: null
  };
};

Comparación directa: role vs context

Role prompting (inefectivo):

"Eres un arquitecto de software senior con experiencia en sistemas distribuidos
y microservicios. Crea una clase para manejar peticiones HTTP."

Resultado: Clase genérica que no encaja en ningún proyecto.

Context injection (efectivo):

"Crea HTTP client siguiendo nuestro patrón:

class AuthService {
  constructor(baseURL) {
    this.baseURL = baseURL;
    this.headers = { 'Content-Type': 'application/json' };
  }

  async request(endpoint, options = {}) {
    // implementation
  }
}

Necesito ApiService similar con retry logic."

Resultado: Código que se integra perfectamente con tu arquitectura.

Cuándo usar cada estrategia

Role prompting es útil para:

• Creative tasks: "Actúa como copywriter y mejora este texto".
• Analysis tasks: "Como code reviewer, evalúa este código".
• Perspective tasks: "Desde la perspectiva del usuario, ¿qué falta?".

Context injection es esencial para:

• Code generation: Cualquier código que debe integrarse con tu proyecto.
• Technical tasks: Funciones, clases, módulos que siguen tus patterns.
• Consistency: Cuando necesitas coherencia con tu codebase.

Tipos de context injection

Pattern Context

Mostrar examples de código existente:

"Crea error handler siguiendo este patrón:
try {
  const result = await operation();
  return { success: true, data: result, error: null };
} catch (err) {
  return { success: false, data: null, error: err.message };
}

Necesito similar para user authentication."

Technical Context

Especificar constraints específicos:

"Crea debounce function:
- JavaScript vanilla ES2022
- Sin dependencias externas
- Cleanup automático
- Máximo 15 líneas"

Integration Context

Explicar integración con sistemas existentes:

"Crea cache module que use nuestro logging:
Logger.debug('Cache', 'Key accessed', { key });

Y nuestro config:
const ttl = Config.get('cache.ttl', 300);"

Errores comunes

Context overload

// Información irrelevante
"Trabajo en startup fintech con 50 empleados, usamos agile, AWS, PostgreSQL..."

// Contexto específico
"Formatea fechas usando nuestro patrón:
export const formatCurrency = (amount) => new Intl.NumberFormat('es-ES').format(amount);"

Role elaborate sin propósito

// Role sin beneficio
"Eres un ninja coding rockstar, crea función..."

// Reequerimiento directo
"Crea función optimizada para 10k+ items sin bloquear main thread."

El ROI de prompting efectivo

Role prompting elaborate:

• Tokens desperdiciados en setup.
• Código genérico que necesitas adaptar.
• No garantiza integración.

Context injection:

• Tokens invertidos en información útil.
• Código que encaja inmediatamente.
• Consistency automática.

La inversión: 30 segundos de context real.

El retorno: Horas ahorradas en adaptación.

Takeaways

• Role prompting elaborate desperdicia tokens sin añadir especificidad técnica
• Context injection supera a personalities inventadas
• Mostrar patterns es más efectivo que describir roles
• 30 segundos de context específico > 3 párrafos de background
• La IA necesita información, no inspiración