Desarrollador vs. Arquitecto: Cuándo Gana Cada Uno
Desarrollador vs. arquitecto no va de títulos, sino de quién decide la arquitectura. ADRs, acoplamiento y reversibilidad para tu ascenso sorpresa.

El mes pasado revisé un diff en el que un asistente de programación con IA había escrito una cadena de bloques try/catch para registrar las nuevas instalaciones de una extensión de navegador. Primero intentaba obtener el email del usuario. Si eso lanzaba una excepción, recurría a un ID de usuario. Si eso también lanzaba una excepción, registraba un encogimiento de hombros: alguien instaló algo, no sabemos quién. El código funcionaba. También estaba mal, porque la plataforma acababa de restringir qué datos de identidad puede pedir una extensión. La pregunta de desarrollador frente a arquitecto se esconde en diffs como este, y nadie te envió el memo sobre en qué lado estás ahora.
La respuesta correcta no era un mejor bloque catch. Era registrar una marca de tiempo, mostrar una pantalla de bienvenida y decirle a marketing que no puede tener el email en el momento de la instalación, a menos que el usuario se lo dé más tarde. Ningún modelo toma esa decisión, porque el modelo no conoce a tus usuarios, las políticas de tu plataforma ni los objetivos trimestrales de tu equipo de marketing. Hace exactamente lo que le pides, a una velocidad aterradora. Eso significa que la persona que pide, o sea tú, acaba de hacerse responsable de algo más grande que el código. Felicidades por el ascenso. Lamento que nadie te lo dijera.
Hay un contraargumento razonable: muchos ingenieros te dirán que en todos sus trabajos se esperaba que cuestionaran los requisitos y diseñaran el modelo de datos para cualquier ticket que tomaran. Es cierto: en los buenos equipos, eso siempre fue el trabajo. Pero algo real ha cambiado. La velocidad de escritura solía ser un freno natural para las malas ideas. Cuando un plan mediocre cuesta tres días de implementación, lo piensas primero. Cuando cuesta noventa segundos, el plan se construye antes de que nadie haya tenido la idea. La fricción que antes obligaba a pensar en arquitectura ha desaparecido, y nada la ha reemplazado salvo tú.
Desarrollador vs. arquitecto: dos trabajos distintos
Esta es la forma más limpia que encuentro para explicar la diferencia. Un desarrollador toma un ticket y pregunta cómo. Un arquitecto mira ese mismo ticket y pregunta si debería existir y con qué forma. El desarrollador optimiza dentro de las restricciones. El arquitecto elige las restricciones y, lo que es crucial, se hace cargo de las consecuencias de esa elección durante los próximos dos años. Ambos son ingeniería de verdad. Son trabajos distintos, y fallan de maneras distintas. El fallo de un desarrollador es un bug. El fallo de un arquitecto es un modelo de datos con tablas redundantes sobre las que tres equipos han construido cuando alguien por fin lo nota.
Las herramientas de programación con IA se han colado sin hacer ruido en el asiento del desarrollador. Son el junior más rápido que hayas contratado: incansable, fluido y totalmente incapaz de decirte que tu requisito es el problema real. Pide registro de instalaciones por usuario y obtendrás registro de instalaciones por usuario, con una cascada de respaldos para asegurarse de que “funciona” incluso cuando la plataforma no quiere que lo haga. El modelo no tiene nada en juego en el presupuesto de latencia de tu app, en tu postura de privacidad ni en tu rotación de guardias. Eso no es un defecto de la herramienta. Es la descripción del puesto del asiento que ocupó, lo que significa que el otro asiento, el que dice que no, está vacío a menos que te sientes en él.
Entonces, ¿qué implica sentarse ahí de verdad? Básicamente tres cosas. Conocer bien a tus usuarios como para detectar cuándo un requisito contradice sus intereses. Conocer el acoplamiento de tu sistema como para ver el radio de impacto de un cambio de una sola línea. Y estar dispuesto a tener la conversación incómoda con quien escribió el requisito, antes de que exista el código, no en un postmortem. Ninguna de estas cosas implica dibujar diagramas de cajas y flechas en una wiki que nadie lee. Todas requieren un criterio que no se puede delegar en una herramienta que nunca se resiste.
Decisiones de arquitectura que ya estás tomando
No necesitas el título para tomar decisiones de arquitectura: las tomas cada semana, dentro de tickets corrientes. Dónde vive la validación (cliente, API o base de datos). Si una llamada es síncrona o va a una cola. Qué se registra y qué se decide no registrar. La forma de una nueva tabla y a qué clave foránea apunta. Cada una de estas cosas es una apuesta sobre el futuro, y cada una limita o habilita los próximos diez tickets. El diff del registro de instalaciones parecía una tarea de monitorización. En realidad era una decisión de privacidad, una de seguridad y una de producto disfrazada de línea de código.
Aquí está el antes: lo que produjo el asistente, implementando fielmente “registrar quién instaló”:
async function logInstall(req, res) {
let identity = null;
try {
identity = { email: await getUserEmail(req) };
} catch {
try {
identity = { userId: await getUserId(req) };
} catch {
identity = { note: "install without identity" };
}
}
await db.installs.insert({ ...identity, at: new Date() });
res.redirect("/welcome");
}
Quince líneas, tres modos de fallo y un esquema que tendrá que acomodar para siempre email, userId o nada. Cada fallback acopla silenciosamente la ruta de instalación a una API de identidad, así que una caída en un servicio sujeto a consentimiento puede ralentizar o romper tu embudo de onboarding. Y la fila que dice “alguien instaló, no sabemos quién” es analíticamente inútil: no le dice nada a marketing que pueda usar. El requisito se cumplió al pie de la letra y se incumplió en espíritu.
async function logInstall(req, res) {
await db.installs.insert({ at: new Date() });
res.redirect("/welcome");
// Email is collected on the welcome screen, with consent,
// posted asynchronously — and never gates the install path.
}
El después tiene cuatro líneas. Pero fíjate en lo que realmente cambió: no el código, sino el requisito. El objetivo nunca fue “capturar un email”, sino “medir instalaciones y hacer seguimiento de los usuarios nuevos”. Una marca de tiempo mide instalaciones. La pantalla de bienvenida, donde el usuario ya está viendo una superficie de consentimiento, es el lugar adecuado para pedir el email, de forma asíncrona, donde un fallo no cuesta nada. El movimiento del arquitecto no fue escribir menos código. Fue renegociar para qué sirve el código.
Un hábito que vale la pena adquirir: antes de cualquier cambio no trivial, haz un inventario de acoplamiento de dos minutos. Pregúntate qué llamará este código, qué lo llamará a él y qué se rompe cuando cualquiera de esas cosas está lenta, caída o deprecada. En la versión de antes, la ruta de instalación dependía de dos servicios de identidad que no tenía por qué conocer. En la versión de después, depende de una sola tabla. Ese recuento de dependencias, no las líneas ni la complejidad ciclomática, es el número que predice tus incidentes futuros. Hemos visto el mismo patrón en cómo fallan los asistentes de programación con IA de formas predecibles y comprobables: el resultado es localmente plausible y globalmente acoplado.
ADRs frente a conocimiento tribal: cuándo gana cada uno
Un Architecture Decision Record es deliberadamente aburrido: una página con el contexto, la decisión, las alternativas consideradas y las consecuencias aceptadas. Eso es todo. Sin ceremonia, sin flujo de aprobación a menos que lo quieras. La razón por la que los ADRs han pasado de ser algo deseable a obligatorios en la era de la IA es la memoria. El modelo no tiene ninguna. Dentro de seis meses, alguien le pedirá a un asistente que cambie el módulo de instalación, y el razonamiento cuidadoso sobre consentimiento y políticas de plataforma se habrá evaporado, a menos que esté escrito en un lugar donde tanto personas como herramientas puedan encontrarlo. Un ADR en el repositorio lo lee quien (o lo que) toque el código después.
El conocimiento tribal gana de verdad en algunas situaciones, y fingir lo contrario es la razón por la que los ADRs tienen fama de burocráticos. Un equipo de dos personas que construye un prototipo con una vida útil de semanas no necesita registros de decisiones: quienes deciden están sentados uno al lado del otro y el código se reescribirá de todos modos. A esa escala, el contexto verbal es más rápido, más rico y más barato. El problema es que los equipos casi nunca notan el momento en que cruzan el umbral: la primera incorporación, el primer equipo que consume tu API, el primer incidente en el que “¿por qué lo hicimos así?” no tiene respuesta.
- La decisión es cara de revertir: cambios de esquema sobre datos en producción, contratos de API públicos, dependencia de un proveedor.
- La decisión cruza una frontera de equipo, así que las personas afectadas no están en la sala cuando se toma.
- Ya puedes oír la pregunta futura: “¿por qué diablos lo hicimos así?”
- Una herramienta de IA generó la implementación, así que ningún humano tuvo que articular el razonamiento en voz alta.
- El compromiso no es obvio: aceptas un coste real (latencia, superficie de privacidad, carga operativa) a propósito.
Ese cuarto punto es el nuevo. Cuando un humano escribe código, el razonamiento deja huellas: mensajes de commit, argumentos en los PR, la forma misma del intento. Cuando lo escribe un asistente, el razonamiento existe solo en tu cabeza, brevemente, y luego en ninguna parte. El ADR es el artefacto que hace posible la revisión, porque le da a los revisores algo contra lo que comprobar el código. Sin él, la revisión degenera en comentarios de estilo mientras la arquitectura se desvía.

Decisiones reversibles e irreversibles en el diseño de sistemas
La pregunta más útil del kit del arquitecto es esta: ¿cuánto cuesta cambiar de opinión? Algunas decisiones son puertas de dos sentidos. Un formato de log, la firma de una función interna, un TTL de caché: puedes deshacerlas cualquier tarde. Otras son puertas de un solo sentido. Un contrato de API pública con el que se integran clientes externos. Un esquema de base de datos que ha acumulado seis meses de datos de producción. Un flujo de consentimiento del que depende tu postura legal. Una vez que has cruzado una puerta de un solo sentido, el coste de reconsiderar no es una refactorización: es una migración, un calendario de deprecación y una disculpa.
Clasifica la puerta antes de construir, porque la IA ha abaratado la construcción, pero deshacer sigue siendo tan caro como siempre. Sin restricciones, un asistente diseñará felizmente tu modelo de datos, y el modo de fallo son tablas redundantes, columnas duplicadas y código de migración apilado sobre código de migración, porque cada prompt añade una tabla en lugar de reconsiderar el modelo. Borrar una tabla con datos vivos que leen tres servicios es una de las operaciones más miserables de nuestra industria. La generación barata del esquema es precisamente la razón por la que el esquema merece una reflexión cara. Dedica tu presupuesto de deliberación en proporción a la irreversibilidad, no en proporción a cuánto tarda en escribirse el código: esa proporción se ha invertido.
Mi regla de trabajo: si una decisión toca datos que no puedes recrear o una interfaz de la que dependerá alguien fuera de tu equipo, lleva un ADR y un segundo par de ojos antes de que empiece la implementación. Todo lo demás se publica y se itera. Esta regla escala de un proyecto en solitario a un equipo de plataforma sin cambios, y es la diferencia entre avanzar rápido y avanzar rápido en una dirección de la que no puedes salir.
Cuestionar requisitos como un arquitecto
El núcleo incómodo del trabajo del arquitecto es decirle que no a gente que tiene más poder que tú. “Registrar quién instaló” sonaba a requisito; en realidad era una solución que alguien había imaginado de antemano para el objetivo “medir instalaciones y hacer seguimiento de usuarios nuevos”. Los arquitectos traducen las soluciones de vuelta a objetivos y luego ofrecen un camino más barato hacia ese objetivo. Esa traducción es todo el truco, y ninguna herramienta la hace, porque el diseño entero de una herramienta es cumplir. Algunos ingenieros cargan a su asistente con contexto de usuarios y obtienen un juicio decente, lo cual ayuda en los márgenes, pero el modelo aun así no entrará en una reunión a decirle a marketing que su email de seguimiento no se enviará en el momento de la instalación.
- Devuelve el objetivo, no la solución: “queremos medir instalaciones y llegar a los usuarios nuevos”.
- Ofrece el camino más barato y lo que entrega: registrar marcas de tiempo mide las instalaciones perfectamente.
- Nombra lo que realmente cuesta la vía cara: fricción de consentimiento, una ruta de instalación acoplada, filas que marketing no puede usar.
- Dales una elección real: “si el email importa, lo pedimos en la pantalla de bienvenida; aquí está la versión de un día”.
- Escribe lo que se decida, para que la siguiente persona no vuelva a discutirlo desde cero.
Ahora la objeción honesta, porque merece atención: nadie te ascendió. La versión más probable es que te estás convirtiendo en el sumidero de responsabilidad de decisiones que tomó un modelo, con el mismo salario y menos de la parte divertida. No creo que eso sea erróneo; creo que es una razón para tomarte en serio el hábito de documentar en lugar de saltártelo. Un rastro de ADRs también es un rastro en papel. Ser la persona que decidió solo es un riesgo cuando no puedes mostrar tu razonamiento. Quien escribió “elegimos marcas de tiempo en lugar de captura de email porque la plataforma restringe los datos de identidad” está cubierto. Quien fusionó lo que emitió el asistente, no.
Desarrollador vs. arquitecto: cuándo gana cada uno
Esto no es un ranking: es un cambio de modo, y la habilidad está en saber qué modo necesita el trabajo que tienes delante. Algunos casos concretos de mi propio backlog:
- Corrección de bug bien especificada, radio de impacto conocido: gana el modo desarrollador. Reproducir, corregir, probar, publicar. La deliberación arquitectónica aquí es procrastinación disfrazada de arquitectura.
- Prototipo que valida una demanda: modo desarrollador. Si funciona, el código se reescribirá; si no, se borrará. Los ADRs para algo desechable son desperdicio.
- Funcionalidad nueva con requisitos difusos: primero modo arquitecto, aunque sea solo una hora. La ambigüedad es donde el impulso generado por IA hace más daño.
- Cualquier cosa que toque dinero, identidad o consentimiento: modo arquitecto, sin excepciones. La asimetría de coste entre construir y deshacer está en su peor momento aquí.
- Cambios de esquema sobre datos en producción o cambios en APIs públicas: modo arquitecto con un ADR, según la regla de reversibilidad.
- Equipo de dos personas, base de código con menos de seis meses: modo desarrollador con un archivo de notas en marcha. La ceremonia completa todavía no aporta nada.
- Dominio regulado o varios equipos consumidores: modo arquitecto con registros, porque el “por qué” lo preguntarán auditores y desconocidos, no amigos.
El modo de fallo en ambas direcciones es quedarse en un solo modo. Los desarrolladores que nunca cambian producen implementaciones elegantes de la cosa equivocada. Los arquitectos que nunca bajan producen diagramas de sistemas que no existen. Las personas que menos me gustaría perder en un equipo son las que hacen ambas cosas en la misma tarde: discuten el modelo de datos a las 10 de la mañana y después corrigen el off-by-one a las 2 de la tarde sin quejarse de que está por debajo de ellas. Si estás construyendo tu proceso de revisión alrededor de la salida de la IA, vale la pena leer sobre cómo las herramientas de programación agéntica estructuran los bucles, el contexto y los permisos, porque el cambio de modo tiene que ocurrir dentro de ese bucle, no después de él.
La IA construirá felizmente la cosa equivocada a alta velocidad, para siempre. El trabajo del arquitecto es decidir cuál es la cosa correcta, y escribir por qué antes de que el razonamiento se evapore.

La recomendación: acepta el ascenso
Mi postura es esta, y no es “depende”: usa por defecto el modo arquitecto para todo lo que toque tu modelo de datos, un contrato externo o tu postura de seguridad, y quédate en modo desarrollador para todo lo contenido. La división no será 50/50: para la mayoría de ingenieros son 20 % de arquitectura y 80 % de construcción, como siempre. Lo que ha cambiado es que construir se volvió rápido y el coste de saltarse ese 20 % subió exactamente en el mismo multiplicador de velocidad. Cuanto más delegues la escritura, más se concentrará tu valor en la parte que no puedes delegar.
El kit inicial son tres hábitos, y puedes instalarlos todos esta semana. Primero, añade una plantilla de ADR a tu repositorio (contexto, decisión, alternativas, consecuencias, media página) y escribe uno la próxima vez que aceptes un compromiso real. Segundo, añade un inventario de acoplamiento de dos minutos a cada épica: qué llama esto, qué lo llama, qué se rompe cuando fallan esas cosas. Tercero, pon la pregunta de reversibilidad en tu plantilla de tickets: “si esto está mal, ¿cuánto cuesta cambiar de opinión?”. Si la respuesta es “una migración y una disculpa”, frena. Si es “una tarde”, no lo hagas.
El trabajo de programar no está desapareciendo: lo que desaparece es el de escribir. Nunca fueron lo mismo, y las personas que se están angustiando en silencio son aquellas cuyo rol se había reducido sin hacer ruido a traducir tickets en sintaxis. Si lees diffs y te preguntas “¿por qué esto está acoplado a una API de identidad?”, ya estabas haciendo el trabajo de arquitecto. El único cambio real es que ahora es oficial, está documentado y es tuyo. Acepta el ascenso.


