Capítulo 3 — Abandonar el editor

Los editores habían sido mi lugar de trabajo durante unos quince años. No solo una herramienta que usaba, sino la habitación donde pasaba el trabajo.

Al principio era Notepad. El trabajo estaba lo bastante cerca del texto plano como para que el texto plano se sintiera honesto. Dreamweaver pertenecía a otra época, cuando ver la página y construir la página parecían el mismo laburo. JetBrains tenía sentido cuando el codebase se volvió un mundo propio y necesitaba que la habitación entendiera más. Sublime y Atom hicieron la habitación más liviana. VS Code la hizo expansible.

Probé vim. Probé vivir en la consola. Siempre volvía.

Cada editor respondía la pregunta que yo tenía ese año: ¿para qué estoy acá? Escribir el archivo. Entender el proyecto. Moverme más rápido. Tener más del sistema cerca. Cuando cambiaba la fricción, cambiaba de editor, pero nunca cuestioné la ventana en sí. Había código en el medio, un árbol al costado, y yo tomando decisiones línea por línea.

Esa disposición sobrevivió cada cambio de mi carrera. Cambiaron los lenguajes. Cambiaron los frameworks. Pasé de escribir código a gestionar gente y de nuevo al código. El editor se quedó.

Por eso dejarlo me llevó más de lo que debería. No estaba comparando dos aplicaciones. Estaba admitiendo que el lugar donde había trabajado quince años ya no coincidía con el trabajo.

Cuando llegaron los agentes de código, llegaron adentro del editor.

Cursor, Windsurf, las herramientas con forma de VS Code — me dejaron conservar la habitación familiar mientras cambiaba quién tecleaba. Eso importaba. Podía pedir un feature, ver cómo cambiaban los archivos, inspeccionar el resultado y arreglar lo que no me gustaba sin aprender una forma nueva de sentarme frente a la computadora.

Durante un tiempo, eso era exactamente lo que necesitaba.

Buenos Bakery se construyó así. El agente escribía. Yo leía. Avanzaba rápido, y yo mantenía la calidad bajo control revisando el trabajo como había revisado trabajo humano: línea por línea. El editor era útil porque editar todavía era el trabajo.

Pero el agente en el panel también escondía lo que había cambiado.

Tipear ya no era escaso. El juicio sí. Las preguntas importantes se alejaban de si esta función debía partirse o si ese tipo debía vivir en otro archivo. Se volvían: ¿construimos lo correcto?, ¿funciona?, ¿pertenece al producto?, ¿y el sistema puede demostrar que es seguro mergear?

El capítulo 2 era sobre las paredes alrededor del código. Estándares, ubicación, guards, tests — la estructura que deja que un agente trabaje sin inventar un estudio nuevo cada vez que abre un repositorio. Esas paredes importan porque yo no puedo inspeccionar personalmente cada ladrillo.

Esa era la contradicción sentada en mi pantalla. Estaba construyendo un sistema diseñado para funcionar sin mi atención línea por línea, y después pasaba el día en el único lugar hecho para exigir atención línea por línea.

Un editor es donde editás.

Suena demasiado obvio para ser útil, pero me llevó meses tomármelo en serio. Todo en esa ventana te empuja hacia el código. La línea cambiada pide ser leída. El árbol de archivos pide ser navegado. El agente termina y presenta un diff, así que lo responsable parece ser revisar el diff.

Con un agente en un proyecto, es responsable.

Con varios agentes a través de varios proyectos, se vuelve una elección sobre qué no hacer. Cada minuto puliendo el cambio de un worker es un minuto que no pasás chequeando el producto, desbloqueando a otro worker o decidiendo qué importa después. El código puede estar perfectamente revisado mientras el estudio me espera a mí.

Otro editor con IA no habría arreglado eso. Quizá habría hecho el mismo loop más suave, pero el loop mismo era el techo: pedir, mirar, inspeccionar, corregir. Una persona supervisando de cerca un solo stream.

Ya había aprendido en el proyecto de la panadería que hacer al escritor más rápido no hace más rápida toda la operación. Ahora tenía que aceptar la versión más incómoda.

Una vez que mi revisión se movió al nivel del producto, quedarme en un editor con IA era pretender que mi trabajo seguía siendo editar.

La ventana de código era el lugar de trabajo equivocado.

Dejé el editor por supervisores en la terminal.

El cambio visible fue chico. Primero Ghostty, después Most. En lugar de acomodar ventanas de código, acomodé espacios alrededor de supervisores y orquestadores. Cada supervisor sostenía un proyecto o una parte de la operación y mandaba trabajo a agentes más chicos — drones — que podían escribir, testear, inspeccionar y reportar.

Estos días suele haber alrededor de seis o siete supervisores, cada uno trabajando con más o menos dos a cinco drones. El número exacto se mueve con el día. Últimamente, buena parte del trabajo fue pesado de infraestructura. Otro día, más puede ser trabajo de producto. El punto no es cuántas terminales entran en una pantalla. El punto es que ya no estoy adentro de cada tarea con cada worker.

Yo gestiono el trabajo.

Eso significa que las preguntas en mi pantalla son distintas. ¿Qué está bloqueado? ¿Qué falló sus checks? ¿Qué cambio está listo para mergear? ¿El producto se comporta bien? ¿Qué supervisor tiene suficiente contexto para decidir, y qué decisión todavía me necesita a mí?

El código y los tests todavía viven en local. Los agentes todavía toman malas decisiones. Un check verde todavía puede esconder la decisión de producto equivocada, y una implementación limpia todavía puede resolver el problema equivocado. Dejar el editor no eliminó la revisión. Movió la revisión una capa hacia arriba.

Esa distinción es todo.

El modelo de taller me ponía al lado de un worker, mirando una pieza mientras se hacía. El modelo de fábrica me pone en el piso, moviéndome entre líneas, chequeando salidas, arreglando el sistema que las produce. Puedo entrar a un repositorio cuando lo necesito. Simplemente ya no vivo ahí.

Mantengo un cockpit que cuenta pull requests y merges. El número salta — algunos días una inundación, otros días ordinario — y no confío en un multiplicador prolijo para un trabajo tan desigual. Una reparación de una línea no es un feature. Aun así, puesto al lado de cómo trabajaba antes de la IA, un día fuerte en ese cockpit se ve como otra escala de shipping.

Esa ganancia no viene de tipear más rápido. Viene de ya no hacer que cada pedazo de trabajo espere a mi cursor.

A la gente de software le gusta creer que por fin encontró su herramienta.

Afinamos los atajos. Movemos la configuración de máquina en máquina. Aprendemos los rincones raros, perdonamos lo molesto, y despacio convertimos la familiaridad en un principio. La herramienta se vuelve parte de cómo nos describimos. Soy de JetBrains. Soy de vim. Construyo en Cursor. Este es mi setup.

Yo también hice eso. Cada mudanza se sentía como que podía ser la última: el editor lo bastante bueno para dejar de pensar en editores.

Pero las herramientas pertenecen al trabajo, no al revés. Mis hábitos tienen permiso de vencerse.

No toda revisión merece la misma distancia. Cuando yo escribía cada línea, la línea importaba más. Cuando un agente escribía adentro de mi editor, el diff importaba más. Cuando varios supervisores coordinan varios agentes, importan más el producto, los tests, los estándares y el estado de todo el sistema. Las capas de abajo no se vuelven sin importancia. Se vuelven la responsabilidad inmediata de otro, sostenida dentro de paredes que yo puedo verificar.

Acá también cambia la gente del sistema. Al principio, los workers se sientan en el editor y una persona los gestiona desde el mismo panel. Después la persona deja el panel. Los agentes siguen trabajando cerca del código; la persona empieza a gestionar las condiciones alrededor del código.

Ese fue el cambio de doctrina en enero. No se rompió nada. Simplemente dejé de tratar a la última herramienta que se sentía mágica como el lugar donde tenía que quedarme.

Para cuando lo admití, ya había abandonado el editor. Simplemente no había cerrado la ventana.

Dejar el editor creó otro problema. Los cerebros de los agentes eran remotos — Anthropic, Codex y otros — pero el código, los tests, los containers y todo el trabajo que tocaban seguían corriendo en local. Una MacBook o una PC tiene un límite muy ordinario, incluso cuando los workers que la usan no duermen.

Espacios de Most, alrededor de siete orquestadores, ops-layer, Cortex, AgentBus, Nomad: esos nombres pertenecen al sistema que creció después de que desapareció la ventana de código. Son capítulos posteriores. Por ahora, alcanza con decir que una vez que el taller se volvió fábrica, la fábrica necesitaba un lugar donde vivir.

Próximo capítulo: a la laptop se le acabó el espacio — y el estudio se mudó a su propio servidor.