Sviluppatore vs architetto: quando vince ciascuno
Sviluppatore vs architetto non dipende dal titolo: conta chi decide sull'architettura. ADR, accoppiamento e reversibilità per la promozione a sorpresa.

Il mese scorso ho revisionato un diff in cui un assistente di programmazione basato su AI aveva scritto una catena di blocchi try/catch per registrare le nuove installazioni di un'estensione per browser. Prima cercava di prendere l'email dell'utente. Se quella chiamata falliva, ripiegava su un ID utente. Se anche quello falliva, registrava un'alzata di spalle: qualcuno ha installato, non sappiamo chi. Il codice funzionava. Era anche sbagliato, perché la piattaforma aveva da poco stretto le maglie sui dati d'identità che un'estensione può richiedere. La domanda sviluppatore vs architetto si nasconde nei diff come questo, e nessuno ti ha mandato il promemoria su da che parte stai adesso.
La risposta giusta non era un catch block migliore. Era registrare un timestamp, mostrare una schermata di benvenuto e dire al marketing che non può avere l'email al momento dell'installazione, a meno che l'utente non la fornisca in seguito. Nessun modello prende questa decisione, perché il modello non conosce i tuoi utenti, le policy della piattaforma o gli obiettivi trimestrali del team marketing. Fa esattamente quello che chiedi, a una velocità spaventosa. Il che significa che chi chiede, cioè tu, è appena diventato responsabile di qualcosa di più grande del codice. Complimenti per la promozione. Scusa se nessuno te l'ha detto.
C'è un controargomento sensato: molti ingegneri ti diranno che in ogni lavoro avuto si aspettava da loro di contestare i requisiti e progettare il modello dei dati per qualsiasi ticket prendessero in carico. Vero: nei team validi questo è sempre stato il lavoro. Ma qualcosa di reale è cambiato. La velocità di digitazione era un freno naturale alle idee sbagliate. Quando un piano mediocre costa tre giorni di implementazione, ci pensi prima. Quando costa novanta secondi, il piano viene costruito prima che qualcuno abbia avuto il pensiero. L'attrito che un tempo obbligava a ragionare sull'architettura è scomparso, e non è stato sostituito da nulla, tranne che da te.
Sviluppatore vs architetto: due lavori diversi
Ecco il modo più netto che conosco per descrivere la differenza. Uno sviluppatore prende un ticket e si chiede come. Un architetto guarda lo stesso ticket e si chiede se debba esistere e in quale forma. Lo sviluppatore ottimizza entro i vincoli. L'architetto sceglie i vincoli e, soprattutto, risponde delle conseguenze di quella scelta per i prossimi due anni. Entrambi fanno ingegneria vera. Sono solo lavori diversi, e falliscono in modi diversi. Il fallimento di uno sviluppatore è un bug. Il fallimento di un architetto è un modello dei dati con tabelle ridondanti sulle quali, quando qualcuno se ne accorge, hanno già costruito tre team.
Gli strumenti di programmazione con AI si sono sistemati silenziosamente sul sedile dello sviluppatore. Sono il junior più veloce che tu abbia mai assunto: instancabili, fluenti e del tutto restii a dirti che il tuo requisito è il vero problema. Chiedi il logging delle installazioni per utente e otterrai il logging delle installazioni per utente, con una cascata di fallback per assicurarsi che «funzioni» anche quando la piattaforma non lo vuole. Il modello non ha alcun interesse per il budget di latenza della tua app, per la tua postura sulla privacy o per la tua reperibilità. Non è un difetto dello strumento. È la descrizione del ruolo del sedile che ha occupato, il che significa che l'altro sedile, quello che dice di no, è vuoto finché non ti ci siedi tu.
Quindi com'è davvero sedersi lì? Sostanzialmente tre cose. Conoscere i tuoi utenti abbastanza bene da notare quando un requisito contraddice i loro interessi. Conoscere l'accoppiamento del sistema abbastanza da vedere il raggio d'impatto di una modifica di una riga. E avere il coraggio di affrontare la conversazione scomoda con chi ha scritto il requisito, prima che il codice esista, non in una postmortem. Nessuna di queste richiede diagrammi con scatole e frecce in una wiki che nessuno legge. Tutte richiedono un giudizio che non può essere delegato a uno strumento che non controbatte mai.
Decisioni architetturali che stai già prendendo
Non serve il titolo per prendere decisioni architetturali: le prendi ogni settimana, dentro ticket ordinari. Dove vive la validazione (client, API o database). Se una chiamata è sincrona o accodata. Cosa viene registrato e cosa volutamente no. La struttura di una nuova tabella e le chiavi esterne che punta. Ognuna di queste è una scommessa sul futuro, e ognuna vincola o abilita i prossimi dieci ticket. Il diff sul logging delle installazioni sembrava un task di monitoraggio. In realtà era una decisione sulla privacy, una decisione di sicurezza e una decisione di prodotto travestita da riga di codice.
Ecco il prima: quello che ha prodotto l'assistente, implementando fedelmente «registra chi ha installato»:
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");
}
Quindici righe, tre modalità di fallimento e uno schema che deve accogliere per sempre email, userId o nessuno dei due. Ogni fallback accoppia silenziosamente il percorso di installazione a un'API di identità, quindi un'interruzione in un servizio soggetto al consenso può ora rallentare o rompere il tuo funnel di onboarding. E la riga che dice «qualcuno ha installato, non sappiamo chi» è analiticamente inutile: non dice al marketing nulla su cui possa agire. Il requisito è stato soddisfatto alla lettera e vanificato nello spirito.
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.
}
Il dopo sono quattro righe. Ma nota cosa è cambiato davvero: non il codice, il requisito. L'obiettivo non è mai stato «catturare un'email», ma «misurare le installazioni e ricontattare i nuovi utenti». Un timestamp misura le installazioni. La schermata di benvenuto, dove l'utente sta già guardando una superficie di consenso, è il posto giusto per chiedere l'email, in modo asincrono, dove un fallimento non costa nulla. La mossa dell'architetto non è stata scrivere meno codice. È stata rinegoziare a cosa serve il codice.
Un'abitudine che vale la pena costruire: prima di ogni modifica non banale, fai un inventario dell'accoppiamento di due minuti. Chiediti cosa chiamerà questo codice, cosa lo chiamerà e cosa si rompe quando ciascuna di queste dipendenze è lenta, giù o deprecata. Nella versione «prima», il percorso di installazione dipendeva da due servizi di identità di cui non avrebbe dovuto sapere nulla. Nella versione «dopo», dipende da una sola tabella. Quel conteggio delle dipendenze, non le righe di codice né la complessità ciclomatica, è il numero che predice i tuoi incidenti futuri. Abbiamo visto lo stesso schema nel modo in cui gli assistenti di programmazione con AI falliscono in modi prevedibili e verificabili: l'output è localmente plausibile e globalmente accoppiato.
ADR vs conoscenza tacita: quando vince ciascuna
Un Architecture Decision Record è volutamente noioso: una pagina con il contesto, la decisione, le alternative considerate e le conseguenze accettate. Tutto qui. Niente cerimonie, niente flusso di approvazione a meno che tu non lo voglia. Gli ADR sono passati da «carino da avere» a obbligatori nell'era dell'AI per via della memoria. Il modello non ne ha. Tra sei mesi qualcuno indirizzerà un assistente sul modulo di installazione, chiederà una modifica, e il ragionamento accurato su consenso e policy di piattaforma sarà evaporato, a meno che non sia scritto dove sia gli umani sia gli strumenti possano trovarlo. Un ADR nel repository viene letto da chiunque (o qualunque cosa) tocchi il codice dopo.
La conoscenza tacita vince davvero in alcune situazioni, e fingere il contrario è il motivo per cui gli ADR hanno assunto una reputazione burocratica. Un team di due persone che costruisce un prototipo con una vita di poche settimane non ha bisogno di registri delle decisioni: chi decide siede uno accanto all'altro e il codice verrà comunque riscritto. Il contesto verbale è più veloce, più ricco ed economico a quella scala. Il problema è che i team raramente si accorgono del momento in cui superano la soglia: la prima nuova assunzione, il primo team che consuma la tua API, il primo incidente in cui «perché l'abbiamo fatto così?» non ha risposta.
- La decisione è costosa da invertire: modifiche allo schema su dati in produzione, contratti di API pubbliche, vendor lock-in.
- La decisione attraversa il confine di un team, quindi le persone coinvolte non sono nella stanza quando viene presa.
- Senti già la domanda futura: «ma perché diavolo l'abbiamo fatto così?»
- Uno strumento di AI ha generato l'implementazione, quindi nessun umano ha mai dovuto spiegare il ragionamento ad alta voce.
- Il compromesso non è ovvio: stai accettando di proposito un costo reale (latenza, superficie sulla privacy, carico operativo).
Quel quarto punto è quello nuovo. Quando un umano scrive codice, il ragionamento lascia tracce: messaggi di commit, discussioni nelle PR, la forma stessa del tentativo. Quando lo scrive un assistente, il ragionamento esiste solo nella tua testa, per un attimo, e poi da nessuna parte. L'ADR è l'artefatto che rende possibile la revisione, perché offre ai revisori qualcosa con cui confrontare il codice. Senza di esso, la revisione degenera in osservazioni di stile mentre l'architettura va alla deriva.

Decisioni reversibili vs irreversibili nel system design
La domanda più utile nella cassetta degli attrezzi dell'architetto è questa: quanto costa cambiare idea? Alcune decisioni sono porte a doppio senso. Un formato di log, la firma di una funzione interna, un TTL di cache: si tornano indietro in un pomeriggio qualunque. Altre sono porte a senso unico. Un contratto di API pubblica con cui integrano client esterni. Uno schema di database che ha accumulato sei mesi di dati di produzione. Un flusso di consenso da cui dipende la tua posizione legale. Una volta attraversata una porta a senso unico, il costo di riconsiderare non è un refactoring: è una migrazione, un piano di deprecazione e delle scuse.
Classifica la porta prima di costruire, perché l'AI ha reso la costruzione economica, mentre disfare resta costoso come sempre. Lasciato senza vincoli, un assistente progetterà volentieri il tuo modello dei dati e il fallimento tipico sono tabelle ridondanti, colonne duplicate e codice di migrazione sovrapposto a codice di migrazione, perché ogni prompt aggiunge una tabella invece di riconsiderare il modello. Eliminare una tabella con dati vivi che tre servizi leggono è una delle operazioni più penose del nostro settore. La generazione economica dello schema è proprio il motivo per cui lo schema merita una riflessione costosa. Distribuisci il tuo budget di deliberazione in proporzione all'irreversibilità, non in proporzione al tempo necessario per scrivere il codice: quel rapporto si è invertito.
La mia regola pratica: se una decisione tocca dati che non puoi ricreare, o un'interfaccia da cui dipenderà qualcuno fuori dal tuo team, si fa un ADR e si chiede un secondo paio d'occhi prima di iniziare l'implementazione. Tutto il resto viene rilasciato e iterato. Questa regola scala da un progetto personale a un platform team senza modifiche, ed è la differenza tra muoversi velocemente e muoversi velocemente in una direzione da cui non puoi tornare indietro.
Contestare i requisiti da architetto
Il nucleo scomodo del lavoro dell'architetto è dire di no a persone che hanno più autorità di te. «Registra chi ha installato» suonava come un requisito; in realtà era una soluzione che qualcuno aveva immaginato in anticipo per l'obiettivo «misurare le installazioni e ricontattare i nuovi utenti». Gli architetti traducono le soluzioni di nuovo in obiettivi, poi offrono un percorso più economico verso l'obiettivo. Questa traduzione è il trucco intero, e nessuno strumento la fa, perché il progetto stesso dello strumento è conformarsi. Alcuni ingegneri caricano il proprio assistente con il contesto utente e ne ricavano un giudizio discreto: aiuta ai margini, ma il modello non entrerà mai in una riunione per dire al marketing che la loro email di follow-up non partirà al momento dell'installazione.
- Riformula l'obiettivo, non la soluzione: «vogliamo misurare le installazioni e raggiungere i nuovi utenti».
- Proponi il percorso più economico e cosa fornisce: il logging dei timestamp misura perfettamente le installazioni.
- Dichiara quanto costa davvero il percorso costoso: attrito sul consenso, un percorso di installazione accoppiato, righe che il marketing non può usare.
- Dai loro una scelta reale: «se l'email conta, la chiediamo nella schermata di benvenuto, ecco la versione da un giorno».
- Scrivi per iscritto ciò che viene deciso, così la persona successiva non rimette tutto in discussione da zero.
Ora l'obiezione onesta, perché merita spazio: nessuno è stato promosso. La versione più probabile è che tu stia diventando il pozzo di responsabilità per decisioni prese da un modello, allo stesso stipendio, con meno della parte divertente. Non credo sia sbagliato: credo sia un motivo per prendere sul serio l'abitudine di documentare invece di saltarla. Una traccia di ADR è anche una traccia cartacea. Essere l'umano che ha deciso diventa un rischio solo quando non riesci a mostrare il tuo ragionamento. Chi ha scritto «abbiamo scelto i timestamp invece della cattura dell'email perché la piattaforma limita i dati d'identità» è coperto. Chi ha fatto il merge di qualunque cosa l'assistente abbia prodotto, no.
Sviluppatore vs architetto: quando vince ciascuno
Questa non è una classifica: è un cambio di modalità, e l'abilità sta nel capire quale modalità richiede il lavoro che hai davanti. Alcuni casi concreti dal mio backlog:
- Bug fix ben specificato, raggio d'impatto noto: vince la modalità sviluppatore. Riproduci, correggi, testa, rilascia. La riflessione architetturale qui è procrastinazione con la giacca.
- Prototipo per validare una domanda: modalità sviluppatore. Il codice verrà riscritto se funziona e cancellato se non funziona. Gli ADR per un usa e getta sono sprecati.
- Funzionalità greenfield con requisiti sfumati: prima la modalità architetto, anche solo per un'ora. Le zone sfumate sono dove lo slancio generato dall'AI fa più danni.
- Qualsiasi cosa tocchi denaro, identità o consenso: modalità architetto, senza eccezioni. L'asimmetria di costo tra costruire e disfare è al suo peggio proprio qui.
- Modifiche di schema su dati in produzione o modifiche di API pubbliche: modalità architetto con un ADR, secondo la regola della reversibilità.
- Team di due persone, codebase più giovane di sei mesi: modalità sviluppatore con un file di note in continuo aggiornamento. La cerimonia completa non serve ancora.
- Dominio regolamentato o più team consumatori: modalità architetto con registrazioni, perché il «perché» lo chiederanno revisori e sconosciuti, non amici.
Il modo di fallire, in entrambe le direzioni, è restare in una sola modalità. Gli sviluppatori che non passano mai alla modalità architetto consegnano implementazioni eleganti della cosa sbagliata. Gli architetti che non tornano mai alla modalità sviluppatore producono diagrammi di sistemi che non esistono. Le persone che meno vorrei perdere in un team sono quelle che fanno entrambe le cose nello stesso pomeriggio: discutono del modello dei dati alle 10 e poi sistemano l'off-by-one alle 14 senza lamentarsi che sia sotto di loro. Se stai costruendo il processo di revisione attorno all'output dell'AI, vale la pena leggere di come gli strumenti di programmazione agentica strutturano cicli, contesto e permessi, perché il cambio di modalità deve avvenire dentro quel ciclo, non dopo.
L'AI costruirà volentieri la cosa sbagliata, a grande velocità, per sempre. Il lavoro dell'architetto è decidere qual è la cosa giusta, e scrivere perché prima che il ragionamento evapori.

La raccomandazione: accetta la promozione
Ecco la mia posizione, e non è un «dipende»: usa per default la modalità architetto per tutto ciò che tocca il tuo modello dei dati, un contratto esterno o la tua postura di sicurezza, e resta in modalità sviluppatore per tutto ciò che è contenuto. La divisione non sarà 50/50: per la maggior parte degli ingegneri sarà 20% di architettura e 80% di costruzione, come è sempre stato. Quello che è cambiato è che la costruzione è diventata veloce e il costo di saltare quel 20% è cresciuto esattamente del moltiplicatore di velocità. Più digitazione deleghi, più il tuo valore si concentra nella parte che non puoi delegare.
Il kit di partenza sono tre abitudini, e puoi installarle tutte questa settimana. Primo, aggiungi un template di ADR al repository: contesto, decisione, alternative, conseguenze, mezza pagina. Scrivine uno la prossima volta che accetti un vero compromesso. Secondo, aggiungi un inventario dell'accoppiamento di due minuti a ogni epic: cosa chiama questo, cosa lo chiama, cosa si rompe quando quelle dipendenze falliscono. Terzo, inserisci la domanda sulla reversibilità nel template dei ticket: «se questo è sbagliato, quanto costa cambiare idea?». Se la risposta è «una migrazione e delle scuse», rallenta. Se è «un pomeriggio», non farlo.
Il lavoro di programmare non sta scomparendo: sta scomparendo il lavoro di digitare. Non sono mai state la stessa cosa, e le persone che si stanno silenziosamente agitando sono quelle il cui ruolo si era silenziosamente ridotto a tradurre ticket in sintassi. Se leggi i diff e ti chiedi «perché questo è accoppiato a un'API di identità», stavi già facendo il lavoro dell'architetto. L'unico vero cambiamento è che ora è ufficiale, è documentato, ed è tuo. Accetta la promozione.


