# El efecto compuesto del Contexto

Esta imagen explica una idea muy importante detrás de **Claude Code** (y, en realidad, de cualquier agente de IA moderno): **invertir tiempo en darle contexto produce un efecto compuesto**, igual que el interés compuesto en finanzas.

No significa que la IA "aprenda sola" en el sentido de entrenar un nuevo modelo. Significa que **cada vez tiene más información estructurada para trabajar correctamente**.

Veámoslo por partes.

## La idea principal

La curva representa cómo aumenta la productividad de la IA con el tiempo.

No es lineal.

No es:

> Día 1 -> +10%
> 
> Día 2 -> +10%
> 
> Día 3 -> +10%

Sino algo como:

> Día 1 |
> 
> Semana 1 |
> 
> Mes 1 |
> 
> Trimestre |
> 
> crecimiento exponencial

¿Por qué?

Porque el contexto se va acumulando.

## ¿Qué es "Context"?

En Claude Code el contexto es todo aquello que ayuda a entender tu proyecto.

Por ejemplo:

> Proyecto
> 
> │
> 
> ├── [CLAUDE.md](http://CLAUDE.md)
> 
> ├── arquitectura
> 
> ├── reglas
> 
> ├── patrones
> 
> ├── scripts
> 
> ├── skills
> 
> ├── ejemplos
> 
> ├── convenciones
> 
> └── documentación

Cada archivo reduce las dudas del agente.

### Día 1

La imagen dice:

> Basic [CLAUDE.md](http://CLAUDE.md) (2 hrs)
> 
> +5 skills (3 hrs)
> 
> AI understands basics.

Traducción:

> Dedicas unas horas a escribir un buen [**CLAUDE.md**](http://CLAUDE.md) y algunas Skills.

Entonces Claude ya sabe cosas como:

> Este proyecto usa:
> 
> *   Java 21
>     
> *   Spring Boot
>     
> *   DDD
>     
> *   PostgreSQL
>     
> *   Maven
>     
> 
> No usar Lombok.
> 
> Siempre crear tests.
> 
> Arquitectura hexagonal.
> 
> Convenciones de nombres.

Ahora ya no tienes que repetirlo.

Antes:

> Claude,
> 
> usa Java 21,
> 
> usa Maven,
> 
> haz tests,
> 
> usa records,
> 
> no uses Lombok...

Después:

> Claude,
> 
> crea un endpoint.

Porque todo lo demás ya está documentado.

## Semana 1

La imagen dice:

> Bug fixes + Pattern discovery

Aquí ocurre algo muy interesante.

Supongamos que Claude genera esto:

> @[Service](@businessservic)
> 
> public class ProductService {
> 
> }

Tú respondes:

> Aquí siempre usamos casos de uso.

Entonces actualizas la documentación:

> Nunca crear lógica en Services.
> 
> Siempre:
> 
> Application
> 
> ↓
> 
> UseCase
> 
> ↓
> 
> Repository

Ahora Claude nunca vuelve a cometer ese error.

Otro ejemplo:

Antes:

> Controller
> 
> ↓
> 
> Service
> 
> ↓
> 
> Repository

Después:

> Controller
> 
> ↓
> 
> CreateProductUseCase
> 
> ↓
> 
> Repository

Ya aprendió el patrón de **tu proyecto**.

## Mes 1

La imagen dice:

> +15 more skills

Ahora ya no son cinco Skills.

Ahora tienes muchas.

Ejemplo:

> skills/
> 
> [java.md](http://java.md)
> 
> [spring.md](http://spring.md)
> 
> [ddd.md](http://ddd.md)
> 
> [testing.md](http://testing.md)
> 
> [migration.md](http://migration.md)
> 
> [performance.md](http://performance.md)
> 
> [security.md](http://security.md)
> 
> [logging.md](http://logging.md)
> 
> [api.md](http://api.md)
> 
> [docker.md](http://docker.md)
> 
> [kubernetes.md](http://kubernetes.md)

Cada una explica cómo trabajar.

Cuando Claude necesita hacer logging:

No inventa.

Va a:

> skills/[logging.md](http://logging.md)

Cuando necesita Docker:

> skills/[docker.md](http://docker.md)

Cuando necesita pruebas:

> skills/[testing.md](http://testing.md)

Eso hace que pueda trabajar casi solo.

## Trimestre

La imagen dice:

> +50 skills
> 
> Comprehensive [CLAUDE.md](http://CLAUDE.md)
> 
> AI tackles "impossible" tasks.

Aquí el proyecto ya tiene muchísimo contexto.

Por ejemplo:

> [CLAUDE.md](http://CLAUDE.md)
> 
> [Architecture.md](http://Architecture.md)
> 
> Coding [Standards.md](http://Standards.md)
> 
> [DDD.md](http://DDD.md)
> 
> [Observability.md](http://Observability.md)
> 
> [Performance.md](http://Performance.md)
> 
> [Migration.md](http://Migration.md)
> 
> [Security.md](http://Security.md)
> 
> [CI.md](http://CI.md)
> 
> [Testing.md](http://Testing.md)
> 
> [Release.md](http://Release.md)
> 
> ADR/
> 
> Skills/
> 
> Examples/

Entonces puedes pedir algo enorme:

> Migra este módulo Java 8 a Java 21 usando arquitectura hexagonal, reemplaza javax por jakarta, genera tests y actualiza Docker.

Y Claude ya sabe:

*   cómo organizas paquetes
    
*   cómo nombras clases
    
*   cómo escribes tests
    
*   qué librerías usas
    
*   qué framework utilizas
    
*   qué estilo prefieres
    
*   cómo documentas
    
*   cómo haces logging
    
*   cómo despliegas
    

Ya no necesita preguntarte todo.

## ¿Por qué la curva es exponencial?

Porque el contexto se reutiliza.

Imagina una empresa.

Sin contexto:

> Tarea 1
> 
> 20 explicaciones
> 
> ↓
> 
> Claude trabaja

Nueva tarea:

> otras 20 explicaciones

Nueva tarea:

> otras 20 explicaciones

Siempre empiezas desde cero.

Con contexto:

> Explicas una vez
> 
> ↓
> 
> queda en [CLAUDE.md](http://CLAUDE.md)
> 
> ↓ queda en Skills
> 
> ↓ queda en ejemplos
> 
> ↓ queda en documentación

La siguiente tarea reutiliza todo.

Y la siguiente también.

Y la siguiente.

Por eso el beneficio se acumula.

## Una analogía con un desarrollador junior

Imagina que contratas un desarrollador nuevo.

### Día 1

Le explicas:

*   qué hace la empresa
    
*   cómo compilar
    
*   cómo ejecutar
    

Todavía pregunta mucho.

### Semana 1

Aprende:

*   convenciones
    
*   arquitectura
    
*   errores comunes
    

Ya pregunta menos.

### Mes 1

Ya conoce:

*   el dominio
    
*   el código
    
*   los patrones
    

Empieza a resolver tareas solo.

### Tres meses

Ahora incluso ayuda a otros.

La IA funciona de manera similar: **no porque el modelo cambie**, sino porque dispone de un conjunto cada vez más rico y organizado de instrucciones y conocimiento sobre tu proyecto.

Enjoy!

Joe