Hace unos años, muchos investigadores de IA (incluso los más reputados) predecían que el prompt engineering sería una habilidad temporal que desaparecería rápidamente. Se equivocaron completamente. No solo no ha desaparecido, sino que ha evolucionado hacia algo mucho más sofisticado: Context Engineering.
Y no, no es solo otro término de moda. Es una evolución natural que refleja la complejidad real de trabajar con LLMs en aplicaciones productivas.
De prompt engineering a context engineering
El problema con el término “prompt engineering” es que mucha gente lo confunde con blind prompting - simplemente escribir una pregunta en ChatGPT y esperar un resultado. Eso no es ingeniería, es usar una herramienta.
Context Engineering abarca todo el proceso de arquitectura del contexto que un LLM necesita para funcionar efectivamente. No es solo escribir un prompt; es diseñar un sistema completo de información contextual.
Qué incluye Context Engineering
Según la definición que más me convence, context engineering abarca:
- Diseño de cadenas de prompts para flujos complejos
- Optimización de instrucciones y system prompts
- Gestión de elementos dinámicos (inputs del usuario, fecha/hora, estado)
- Búsqueda y preparación de conocimiento relevante (RAG)
- Definición de herramientas y sus instrucciones
- Estructuración de inputs y outputs (delimitadores, esquemas JSON)
- Gestión de memoria a corto y largo plazo
- Optimización del contexto para eliminar información irrelevante
En resumen: optimizar toda la información que proporcionas en la ventana de contexto del LLM.
Un ejemplo práctico: Agente de investigación
Me ha llamado la atención este ejemplo práctico de Elvis Saravia sobre un agente de investigación. Vamos a desglosarlo para entender los principios clave.
El agente planificador
El sistema incluye un “Search Planner” que descompone consultas complejas en subtareas de búsqueda. Aquí está el system prompt:
You are an expert research planner. Your task is to break down a complex research query (delimited by <user_query></user_query>) into specific search subtasks, each focusing on a different aspect or source type.
The current date and time is: {{ $now.toISO() }}
For each subtask, provide:
1. A unique string ID for the subtask (e.g., 'subtask_1', 'news_update')
2. A specific search query that focuses on one aspect of the main query
3. The source type to search (web, news, academic, specialized)
4. Time period relevance (today, last week, recent, past_year, all_time)
5. Domain focus if applicable (technology, science, health, etc.)
6. Priority level (1-highest to 5-lowest)
Create 2 subtasks that together will provide comprehensive coverage of the topic.
Disección del context engineering
Este prompt tiene varias capas de context engineering que vale la pena analizar:
1. Instrucciones claras y específicas
No solo dice “planifica búsquedas”, sino que define exactamente qué significa eso: descomponer en subtareas específicas con diferentes enfoques.
2. Contexto temporal dinámico
The current date and time is: {{ $now.toISO() }}
Esto es crucial. Sin la fecha actual, el LLM no puede interpretar correctamente términos como “última semana” o “reciente”.
3. Estructura de output específica
Define exactamente qué campos necesita cada subtarea y qué tipo de valores espera. No deja nada a la interpretación.
4. Uso de delimitadores
<user_query></user_query>
Los delimitadores evitan confusión entre diferentes tipos de información en el prompt.
5. Schema de datos estructurado
{
"subtasks": [
{
"id": "openai_latest_news",
"query": "latest OpenAI announcements and news",
"source_type": "news",
"time_period": "recent",
"domain_focus": "technology",
"priority": 1,
"start_date": "2025-06-03T06:00:00.000Z",
"end_date": "2025-06-11T05:59:59.999Z"
}
]
}
Los componentes clave del context engineering
1. Instrucciones (Instructions)
La base de todo. Pero no solo “haz X”, sino “haz X de esta manera específica, considerando Y y Z”.
// ❌ Instrucción básica
"Genera un resumen del texto"
// ✅ Context engineering
"Genera un resumen ejecutivo de máximo 200 palabras que incluya:
1) Los 3 puntos clave principales
2) Implicaciones para el negocio
3) Próximos pasos recomendados
El público objetivo son CTOs con 10+ años de experiencia."
2. Inputs y outputs estructurados
Los LLMs funcionan mejor cuando saben exactamente qué formato usar:
interface TaskResult {
success: boolean;
data?: any;
error?: string;
confidence: number; // 0-1
sources: string[];
}
3. Gestión de herramientas
En sistemas agénticos, definir claramente qué herramientas usar y cuándo:
Available tools:
- search_web(query: string, date_range?: string)
- search_academic(query: string, fields?: string[])
- get_company_data(company: string)
Use search_web for general information and recent news.
Use search_academic for research papers and studies.
Use get_company_data only when specifically asked about company metrics.
4. RAG y memoria
Context engineering incluye decidir qué información externa inyectar:
Relevant context from previous conversations:
- User is working on a React project
- Prefers TypeScript over JavaScript
- Uses Tailwind CSS for styling
- Working in a team of 5 developers
5. Estado e historial
Para aplicaciones complejas, gestionar el estado anterior:
Current session state:
- Search queries executed: 3
- Results found: 47 documents
- User feedback: "Need more recent sources"
- Last successful query: "climate change policies 2024"
Aplicación práctica en proyectos reales
Caso 1: Asistente de documentación
const systemPrompt = `
You are a technical documentation assistant for a TypeScript/Node.js project.
Current project context:
- Framework: ${framework}
- Database: ${database}
- Testing: ${testingFramework}
- Current file: ${currentFile}
When generating documentation:
1. Use JSDoc format for functions
2. Include practical examples
3. Note any breaking changes since v${lastVersion}
4. Reference related functions in the same module
Output format: markdown with code blocks using the appropriate language syntax.
`;
Caso 2: Revisor de código
const codeReviewPrompt = `
You are a senior code reviewer with expertise in ${language}.
Review criteria:
- Security vulnerabilities (OWASP Top 10)
- Performance issues
- Code style adherence to ${styleGuide}
- Test coverage gaps
- Documentation completeness
For each issue found, provide:
{
"severity": "low|medium|high|critical",
"category": "security|performance|style|testing|documentation",
"line": number,
"description": string,
"suggestion": string,
"example": string?
}
`;
Herramientas y ecosistema
LangChain y context engineering
LangChain ya incluye muchos patrones de context engineering:
from langchain.prompts import ChatPromptTemplate
from langchain.schema import SystemMessage, HumanMessage
template = ChatPromptTemplate.from_messages([
SystemMessage(content=system_context),
HumanMessage(content="{user_input}"),
# Contexto dinámico basado en el estado
HumanMessage(content="{dynamic_context}")
])
Herramientas no-code
Plataformas como n8n, Zapier, o LangFlow están incorporando context engineering como parte de sus flujos visuales.
Frameworks especializados
- Guidance (Microsoft) - Para prompts estructurados
- Jsonformer - Para outputs JSON garantizados
- Outlines - Generación con restricciones estructurales
Evaluación y métricas
Context engineering requiere medición sistemática:
Métricas de calidad
interface ContextMetrics {
accuracy: number; // % respuestas correctas
consistency: number; // Variación entre ejecuciones
latency: number; // Tiempo de respuesta
tokenUsage: number; // Eficiencia del contexto
userSatisfaction: number; // Feedback del usuario
}
A/B testing de contexto
const experimentConfig = {
control: {
systemPrompt: basePrompt,
examples: standardExamples
},
treatment: {
systemPrompt: enhancedPrompt,
examples: curatedExamples,
additionalContext: relevantDocs
}
};
Problemas comunes y soluciones
1. Context window overflow
// ❌ Problema: Demasiado contexto
const hugPrompt = systemPrompt + allDocuments + fullHistory;
// ✅ Solución: Context management
const relevantContext = selectRelevantContext(
userQuery,
documents,
maxTokens: 4000
);
2. Información obsoleta
// ✅ Context aging
const contextMetadata = {
timestamp: Date.now(),
source: 'user_documentation',
relevanceScore: 0.87,
lastValidated: '2025-01-15'
};
3. Contexto irrelevante
// ✅ Context filtering
const filteredContext = contextItems
.filter(item => item.relevanceScore > 0.7)
.slice(0, 10); // Top 10 más relevantes
El futuro del context engineering
Automatización del contexto
Ya empezamos a ver herramientas que optimizan automáticamente el contexto:
- DSPy - Optimización automática de prompts
- Prompt flow (Microsoft) - Gestión visual de contexto
- Context compression - Técnicas para reducir tokens manteniendo información
Context engineering como servicio
Imagino que pronto veremos:
- APIs de optimización de contexto
- Herramientas de A/B testing específicas para prompts
- Dashboards de métricas de context engineering
- Context stores - Repositorios de contextos optimizados
Consideraciones de seguridad
Context engineering también implica riesgos:
Prompt injection
// ❌ Vulnerable
const prompt = `Summarize: ${userInput}`;
// ✅ Protegido
const prompt = `
Summarize the following text (delimited by triple quotes):
"""
${sanitizeInput(userInput)}
"""
`;
Filtrado de información sensible
const sanitizedContext = filterSensitiveData(context, {
removePersonalData: true,
redactCredentials: true,
filterProfanity: false
});
Herramientas recomendadas
Para desarrollo
- LangChain - Framework completo con patrones de context engineering
- Guidance - Control preciso sobre generación
- LlamaIndex - Excelente para RAG y context management
Para prototipado
- n8n - Flujos visuales con context engineering integrado
- LangFlow - Desarrollo visual de aplicaciones LLM
- Flowise - Drag & drop para chatbots
Para evaluación
- Weights & Biases - Tracking de experimentos
- LangSmith - Debugging y evaluación de LLM
- Phoenix - Observabilidad para aplicaciones LLM
Mi experiencia práctica
En mis últimos proyectos con LLMs, context engineering ha sido la diferencia entre prototipos que funcionan “a veces” y sistemas que funcionan consistentemente.
Lecciones aprendidas:
- Empieza simple, itera sistemáticamente - No intentes optimizar todo de una vez
- Mide todo - Sin métricas, es imposible saber si mejoras o empeoras
- El contexto es código - Trata tus prompts con el mismo rigor que tu código
- La estructura importa más que la longitud - Un prompt bien estructurado de 200 tokens funciona mejor que uno desestructurado de 1000
Patrón típico que uso:
interface ContextEngine {
systemPrompt: string;
userInput: string;
dynamicContext: Record<string, any>;
tools: ToolDefinition[];
outputSchema: JSONSchema;
metadata: ContextMetadata;
}
const buildContext = (config: ContextEngine) => {
return {
system: config.systemPrompt,
messages: [
...buildUserMessages(config.userInput),
...injectDynamicContext(config.dynamicContext),
],
tools: config.tools,
responseFormat: config.outputSchema
};
};
Recursos para profundizar
- Context Engineering Guide - El artículo original de Elvis Saravia
- Context Engineering by Lance Martin - Perspectiva técnica detallada
- The Skill That’s Replacing Prompt Engineering - Análisis del cambio de paradigma
- LangChain Context Engineering - Documentación oficial
- DSPy Framework - Optimización automática de prompts
Conclusión
Context Engineering no es solo una evolución terminológica del prompt engineering - es una disciplina más madura que reconoce la complejidad real de construir aplicaciones LLM productivas.
Como desarrolladores, necesitamos tratar el contexto como un sistema arquitectural, no como una nota al margen. Esto significa:
- Diseño sistemático del contexto
- Evaluación continua de su efectividad
- Iteración basada en datos para optimizar resultados
- Gestión de versiones del contexto como cualquier otro código
El futuro pertenece a quienes dominen estas habilidades. No porque sea hype, sino porque es la diferencia entre aplicaciones LLM que funcionan y aplicaciones que realmente resuelven problemas.
¿Ya estás aplicando context engineering en tus proyectos? ¿Qué patrones has encontrado más efectivos? Me encantaría conocer tu experiencia.
¿Te ha resultado útil este artículo? Compártelo con otros desarrolladores que estén trabajando con LLMs. Y si tienes alguna pregunta o experiencia que compartir sobre context engineering, no dudes en contactarme.
Comentarios