Jeff Bruchado
Volver al blog

Prompt Engineering Para Desarrolladores en 2026: Guía Práctica

Hola HaWkers, en 2026, saber escribir buenos prompts para herramientas de IA dejó de ser un diferencial y se convirtió en una habilidad básica. La diferencia entre un desarrollador que usa bien la IA y uno que la usa mal puede ser de 3-5x en productividad.

Vamos a explorar técnicas prácticas para que saques el máximo provecho de las herramientas de IA.

Por Qué Importa el Prompt Engineering

El Impacto Real

// La diferencia entre prompts buenos y malos

const promptComparison = {
  badPrompt: {
    input: 'Haz autenticación',
    result: 'Código genérico, probablemente incorrecto',
    iterations: '5-10 hasta que funcione',
    time: '30 minutos'
  },

  goodPrompt: {
    input: `
      Implementa autenticación JWT para la API Express existente.
      - Usa la estructura de middleware en src/middleware/
      - Sigue el patrón de error handling de src/utils/errors.ts
      - Los tokens deben expirar en 24h
      - Refresh tokens en 7 días
      - Almacena refresh tokens en Redis (ya configurado)
    `,
    result: 'Código alineado con el proyecto',
    iterations: '1-2',
    time: '5 minutos'
  },

  productivityGain: '6x más rápido con buenos prompts'
};

Principios Fundamentales

1. Sé Específico

// MALO: vago, deja todo para que la IA decida
const badPrompt1 = "Crea un componente de formulario";

// BUENO: específico sobre lo que necesitas
const goodPrompt1 = `
  Crea un componente React para formulario de registro de usuario.

  Campos:
  - Nombre (obligatorio, mín 2 caracteres)
  - Email (obligatorio, validación de email)
  - Contraseña (obligatorio, mín 8 chars, 1 número, 1 especial)
  - Confirmación de contraseña

  Requisitos:
  - Usa React Hook Form para gestión
  - Validación con Zod
  - Muestra errores inline debajo de cada campo
  - Botón submit deshabilitado mientras sea inválido
  - Muestra loading state durante submit
`;

2. Proporciona Contexto

// MALO: sin contexto del proyecto
const badPrompt2 = "Añade paginación a la lista";

// BUENO: contexto completo
const goodPrompt2 = `
  Añade paginación a la lista de productos en ProductList.tsx.

  Contexto del proyecto:
  - Usamos TanStack Query para data fetching
  - La API retorna: { data: Product[], total: number, page: number }
  - Endpoint: GET /api/products?page=1&limit=20
  - Design system: Tailwind + componentes en src/components/ui/

  Comportamiento esperado:
  - 20 elementos por página
  - Mostrar "Página X de Y"
  - Botones Anterior/Siguiente
  - Deshabilitar botones en los límites
  - Mantener scroll position al cambiar página
`;

3. Muestra Ejemplos

// MALO: espera que la IA adivine el patrón
const badPrompt3 = "Crea un hook para API";

// BUENO: muestra patrón existente
const goodPrompt3 = `
  Crea un hook useProducts siguiendo el patrón existente.

  Ejemplo de hook existente (useUsers.ts):
  \`\`\`typescript
  export function useUsers(filters: UserFilters) {
    return useQuery({
      queryKey: ['users', filters],
      queryFn: () => api.users.list(filters),
      staleTime: 5 * 60 * 1000,
    });
  }

  export function useUser(id: string) {
    return useQuery({
      queryKey: ['user', id],
      queryFn: () => api.users.get(id),
      enabled: !!id,
    });
  }

  export function useCreateUser() {
    const queryClient = useQueryClient();
    return useMutation({
      mutationFn: api.users.create,
      onSuccess: () => {
        queryClient.invalidateQueries({ queryKey: ['users'] });
      },
    });
  }
  \`\`\`

  Crea hooks equivalentes para Products con:
  - useProducts(filters)
  - useProduct(id)
  - useCreateProduct()
  - useUpdateProduct()
  - useDeleteProduct()
`;

Técnicas Avanzadas

Chain of Thought

// Pide a la IA que piense paso a paso

const chainOfThoughtPrompt = `
  Necesito optimizar esta query SQL que está lenta.

  Query actual:
  \`\`\`sql
  SELECT * FROM orders o
  JOIN users u ON o.user_id = u.id
  JOIN products p ON o.product_id = p.id
  WHERE o.created_at > '2025-01-01'
  ORDER BY o.created_at DESC
  \`\`\`

  Tablas:
  - orders: 10M filas
  - users: 500K filas
  - products: 50K filas

  Por favor:
  1. Primero, analiza por qué la query puede estar lenta
  2. Lista posibles problemas (índices, joins, select *)
  3. Sugiere optimizaciones en orden de impacto
  4. Proporciona la query optimizada final
  5. Explica qué índices crear
`;

// La IA pensará de forma estructurada, no solo adivinará una respuesta

Few-Shot Learning

// Muestra ejemplos de lo que quieres

const fewShotPrompt = `
  Convierte estos tests Jest a Vitest.

  Ejemplo de conversión:

  Jest:
  \`\`\`typescript
  import { render, screen } from '@testing-library/react';

  describe('Button', () => {
    it('renders correctly', () => {
      render(<Button>Click me</Button>);
      expect(screen.getByRole('button')).toHaveTextContent('Click me');
    });

    it('calls onClick when clicked', () => {
      const handleClick = jest.fn();
      render(<Button onClick={handleClick}>Click</Button>);
      screen.getByRole('button').click();
      expect(handleClick).toHaveBeenCalledTimes(1);
    });
  });
  \`\`\`

  Vitest:
  \`\`\`typescript
  import { render, screen } from '@testing-library/react';
  import { describe, it, expect, vi } from 'vitest';

  describe('Button', () => {
    it('renders correctly', () => {
      render(<Button>Click me</Button>);
      expect(screen.getByRole('button')).toHaveTextContent('Click me');
    });

    it('calls onClick when clicked', () => {
      const handleClick = vi.fn();
      render(<Button onClick={handleClick}>Click</Button>);
      screen.getByRole('button').click();
      expect(handleClick).toHaveBeenCalledTimes(1);
    });
  });
  \`\`\`

  Ahora convierte estos tests: [pegar tests]
`;

Constraints (Restricciones)

// Define límites claros

const constraintsPrompt = `
  Refactoriza la función processOrder para mejor legibilidad.

  Restricciones:
  - NO cambies la firma de la función
  - NO añadas dependencias externas
  - NO cambies el comportamiento (los tests deben seguir pasando)
  - MANTÉN compatibilidad con Node 18
  - MÁXIMO 50 líneas de código

  Foco:
  - Extraer funciones auxiliares si es necesario
  - Nombres de variables más claros
  - Eliminar código duplicado
  - Añadir early returns donde tenga sentido
`;

Prompts Por Situación

Debug

const debugPrompt = `
  Estoy recibiendo este error y necesito ayuda para debugear.

  Error:
  \`\`\`
  TypeError: Cannot read properties of undefined (reading 'map')
    at ProductList (ProductList.tsx:25:18)
    at renderWithHooks (react-dom.development.js:14985:18)
  \`\`\`

  Código relevante:
  \`\`\`typescript
  // ProductList.tsx
  function ProductList({ categoryId }: Props) {
    const { data } = useProducts(categoryId);

    return (
      <ul>
        {data.products.map(p => (  // línea 25
          <li key={p.id}>{p.name}</li>
        ))}
      </ul>
    );
  }
  \`\`\`

  Lo que ya verifiqué:
  - La API está retornando datos correctamente (testeé en Postman)
  - categoryId está definido (lo logueé y confirmé)

  ¿Qué puede estar causando esto y cómo corregirlo?
`;

Code Review

const codeReviewPrompt = `
  Haz code review de este PR enfocándote en:
  1. Bugs potenciales
  2. Problemas de seguridad
  3. Performance
  4. Legibilidad
  5. Adherencia a los patrones del proyecto

  Patrones del proyecto:
  - Usamos early returns
  - Los errores se manejan con try/catch en boundaries
  - Validación de input con Zod
  - Tipos explícitos (sin 'any')

  Código para review:
  \`\`\`typescript
  [pegar código]
  \`\`\`

  Para cada problema encontrado, indica:
  - Severidad (crítico/alto/medio/bajo)
  - Línea del código
  - Explicación del problema
  - Sugerencia de corrección
`;

Arquitectura

const architecturePrompt = `
  Necesito decidir la arquitectura para un nuevo sistema de notificaciones.

  Requisitos:
  - 100K usuarios activos
  - Notificaciones push, email e in-app
  - Prioridades diferentes (urgente, normal, baja)
  - Retry automático para fallos
  - Analytics de entrega

  Stack actual:
  - Node.js/Express
  - PostgreSQL
  - Redis
  - AWS (podemos usar más servicios)

  Por favor:
  1. Sugiere 2-3 enfoques arquitectónicos
  2. Lista pros y contras de cada uno
  3. Recomienda uno con justificación
  4. Esboza el diagrama de componentes
  5. Lista riesgos y mitigaciones
`;

Prompts Para Herramientas Específicas

GitHub Copilot

// Copilot funciona mejor con comentarios estructurados

// Función: Valida CPF brasileño
// Input: string con o sin formato
// Output: boolean indicando si es válido
// Reglas: Verifica dígitos verificadores
function validateCPF(cpf: string): boolean {
  // Copilot completará basándose en el comentario
}

// Para Copilot Chat
// Usa @ para referenciar archivos
// @workspace /explain ¿cómo funciona la autenticación?
// @terminal ¿qué comando para correr tests?

Cursor

// Cursor funciona bien con Composer (Ctrl+I)

/*
Prompt para Composer:

Refactoriza el sistema de cache en src/cache/ para:
1. Usar Redis en vez de memory cache
2. Mantener interfaz existente (no romper consumers)
3. Añadir TTL configurable
4. Añadir métricas de hit/miss
5. Implementar cache invalidation por patrón

Archivos a modificar:
- src/cache/index.ts
- src/cache/providers/memory.ts → redis.ts
- src/config/cache.ts (crear)

No modifiques los tests aún, lo haré después.
*/

Claude (API/Console)

// Claude es bueno para razonamiento complejo

const claudePrompt = `
  <context>
  Soy tech lead de un equipo de 5 personas.
  Tenemos un monolito Node.js con 200K líneas de código.
  El rendimiento está degradando y necesitamos decidir el camino.
  </context>

  <question>
  ¿Debemos migrar a microservicios u optimizar el monolito?
  </question>

  <constraints>
  - Equipo pequeño (5 devs)
  - Budget limitado para infra
  - No podemos parar features por más de 1 sprint
  - Necesitamos resultado en 6 meses
  </constraints>

  Por favor analiza ambas opciones considerando nuestro contexto
  específico, no genérico. Incluye:
  - Riesgos reales para nuestro escenario
  - Esfuerzo estimado (en sprints)
  - Impacto en productividad durante migración
  - Recomendación final con justificación
`;

Anti-Patterns

Lo Que NO Hacer

// Errores comunes en prompts

const antiPatterns = {
  vague: {
    bad: "Mejora este código",
    why: "La IA no sabe qué significa 'mejor' para ti",
    fix: "Especifica: ¿legibilidad? ¿performance? ¿seguridad?"
  },

  noContext: {
    bad: "Añade validación",
    why: "¿Validación de qué? ¿Dónde? ¿Con qué lib?",
    fix: "Da contexto del proyecto y requisitos específicos"
  },

  tooLong: {
    bad: "[5 páginas de requisitos]",
    why: "La IA pierde foco en prompts muy largos",
    fix: "Divide en tareas más pequeñas y específicas"
  },

  assuming: {
    bad: "Usa el patrón normal",
    why: "La IA no sabe cuál es 'tu' patrón",
    fix: "Muestra un ejemplo del patrón que usas"
  },

  noExamples: {
    bad: "Convierte a nuestro estilo",
    why: "La IA no conoce tu estilo",
    fix: "Incluye ejemplo de código en el estilo deseado"
  }
};

Iteración Eficiente

// Cómo iterar cuando el resultado no es bueno

const iterationStrategy = {
  step1: {
    action: 'No descartes, refina',
    example: `
      Buen comienzo, pero:
      - El error handling está muy verboso
      - Prefiero early returns a else anidados
      - Añade tipos explícitos en los parámetros

      Ajusta manteniendo la lógica general.
    `
  },

  step2: {
    action: 'Sé específico sobre el problema',
    example: `
      La función validateEmail tiene un bug:
      - Acepta "test@" como válido (no debería)
      - No acepta "test+tag@gmail.com" (debería)

      Corrige solo la regex, mantén el resto.
    `
  },

  step3: {
    action: 'Pide explicación si no entiendes',
    example: `
      ¿Por qué usaste reduce aquí en vez de map + filter?
      ¿Cuál es la ventaja de performance o legibilidad?
    `
  }
};

Construyendo Prompts Reutilizables

Templates

// Crea templates para tareas comunes

const promptTemplates = {
  newComponent: `
    Crea un componente React [NOMBRE] con:

    Props:
    [LISTA DE PROPS]

    Comportamiento:
    [DESCRIPCIÓN]

    Estilo:
    - Usa Tailwind
    - Sigue los patrones de src/components/ui/

    Tests:
    - Incluye tests básicos de renderización
    - Testea interacciones principales
  `,

  apiEndpoint: `
    Crea endpoint [MÉTODO] [RUTA] que:

    Request:
    [BODY/PARAMS]

    Response:
    [FORMATO]

    Validación:
    - Usa Zod para validar input
    - Retorna errores en el formato estándar

    Seguridad:
    - [¿AUTENTICACIÓN NECESARIA?]
    - [¿RATE LIMITING?]
  `,

  bugFix: `
    Bug: [DESCRIPCIÓN]

    Cómo reproducir:
    [PASOS]

    Comportamiento esperado:
    [LO QUE DEBERÍA SUCEDER]

    Comportamiento actual:
    [LO QUE ESTÁ SUCEDIENDO]

    Código relevante:
    \`\`\`
    [CÓDIGO]
    \`\`\`

    Encuentra la causa raíz y sugiere corrección.
  `
};

Conclusión

El prompt engineering en 2026 no se trata de "hackear" la IA - se trata de comunicación clara. Los mismos principios que te hacen un buen comunicador con humanos (claridad, contexto, ejemplos) te hacen eficiente con la IA.

Resumen de las mejores prácticas:

  1. Sé específico: Di exactamente lo que quieres
  2. Da contexto: Proyecto, patrones, constraints
  3. Muestra ejemplos: Del estilo que quieres
  4. Itera: Refina en vez de empezar de nuevo
  5. Cuestiona: Entiende el "por qué" de las respuestas

La IA es una herramienta poderosa, pero la calidad del output depende de la calidad del input. Invierte tiempo aprendiendo a comunicarte bien con ella.

Para entender más sobre el impacto de la IA en el desarrollo, lee: Agentes de IA en 2026.

¡Vamos con todo! 🦅

Comentarios (0)

Este artículo aún no tiene comentarios 😢. ¡Sé el primero! 🚀🦅

Añadir comentarios