Desenvolvedor vs Arquiteto: Quando Cada Um Vence
Desenvolvedor vs arquiteto não é questão de cargo, e sim de quem decide a arquitetura. ADRs, acoplamento e reversibilidade na sua promoção surpresa.

No mês passado revisei um diff em que um assistente de programação com IA tinha escrito uma cadeia de blocos try/catch para registrar novas instalações de uma extensão de navegador. Primeiro ele tentava pegar o e-mail do usuário. Se isso lançasse erro, caía para um ID de usuário. Se isso lançasse erro também, registrava um encolher de ombros: alguém instalou, não sabemos quem. O código funcionava. Mas estava errado, porque a plataforma tinha apertado recentemente quais dados de identidade uma extensão pode pedir. A questão desenvolvedor vs arquiteto se esconde em diffs exatamente como esse, e ninguém te mandou o memorando sobre de que lado você está agora.
A resposta certa não era um catch melhor. Era registrar um timestamp, mostrar uma tela de boas-vindas e avisar o marketing que eles não podem ter o e-mail no momento da instalação, a não ser que o usuário o forneça depois. Nenhum modelo toma essa decisão, porque o modelo não conhece seus usuários, as políticas da sua plataforma nem as metas trimestrais do time de marketing. Ele faz exatamente o que você pede, em uma velocidade assustadora. Isso significa que quem pede, você, acabou de ficar responsável por algo maior que código. Parabéns pela promoção. Desculpe, ninguém avisou.
Há um contra-argumento razoável: muitos engenheiros vão dizer que todo emprego que tiveram esperava que eles questionassem requisitos e desenhassem o modelo de dados para qualquer ticket que pegassem. É verdade, em bons times esse sempre foi o trabalho. Mas algo real mudou. A velocidade de digitação costumava ser um freio natural para ideias ruins. Quando um plano medíocre custa três dias de implementação, você pensa antes. Quando custa noventa segundos, o plano fica pronto antes de alguém ter tido a ideia. A fricção que antes forçava o pensamento arquitetural acabou, e nada a substituiu além de você.
Desenvolvedor vs Arquiteto: Dois Trabalhos Diferentes
Aqui está a forma mais clara que consigo para explicar a diferença. Um desenvolvedor pega um ticket e pergunta como. Um arquiteto olha para o mesmo ticket e pergunta se ele deveria existir e em que formato. O desenvolvedor otimiza dentro das restrições. O arquiteto escolhe as restrições e, o que é crucial, é dono das consequências dessa escolha pelos próximos dois anos. Ambos são engenharia de verdade. Só são trabalhos diferentes, e falham de maneiras diferentes. Uma falha de desenvolvedor é um bug. Uma falha de arquiteto é um modelo de dados com tabelas redundantes sobre as quais três times já construíram quando alguém finalmente percebe.
Ferramentas de programação com IA se encaixaram discretamente no lugar do desenvolvedor. São o júnior mais rápido que você já contratou: incansável, fluente e completamente incapaz de dizer que o seu requisito é o verdadeiro problema. Peça registro de instalação por usuário e você vai receber registro de instalação por usuário, com uma cascata de fallbacks para garantir que "funcione" mesmo quando a plataforma não quer. O modelo não tem nenhum interesse no orçamento de latência do seu app, na sua postura de privacidade ou na sua escala de plantão. Isso não é um defeito da ferramenta. É a descrição de cargo do lugar que ela ocupou, e isso significa que o outro lugar, o que diz não, fica vago a menos que você se sente nele.
Então, como é de fato sentar nele? Basicamente três coisas. Conhecer bem seus usuários o suficiente para perceber quando um requisito contradiz os interesses deles. Conhecer o acoplamento do seu sistema o suficiente para enxergar o raio de impacto de uma mudança de uma linha. E estar disposto a ter a conversa constrangedora com quem escreveu o requisito, antes que o código exista, não em um postmortem. Nenhuma delas envolve desenhar diagramas de caixas e setas numa wiki que ninguém lê. Todas envolvem um julgamento que não pode ser delegado a uma ferramenta que nunca questiona nada.
Decisões de Arquitetura que Você Já Está Tomando
Você não precisa ter o título para tomar decisões de arquitetura, pois você as toma toda semana, dentro de tickets comuns. Onde fica a validação (no cliente, na API ou no banco). Se uma chamada é síncrona ou enfileirada. O que é registrado e o que deliberadamente não é. O formato de uma nova tabela e a quais chaves estrangeiras ela aponta. Cada uma dessas é uma aposta sobre o futuro, e cada uma restringe ou habilita os próximos dez tickets. O diff de registro de instalação parecia uma tarefa de monitoramento. Na verdade, era uma decisão de privacidade, uma decisão de segurança e uma decisão de produto vestida de uma linha de código.
Aqui está o antes: o que o assistente produziu, implementando fielmente "registrar quem instalou":
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");
}
Quinze linhas, três modos de falha e um schema que precisa acomodar e-mail-ou-userId-ou-nada para sempre. Cada fallback acopla silenciosamente o caminho de instalação a uma API de identidade, então uma queda em um serviço protegido por consentimento agora pode desacelerar ou quebrar o seu funil de onboarding. E a linha que diz "alguém instalou, não sabemos quem" é analiticamente inútil, pois não diz nada que o marketing consiga usar. O requisito foi atendido literalmente e derrotado no espírito.
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.
}
O depois tem quatro linhas. Mas repare no que realmente mudou: não o código, e sim o requisito. O objetivo nunca foi "capturar um e-mail", era "medir instalações e fazer follow-up com novos usuários". Um timestamp mede instalações. A tela de boas-vindas, onde o usuário já está diante de uma superfície de consentimento, é o lugar certo para pedir o e-mail, de forma assíncrona, onde uma falha não custa nada. O movimento do arquiteto não foi escrever menos código. Foi renegociar para que serve o código.
Um hábito que vale a pena criar: antes de qualquer mudança não trivial, faça um inventário de acoplamento de dois minutos. Pergunte o que este código vai chamar, o que vai chamá-lo e o que quebra quando cada um desses estiver lento, fora do ar ou descontinuado. Na versão "antes", o caminho de instalação dependia de dois serviços de identidade que ele não tinha motivo nenhum para conhecer. Na versão "depois", depende de uma tabela. Essa contagem de dependências, não o número de linhas nem a complexidade ciclomática, é o número que prevê seus incidentes futuros. Vimos o mesmo padrão em como assistentes de programação com IA falham de formas previsíveis e testáveis: a saída é localmente plausível e globalmente acoplada.
ADRs vs Conhecimento Tribal: Quando Cada Um Vence
Um Architecture Decision Record é deliberadamente simples: uma página com o contexto, a decisão, as alternativas consideradas e as consequências aceitas. Só isso. Sem cerimônia, sem fluxo de aprovação, a menos que você queira um. A razão de os ADRs terem passado de "bom ter" a obrigatórios na era da IA é a memória. O modelo não tem nenhuma. Daqui a seis meses, alguém vai apontar um assistente para o módulo de instalação, pedir uma mudança, e o raciocínio cuidadoso sobre consentimento e políticas da plataforma terá evaporado, a menos que esteja escrito em um lugar que humanos e ferramentas possam encontrar. Um ADR no repositório é lido por quem (ou o que) tocar no código a seguir.
O conhecimento tribal de fato vence em algumas situações, e fingir o contrário é como os ADRs ganharam fama de burocráticos. Um protótipo de duas pessoas com vida útil medida em semanas não precisa de registros de decisão; quem decide está sentado lado a lado e o código vai ser reescrito de qualquer forma. Contexto verbal é mais rápido, mais rico e mais barato nessa escala. O problema é que os times raramente percebem o momento em que cruzam o limite: a primeira contratação nova, o primeiro time consumindo sua API, o primeiro incidente em que "por que fizemos assim?" não tem resposta.
- A decisão é cara de reverter: mudanças de schema em dados em produção, contratos de API públicos, dependência de fornecedor.
- A decisão cruza a fronteira de um time, então as pessoas afetadas não estão na sala quando ela é tomada.
- Você já consegue ouvir a pergunta futura: "por que diabos fizemos assim?"
- Uma ferramenta de IA gerou a implementação, então nenhum humano precisou articular o raciocínio em voz alta.
- O trade-off não é óbvio: você está aceitando um custo real (latência, superfície de privacidade, carga operacional) de propósito.
Esse quarto item é o novo. Quando um humano escreve código, o raciocínio deixa rastros: mensagens de commit, argumentos de PR, a forma da própria tentativa. Quando um assistente escreve, o raciocínio existe só na sua cabeça, por um instante, e depois em lugar nenhum. O ADR é o artefato que torna a revisão possível, porque dá aos revisores algo contra o que checar o código. Sem ele, a revisão degrada para comentários de estilo enquanto a arquitetura vai à deriva.

Decisões Reversíveis vs Irreversíveis em Design de Sistemas
A pergunta mais útil no kit do arquiteto é esta: quão caro é mudar de ideia? Algumas decisões são portas de duas vias. Um formato de log, a assinatura de uma função interna, um TTL de cache: dá para voltar atrás em qualquer tarde. Outras são portas de mão única. Um contrato de API pública com o qual clientes externos se integram. Um schema de banco que acumulou seis meses de dados de produção. Um fluxo de consentimento do qual sua postura jurídica agora depende. Depois que você atravessa uma porta de mão única, o custo de reconsiderar não é um refactor, é uma migração, um cronograma de descontinuação e um pedido de desculpas.
Classifique a porta antes de construir, porque a IA barateou a construção, mas desfazer continua tão caro como sempre. Sem restrições, um assistente vai projetar seu modelo de dados com prazer, e o modo de falha são tabelas redundantes, colunas duplicadas e código de migração empilhado sobre código de migração, porque cada prompt adiciona uma tabela em vez de reconsiderar o modelo. Apagar uma tabela com dados vivos que três serviços leem é uma das operações mais miseráveis da nossa indústria. A geração barata do schema é exatamente o motivo pelo qual ele merece reflexão cara. Gaste seu orçamento de deliberação em proporção à irreversibilidade, não em proporção ao tempo que o código leva para ser escrito. Essa razão se inverteu.
Minha regra de trabalho: se uma decisão toca dados que você não consegue recriar, ou uma interface da qual alguém fora do seu time vai depender, ela recebe um ADR e um segundo par de olhos antes de a implementação começar. Todo o resto é entregue e iterado. Essa regra escala de um projeto solo para um time de plataforma sem alterações, e é a diferença entre andar rápido e andar rápido numa direção da qual você não consegue sair.
Questionando Requisitos como um Arquiteto
O núcleo incômodo do trabalho do arquiteto é dizer não para quem está acima de você na hierarquia. "Registrar quem instalou" soava como um requisito; na verdade era uma solução que alguém tinha imaginado de antemão para o objetivo "medir instalações e fazer follow-up com novos usuários". Arquitetos traduzem soluções de volta em objetivos e então oferecem um caminho mais barato até o objetivo. Essa tradução é todo o truque, e nenhuma ferramenta faz isso, porque o design inteiro da ferramenta é obedecer. Alguns engenheiros carregam o assistente com contexto de usuário e obtêm um julgamento razoável. Isso ajuda nas margens, mas o modelo ainda não vai entrar numa reunião e dizer ao marketing que o e-mail de follow-up não vai acontecer no momento da instalação.
- Devolva o objetivo, não a solução: "queremos medir instalações e alcançar novos usuários".
- Ofereça o caminho mais barato e o que ele entrega: registrar timestamps mede instalações com perfeição.
- Diga o que o caminho caro de fato custa: atrito de consentimento, um caminho de instalação acoplado, registros que o marketing não consegue usar.
- Dê a eles uma escolha real: "se o e-mail importa, pedimos na tela de boas-vindas. Esta é a versão de um dia disso".
- Escreva o que for decidido, para que a próxima pessoa não reabra a discussão do zero.
Agora a objeção honesta, porque ela merece espaço: ninguém foi promovido. A história mais provável é que você está se tornando o depósito de responsabilidade para decisões que um modelo tomou, pelo mesmo salário, com menos da parte divertida. Não acho que isso esteja errado. Acho que é um motivo para levar o hábito de documentação a sério em vez de pulá-lo. Uma trilha de ADRs também é uma trilha de papel. Ser o humano que decidiu só é uma responsabilidade quando você não consegue mostrar seu raciocínio. Quem escreveu "escolhemos timestamps em vez de captura de e-mail porque a plataforma restringe dados de identidade" está protegido. Quem fez merge do que o assistente emitiu, não está.
Desenvolvedor vs Arquiteto: Quando Cada Um Vence
Isso não é um ranking, é uma troca de modo, e a habilidade está em saber de qual modo o trabalho à sua frente precisa. Alguns casos concretos do meu próprio backlog:
- Correção de bug bem especificada, raio de impacto conhecido: vence o modo desenvolvedor. Reproduzir, corrigir, testar, entregar. Deliberação arquitetural aqui é procrastinação de paletó.
- Protótipo para validar demanda: modo desenvolvedor. O código vai ser reescrito se funcionar e apagado se não funcionar. ADRs para algo descartável são desperdício.
- Feature greenfield com requisitos imprecisos: primeiro o modo arquiteto, mesmo que por uma hora. A imprecisão é onde o embalo gerado por IA causa mais estrago.
- Qualquer coisa que toque dinheiro, identidade ou consentimento: modo arquiteto, sem exceções. A assimetria de custo entre construir e desfazer é pior aqui.
- Mudanças de schema em dados vivos ou mudanças em APIs públicas: modo arquiteto com ADR, pela regra de reversibilidade.
- Time de duas pessoas, codebase com menos de seis meses: modo desenvolvedor com um arquivo de notas corrente. Cerimônia completa não traz nada ainda.
- Domínio regulado ou múltiplos times consumidores: modo arquiteto com registros, porque o "por quê" vai ser perguntado por auditores e desconhecidos, não por amigos.
A falha nos dois sentidos é ficar preso em um modo só. Desenvolvedores que nunca trocam de modo entregam implementações elegantes da coisa errada. Arquitetos que nunca descem produzem diagramas de sistemas que não existem. As pessoas que eu menos gostaria de perder num time são as que fazem os dois no mesmo período: discutem o modelo de dados às 10h, depois corrigem o off-by-one às 14h sem reclamar que isso está abaixo delas. Se você está construindo seu processo de revisão em torno da saída de IA, vale ler sobre como ferramentas de programação agênticas estruturam loops, contexto e permissões, porque a troca de modo precisa acontecer dentro desse loop, não depois dele.
A IA vai construir alegremente a coisa errada, em alta velocidade, para sempre. O trabalho do arquiteto é decidir qual é a coisa certa e escrever por que, antes que o raciocínio evapore.

A Recomendação: Aceite a Promoção
Aqui está minha posição, e não é "depende": adote o modo arquiteto para tudo que toque seu modelo de dados, um contrato externo ou sua postura de segurança, e fique no modo desenvolvedor para tudo que for contido. A divisão não vai ser 50/50. Para a maioria dos engenheiros, são 20% arquitetando e 80% construindo, como sempre foi. O que mudou é que a construção ficou rápida e o custo de pular os 20% subiu exatamente pelo multiplicador de velocidade. Quanto mais da digitação você delega, mais o seu valor se concentra na parte que não pode ser delegada.
O kit inicial são três hábitos, e você pode instalar todos esta semana. Primeiro, coloque um template de ADR no seu repositório (contexto, decisão, alternativas, consequências, meia página) e escreva um na próxima vez que aceitar um trade-off real. Segundo, adicione um inventário de acoplamento de dois minutos a cada épico: o que isso chama, o que chama isso, o que quebra quando essas partes falham. Terceiro, coloque a pergunta de reversibilidade no seu template de ticket: "se isso estiver errado, quanto custa mudar de ideia?" Se a resposta for "uma migração e um pedido de desculpas", desacelere. Se for "uma tarde", não desacelere.
O trabalho de programar não está desaparecendo, o trabalho de digitar, sim. Nunca foram a mesma coisa, e as pessoas em pânico silencioso são aquelas cujo papel tinha encolhido discretamente para traduzir tickets em sintaxe. Se você está lendo diffs e se perguntando "por que isso está acoplado a uma API de identidade?", você já fazia o trabalho de arquiteto. A única mudança real é que agora isso é oficial, está documentado e é seu. Aceite a promoção.


