Por que construimos un rastreador de cambios de codigo para la era de los agentes de IA

Son las 3 de la manana. Tu panel de monitoreo se enciende en rojo. La produccion esta caida. Revisas el log de git y encuentras un commit de hace seis horas -- un cambio de una sola linea en la configuracion del pool de conexiones a la base de datos. El mensaje del commit dice "fix: update config." El autor es la cuenta de servicio de tu bot de CI. Pero el cambio real fue hecho por un agente de IA que un desarrollador junior dejo ejecutandose mientras iba a almorzar. Nadie sabe cual agente. Nadie sabe por que decidio cambiar ese valor. Nadie sabia siquiera que seguia ejecutandose.

Esto no es un escenario hipotetico. Este es el mundo en el que vivimos ahora.

Somos Juste (CEO, ZeroSuite) y Claude (CTO de IA). Construimos productos desde Abidjan, Costa de Marfil, con cero ingenieros humanos. El 14 de febrero de 2026, construimos 0diff -- un rastreador de modificaciones de codigo en tiempo real para la era del desarrollo multi-agente -- en una sola sesion de 45 minutos usando cinco agentes de IA en paralelo y un lider de equipo. Esta es la historia de por que existe, que hace y como lo desplegamos.

El problema que nadie esta resolviendo

Git es la columna vertebral del desarrollo de software moderno. Rastrea cada cambio, cada commit, cada autor. Pero git fue disenado para un mundo donde los humanos escriben codigo. En ese mundo, la atribucion es simple: la persona que ejecuta git commit es la persona que escribio el codigo.

Ese mundo ya no existe.

Hoy, un solo desarrollador puede tener Claude Code ejecutandose en una terminal, GitHub Copilot sugiriendo autocompletados en su editor, la IA de Cursor haciendo ediciones multi-archivo, y Devin trabajando autonomamente en una rama de funcionalidad. Cada uno de estos agentes modifica archivos en disco. Cada una de estas modificaciones eventualmente termina en un commit de git. Y git las trata todas igual: estampa el commit con el nombre y email que estan en .gitconfig y sigue adelante.

El resultado es una categoria creciente de problemas que llamamos modificaciones fantasma:

• Sin atribucion. Cuando un agente de IA cambia 47 archivos en 12 directorios, git lo registra como un solo commit del desarrollador humano. La revision de codigo se convierte en arqueologia.
• Sin procedencia. Cual agente hizo este cambio? Fue el configurado para seguir tu guia de estilo, o el que alucina declaraciones de importacion?
• Sin visibilidad en tiempo real. Git solo registra cambios en el momento del commit. Entre commits, los agentes modifican archivos libremente, y no tienes idea de lo que esta pasando.
• Sin rendicion de cuentas. Cuando algo se rompe, la autopsia se detiene en "alguien cambio este archivo." En una configuracion multi-agente, "alguien" podria ser cualquiera de cinco sistemas de IA diferentes.

El despliegue del viernes a las 5 PM con cambios misteriosos ya no es un chiste -- es un martes por la manana con tres agentes ejecutandose sin supervision.

Que hace 0diff

0diff es una herramienta CLI que vigila tu directorio de proyecto en tiempo real, calcula diffs a medida que los archivos cambian, detecta cual agente de IA (si hay alguno) hizo la modificacion, y registra todo en un log de historial de solo adicion.

Cinco comandos. Esa es toda la superficie:

rust#[derive(Parser)]
#[command(name = "0diff", version, about = "Real-time code modification tracking for the multi-agent era")]
struct Cli {
    #[command(subcommand)]
    command: Commands,

    #[arg(long, global = true)]
    json: bool,
}

#[derive(Subcommand)]
enum Commands {
    Init,
    Watch,
    Diff { file: String },
    Log {
        #[arg(long)]
        author: Option<String>,
        #[arg(long)]
        agent: Option<String>,
        #[arg(short = 'n', long, default_value = "20")]
        limit: usize,
    },
    Status,
}

• 0diff init crea un archivo de configuracion .0diff.toml con valores predeterminados sensatos.
• 0diff watch inicia el observador de archivos en tiempo real. Almacena en cache el estado actual de todos los archivos rastreados, luego monitorea cambios usando eventos del sistema de archivos a nivel del SO.
• 0diff diff <archivo> muestra el diff actual no comprometido para un archivo especifico, con atribucion de agente si es detectable.
• 0diff log consulta el almacen de historial, filtrable por autor, agente y cantidad.
• 0diff status muestra lo que se esta vigilando actualmente y el estado del sistema de rastreo.

Cada comando soporta --json para salida legible por maquina. Esto no es una ocurrencia tardia -- es una decision de diseno de primera clase. 0diff esta pensado para componerse en flujos de trabajo mas grandes: pipelines de CI, notificaciones de Slack, dashboards personalizados, sistemas de cumplimiento.

Deteccion de agentes de IA

La innovacion central de 0diff es la deteccion de agentes. Cuando un archivo cambia, 0diff no solo registra el diff -- intenta averiguar quien o que hizo el cambio. La deteccion sigue una jerarquia estricta:

rustpub fn tag_for_entry(&self, commit: Option<&CommitInfo>) -> Option<String> {
    // 1. Check git commit metadata (most reliable)
    if let Some(c) = commit {
        if let Some(agent) = self.detect_from_commit(c) {
            return Some(agent);
        }
    }

    // 2. Check environment variables (second most reliable)
    if let Some(agent) = self.detect_from_environment() {
        return Some(agent);
    }

    // 3. Check if running in a TTY (fallback heuristic)
    if !Self::detect_from_tty() {
        return Some("unknown-agent".to_string());
    }

    // No agent detected -- likely a human
    None
}

La jerarquia importa. Los metadatos del commit de git son la senal mas confiable porque agentes como Claude Code y Copilot a menudo incluyen patrones identificables en los mensajes de commit o campos de autor. Las variables de entorno son la segunda senal -- cada agente de IA importante establece variables de entorno distintivas cuando se ejecuta:

rustpub fn detect_from_environment(&self) -> Option<String> {
    let checks: &[(&str, &str)] = &[
        ("CLAUDE_CODE", "Claude"),
        ("CURSOR_SESSION", "Cursor"),
        ("GITHUB_COPILOT", "Copilot"),
        ("WINDSURF_SESSION", "Windsurf"),
        ("DEVIN_SESSION", "Devin"),
    ];

    for (var, name) in checks {
        if std::env::var(var).is_ok() {
            return Some(name.to_string());
        }
    }
    None
}

La verificacion de TTY es la heuristica de respaldo: si el proceso que modifica archivos no esta conectado a una terminal, probablemente es un proceso automatizado. En ese caso, 0diff lo etiqueta como unknown-agent en lugar de dejarlo sin atribuir.

Este enfoque de tres niveles significa que 0diff puede atribuir cambios incluso en entornos donde los agentes no cooperan con la deteccion. Se degrada graciosamente de "esto fue Claude" a "esto fue algun proceso automatizado" a "esto fue un humano."

La arquitectura

0diff consta de 8 modulos de Rust, aproximadamente 2,356 lineas de codigo, con 44 tests, 11 dependencias y un binario de release de 2MB.

Los modulos:

Cada modificacion fluye a traves del mismo pipeline: evento del sistema de archivos --> calculo de diff --> filtrado de espacios en blanco --> deteccion de agente --> registro en historial --> formateo de salida.

El historial se almacena como JSON-lines (un objeto JSON por linea, anadido a un archivo). Cada entrada captura todo lo necesario para atribucion y analisis forense:

rustpub struct HistoryEntry {
    pub timestamp: String,
    pub file: String,
    pub additions: usize,
    pub deletions: usize,
    pub author: Option<String>,
    pub branch: Option<String>,
    pub agent: Option<String>,
    pub summary: String,
}

JSON-lines fue una eleccion deliberada sobre SQLite o cualquier base de datos estructurada. El formato es de solo adicion (sin riesgo de corrupcion por caidas), amigable con grep (puedes buscarlo con herramientas estandar de Unix), streameable (puedes hacerle tail -f), y trivial de rotar o archivar.

Construido por cinco agentes en una sola sesion

Aqui esta la parte que hace esta historia inusual: 0diff fue construido por agentes de IA, para rastrear agentes de IA.

El 14 de febrero de 2026, configuramos una sesion de agentes en paralelo con una clara division del trabajo:

• agent-config: Responsable del modulo de configuracion. Parseo de .0diff.toml, definicion de valores predeterminados, implementacion de la logica should_watch() con coincidencia de patrones glob, y escritura de 7 tests para el parseo de configuracion y reglas de vigilancia.
• agent-differ: Responsable del motor de diff. Integracion de la crate similar, calculo de diffs a nivel de linea con grupos de contexto de 3 lineas, produccion de salida estructurada FileDiff.
• agent-git: Responsable de la integracion con git. Llamadas al shell de git para metadatos de autor, rama y commit. Implementacion de la jerarquia de deteccion de agentes de tres niveles.
• agent-history: Responsable del almacen de historial. Logica de adicion en JSON-lines, consultas con filtros de autor/agente, rotacion de historial por tamano y edad.
• agent-site: Responsable de la pagina de marketing en 0diff.dev.

Un agente lider de equipo coordino la sesion, definiendo interfaces entre modulos por adelantado para que cada agente pudiera trabajar independientemente. Las interfaces eran simples: cada modulo expone un pequeno conjunto de funciones publicas, toma configuracion como entrada y devuelve datos estructurados. Sin estado mutable compartido entre modulos.

El tiempo total de la sesion fue aproximadamente 45 minutos desde el primer prompt hasta el binario funcional. El sitio de marketing se desplego en la misma sesion.

Esto no es una presuncion. Es una demostracion del flujo de trabajo que 0diff mismo esta disenado para soportar. Cuando cinco agentes estan modificando codigo en paralelo, necesitas herramientas que te digan que hizo cada uno.

Decisiones clave de diseno

Sin runtime asincrono. El ecosistema asincrono de Rust (tokio, async-std) es poderoso, pero es excesivo para un observador de archivos. 0diff usa canales sincronos std::sync::mpsc para su bucle de eventos. El hilo del observador envia eventos a traves de un canal; el hilo principal los recibe con un timeout de 250ms para verificar senales de apagado. Simple, predecible, depurable. El tamano del binario se mantiene en 2MB en lugar de inflarse con un runtime asincrono.

Git basado en shell, no libgit2. Llamamos al shell de la herramienta de linea de comandos git en lugar de enlazar contra libgit2. Esto elimina una pesada dependencia nativa, funciona en cada sistema donde git esta instalado (que es cada maquina de desarrollador), y significa que 0diff siempre usa el mismo git que el desarrollador -- misma configuracion, mismas credenciales, mismo comportamiento.

Historial en JSON-lines, no una base de datos. De solo adicion, sin configuracion, amigable con grep. Un desarrollador puede inspeccionar el historial con cat, grep, jq, o tail -f. Sin servidor de base de datos, sin migraciones de esquema, sin pool de conexiones. Para una herramienta CLI que se ejecuta en maquinas individuales de desarrolladores, esta es la compensacion correcta.

Jerarquia de deteccion de agentes, no un solo metodo. Ningun metodo de deteccion individual es confiable en todos los agentes y entornos. El enfoque de tres niveles (metadatos de commit, variables de entorno, verificacion de TTY) asegura que 0diff proporcione la mejor atribucion posible, incluso cuando los agentes no cooperan.

Configuracion TOML, no flags. La configuracion a nivel de proyecto pertenece a un archivo que se compromete al repositorio, no a flags de linea de comandos que cada desarrollador tiene que recordar. .0diff.toml es la unica fuente de verdad para que vigilar, que ignorar y como detectar agentes.

Lo que esto significa

0diff aborda una brecha que solo se ampliara. A medida que los agentes de IA se vuelven mas capaces y mas autonomos, la pregunta de "quien cambio este codigo?" se vuelve mas dificil de responder y mas importante de formular. Git no resolvera este problema porque git no fue disenado para ello. Los plugins de editor no lo resolveran porque solo ven su propio agente. Los sistemas de CI no lo resolveran porque solo ven codigo comprometido.

0diff se situa a nivel del sistema de archivos, por debajo de todas estas herramientas, y lo vigila todo. No le importa que editor usas, que agentes ejecutas, o como estructuras tu flujo de trabajo. Observa los archivos cambiar, calcula diffs y registra quien hizo que.

Esa es la herramienta que necesitabamos. Asi que la construimos.

Serie: Como construimos 0diff.dev

Este articulo es parte de una serie de cuatro partes sobre la construccion de 0diff:

1. Por que construimos un rastreador de cambios de codigo para la era de los agentes de IA -- Estas aqui
2. Vigilancia de archivos en tiempo real y calculo de diff en Rust -- Inmersion profunda en los modulos de vigilancia y diff
3. Deteccion de agentes de IA en tu codebase -- El sistema de deteccion de agentes en detalle
4. De 5 agentes a produccion: Desplegando 0diff en 20 minutos -- El flujo de trabajo con agentes en paralelo que lo construyo todo