Concepto clave

El desarrollo de un asistente de código con prompts avanzados implica crear un sistema que no solo genera código, sino que entiende contexto, sigue patrones arquitectónicos y mantiene coherencia en proyectos complejos. Piensa en esto como tener un arquitecto de software virtual que no solo te da ladrillos, sino que entiende cómo construir una casa completa, considerando cimientos, estructura y acabados.

En el mundo real, esto se parece a trabajar con un desarrollador senior que conoce tus convenciones de equipo, tus patrones de diseño preferidos y las mejores prácticas de tu stack tecnológico. El asistente debe ir más allá de generar funciones aisladas; debe entender relaciones entre componentes, manejar estados, y mantener consistencia en todo el proyecto.

Cómo funciona en la práctica

Vamos a construir un asistente que ayude a desarrollar una API REST con Node.js y Express. El proceso comienza con un prompt básico y lo refinamos paso a paso:

Prompt inicial: "Genera un endpoint GET para usuarios"
Prompt mejorado: "Como desarrollador full stack, necesito un endpoint GET /api/users que: 1) Use async/await, 2) Incluya validación de JWT token en headers, 3) Implemente paginación con límite de 20 resultados, 4) Retorne formato JSON estándar con status 200, 5) Maneje errores con try-catch y status 500"
Prompt contextual: Agregamos información sobre la base de datos (MongoDB con Mongoose), estructura de modelo existente, y convenciones de nombrado del equipo.

Codigo en accion

Veamos la diferencia entre un prompt básico y uno avanzado:

Antes: Prompt simple

// Prompt: "Crea una función para obtener usuarios"
// Resultado típico:
async function getUsers() {
  const users = await User.find({});
  return users;
}

Después: Prompt avanzado con contexto

// Prompt: "Como desarrollador full stack trabajando en un proyecto Node.js/Express con MongoDB, crea un endpoint GET /api/users que:
// - Use el modelo User de Mongoose ya definido con campos: name, email, role, createdAt
// - Implemente autenticación JWT (token en header Authorization)
// - Incluya paginación: query params 'page' y 'limit' (default 20)
// - Solo admin puede ver todos los usuarios, usuarios normales solo ven su propio perfil
// - Formato de respuesta: { success: true, data: [...], pagination: { page, limit, total } }
// - Manejo de errores con middleware de errores existente"

// Resultado:
const auth = require('../middleware/auth');
const User = require('../models/User');

router.get('/users', auth.verifyToken, auth.checkRole(['admin', 'user']), async (req, res, next) => {
  try {
    const page = parseInt(req.query.page) || 1;
    const limit = parseInt(req.query.limit) || 20;
    const skip = (page - 1) * limit;
    
    let query = {};
    if (req.user.role !== 'admin') {
      query = { _id: req.user.id };
    }
    
    const [users, total] = await Promise.all([
      User.find(query)
        .select('name email role createdAt')
        .skip(skip)
        .limit(limit)
        .sort({ createdAt: -1 }),
      User.countDocuments(query)
    ]);
    
    res.status(200).json({
      success: true,
      data: users,
      pagination: {
        page,
        limit,
        total,
        pages: Math.ceil(total / limit)
      }
    });
  } catch (error) {
    next(error);
  }
});

Errores comunes

Falta de contexto específico: No proporcionar información sobre stack tecnológico, modelos existentes o convenciones del equipo. Solución: Incluir siempre detalles técnicos relevantes en el prompt.
Prompt demasiado general: Pedir "crea una API" sin especificar endpoints, métodos o requisitos. Solución: Desglosar en requisitos específicos y estructurados.
Ignorar seguridad: Olvidar incluir requisitos de autenticación, autorización o validación. Solución: Siempre mencionar aspectos de seguridad en los prompts.
No especificar formato de respuesta: Dejar que el modelo decida el formato, creando inconsistencia. Solución: Definir estructura de respuesta esperada.
Ausencia de manejo de errores: No indicar cómo deben manejarse los casos de error. Solución: Incluir estrategia de manejo de errores en el prompt.

Checklist de dominio

¿Incluyo stack tecnológico completo en el prompt? (Node.js version, framework, base de datos, ORM)
¿Especifico modelos de datos existentes y sus relaciones?
¿Defino requisitos de seguridad (autenticación, autorización, validación)?
¿Establezco formato de respuesta consistente (JSON structure, status codes)?
¿Incluyo manejo de errores y casos límite?
¿Menciono convenciones de código del equipo (nombrado, estructura de archivos)?
¿Proporciono ejemplos de entrada/salida cuando es necesario?

Desarrollo de un asistente de código para sistema de autenticación

Objetivo

Crear un sistema de prompts que genere un módulo completo de autenticación para una aplicación web.

Pasos

Define el contexto: Crea un prompt inicial describiendo la aplicación: Stack MERN (MongoDB, Express, React, Node.js), usuario con campos: username, email, password (hash), role, createdAt.
Especifica endpoints: Diseña prompts para 4 endpoints: registro, login, logout, y verificación de token.
Agrega seguridad: Incluye en los prompts: hashing con bcrypt, JWT tokens, validación de email, rate limiting.
Establece convenciones: Define estructura de carpetas, nombres de funciones, y formato de respuestas JSON.
Implementa y prueba: Usa tu prompt para generar el código, luego crea un test básico que verifique cada endpoint.

Entrega esperada

Colección de prompts optimizados para cada endpoint
Código generado funcional
Documentación breve de cómo usar los prompts

Pistas

Comienza con un prompt maestro que establezca todo el contexto del proyecto
Para cada endpoint, crea un prompt específico que herede del contexto general
Incluye ejemplos de request/response en los prompts complejos

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Práctica: Desarrollo de un asistente de código con prompts avanzados