Comienza con un alcance mínimo viable

Al iniciar wherewasai, solicitar a la IA "implementar un gestor de memoria completo" resultó contraproducente. La herramienta proponía sistemas complejos con interfaces web, bases de datos y funcionalidades de colaboración, cuando el MVP solo necesitaba:

• Identificación de proyectos locales
• Almacenamiento en archivos JSON
• Comandos CLI básicos
• Exportación de contexto de desarrollo

Antes de codificar, es crucial definir límites claros:

// Ejemplo de definición de alcance
const mvpRequirements = {
  coreFeatures: ['projectDetection', 'localStorage', 'cliCommands'],
  excludedFeatures: ['webUI', 'cloudSync', 'userManagement']
};

Establece límites explícitos

Las herramientas de IA tienden a expandir el alcance si no se especifican restricciones. Para wherewasai, definí claramente lo que NO era:

• No es una aplicación de notas tradicional
• No es una plataforma colaborativa
• No requiere autenticación de usuarios
• No sincroniza en la nube

Código de ejemplo con restricciones:

class ProjectMemoryManager {
  constructor() {
    this.boundaries = {
      allowedModifications: ['memoryStructure', 'exportFormat'],
      forbiddenChanges: ['storageSchema', 'cliInterface']
    };
  }
  
  validateChanges(requestedChanges) {
    return requestedChanges.every(change => 
      this.boundaries.allowedModifications.includes(change)
    );
  }
}

Divide en ciclos pequeños y verificables

En lugar de tareas grandes como "implementar sistema completo", dividí el desarrollo en unidades independientes:

1. Comando de inicialización
2. Lectura/escritura de memoria
3. Agregar elementos de memoria
4. Listar historial del proyecto
5. Exportar contexto

Implementcaión modular:

// Módulo independiente para inicialización
const setupProject = (projectPath) => {
  const config = {
    memoryFile: '.projectmemory/memoria.json',
    structure: {
      objetivos: [],
      progreso: [],
      decisiones: []
    }
  };
  
  return fileSystem.createStructure(projectPath, config);
};

Comprende la estructura existente antes de modificar

Solicitar a la IA que explique la arquitectura actual previene errores estructurales:

// Antes de modificar, analizar dependencias
const analyzeDependencies = (codebase) => {
  const modules = {
    cli: 'punto de entrada de comandos',
    almacenamiento: 'gestión de archivos locales',
    detector: 'identificación de proyectos',
    memoria: 'estructura de datos del proyecto'
  };
  
  return Object.keys(modules).map(modulo => ({
    modulo,
    responsabilidad: modules[modulo],
    dependencias: findDependencies(codebase, modulo)
  }));
};

Limita el alcance de modificación por archivo

Especificar qué archivos pueden modificarse reduce errores:

const modificationRules = {
  tarea: 'implementar comando lista',
  archivosPermitidos: [
    'src/comandos/lista.ts',
    'src/cli.ts',
    'src/tipos/memoria.ts'
  ],
  archivosProhibidos: [
    'src/almacenamiento/archivoJson.ts',
    'package.json'
  ]
};

Estructura la memoria del pryoecto

La memoria del proyecto requiere organización, no solo almacenamiento de texto:

const projectMemorySchema = {
  metadatos: {
    ultimaActualizacion: 'timestamp',
    contextoProyecto: 'string'
  },
  contenido: {
    objetivo: 'string',
    stackTecnologico: 'array',
    progresoActual: 'object',
    funcionalidadesCompletadas: 'array',
    decisionesClave: 'array',
    problemasConocidos: 'array',
    siguientesPasos: 'array'
  }
};

Define criterios de verificación explícitos

Para cada funcionalidad, especifica resultados esperados:

const verificationCriteria = {
  comando: 'inicializar',
  resultadoEsperado: {
    archivosGenerados: ['.projectmemory', 'memoria.json'],
    estructura: 'formato JSON válido',
    comportamiento: 'no sobrescribe contenido existente'
  },
  verificacion: [
    'ejecutar comando en directorio vacío',
    'verificar creación de archivos',
    'validar estructura JSON'
  ]
};

Mantén el contexto de recuperación conciso

El contexto exportado debe ser relevante para la siguiente sesión de desarrollo:

const generateRecoveryContext = (projectMemory) => {
  return {
    resumen: projectMemory.objetivo,
    stack: projectMemory.stackTecnologico,
    progreso: projectMemory.progresoActual,
    siguientesPasos: projectMemory.siguientesPasos,
    decisionesRecientes: projectMemory.decisionesClave.slice(-3)
  };
};

Documenta reglas para agentes de IA

Un archivo AGENTS.md guía el desarrollo consistente:

# REGLAS PARA DESARROLLO CON IA

## Principios del Proyecto
- Enfoque local primero, CLI primero
- Sin interfaces web en MVP
- Sin sincronización en la nube

## Reglas de Código
- Explicar plan antes de modificar
- No refactorizar código no relacionado
- Reutilizar utilidades existentes
- Modificar máximo 5 archivos por tarea

## Verificación
- Especificar archivos modificados
- Proporcionar comando de ejecución
- Definir resultado esperado
- Incluir puntos de troubleshooting

Evita duplicación de funcionalidades

Antes de implementar nueva lógica, verifica existencia:

const checkExistingImplementation = (nuevaFuncionalidad) => {
  const componentesExistentes = [
    'manejadorArchivos',
    'estructuraMemoria',
    'registroComandos'
  ];
  
  return componentesExistentes.some(componente => 
    esSimilar(nuevaFuncionalidad, componente)
  );
};

Utiliza la IA para revisión de código

Solicita análisis desde múltiples perspectivas:

const reviewPerspectives = {
  revisor: 'legibilidad y mantenibilidad',
  tester: 'cobertura de casos límite',
  arquitecto: 'integridad estructural',
  producto: 'alineación con objetivos MVP'
};