Dal codice scritto a mano al software gestito dall'IA: DHH riscrive una libreria Python con Claude

Introduzione

Un anno fa, il fondatore di Rails, David Heinemeier Hansson (DHH), era uno degli sviluppatori più noti a difendere il piacere di scrivere codice a mano.

Oggi, la sua posizione è radicalmente diversa.

Dopo aver trascorso più tempo con Claude Code e Codex, DHH ha recentemente usato Claude Fable 5 per riscrivere la libreria Python TerminalTextEffects in Rust. Secondo l'articolo originale, il progetto ha consumato circa 11 milioni di token, ed è stato realizzato principalmente tramite flussi di lavoro di agenti autonomi.

I risultati sono notevoli: il tempo di avvio è passato da 87 millisecondi a 2 millisecondi, con un miglioramento della velocità di rendering di circa 9,6 volte.

Questo esperimento solleva anche una questione più ampia. Se un programmatore esperto può affidare un progetto di riscrittura su larga scala ad agenti IA e ottenere risultati utilizzabili con un intervento diretto minimo, cosa dovranno davvero fare i programmatori tra cinque anni?

Consegnare la tastiera all'IA e poi ritirarsi?

Il contrasto tra DHH e la sua posizione dell'anno scorso è evidente.

Nel maggio 2025, ha pubblicato "Programmare dovrebbe essere una sensazione!", sostenendo che l'IA dovrebbe essere più simile a un programmatore di coppia: adatta per consultare le API, rispondere a domande e aiutare a risolvere problemi specifici, ma non dovrebbe sostituire l'atto stesso di scrivere codice.

L'articolo originale cita una posizione ancora più netta: se gli sviluppatori alla fine dovessero consegnare completamente la tastiera all'IA, DHH ha dichiarato che preferirebbe ritirarsi.

In una conversazione di sei ore con Lex Fridman, DHH ha anche descritto la sensazione di perdere la "memoria muscolare" quando l'IA genera ripetutamente codice per lui.

Un esempio riguardava la creazione di una distribuzione Linux. Ha fatto generare all'IA la stessa istruzione condizionale Bash più volte, ma si è reso conto che, non avendola mai scritta manualmente, non sentiva di averla realmente imparata.

Questo gli ha posto una domanda più profonda: la programmazione assistita dall'IA indebolirà gradualmente il modo in cui gli sviluppatori imparano l'ingegneria del software?

Ma secondo l'articolo originale, entro aprile 2026 la sua posizione si è spostata verso flussi di lavoro agent-first.

Oggi discute apertamente: come sarà lo sviluppo software quando la tastiera non sarà più l'interfaccia principale?

Claude Fable 5 smonta una libreria Python e la ricostruisce in Rust

Il progetto scelto da DHH è TerminalTextEffects (TTE), un motore di effetti visivi per terminale utilizzabile sia come applicazione a riga di comando che come libreria Python.

TTE offre movimento del testo, colori, gradienti, animazioni e altri effetti visivi per terminale. Il suo repository pubblico lo descrive come un motore di effetti visivi per terminale e documenta l'uso sia come CLI che come libreria Python.

L'articolo originale afferma che DHH ha chiesto a Claude di riscrivere il progetto in Rust.

Il progetto Rust risultante si chiama ttfx ed è stato collocato sotto l'organizzazione Omarchy di DHH. Secondo l'articolo, la nuova versione supporta 37 effetti, è impacchettata come un eseguibile di circa 3 MB e non richiede un runtime Python.

L'esecuzione riportata è durata circa 3 ore e 11 minuti.

L'implementazione in Rust contiene circa 21.000 righe di codice principale, una dimensione vicina a quella della versione Python originale.

Il flusso di lavoro è anche radicalmente diverso dal tradizionale "autocompletamento IA".

L'articolo originale menziona che otto agenti hanno lavorato in parallelo su branch indipendenti. Ogni agente leggeva il codice, generava l'implementazione, compilava i risultati, eseguiva i test, correggeva i fallimenti e poi passava al ciclo successivo.

In questo senso, la descrizione di "completato in un colpo solo" non significa che l'IA abbia prodotto tutto con un'unica generazione. Piuttosto, significa che DHH ha consegnato il compito e ha lasciato che gli agenti si assumessero il ciclo di sviluppo da soli.

A Codex è stato affidato lo stesso compito

DHH ha ripetuto l'esperimento con Codex.

Secondo l'articolo originale, un singolo prompt è bastato per produrre un altro risultato solido. Tuttavia, la versione di Codex ha richiesto circa il 30% di tempo in più e un costo di circa 43 dollari, equivalenti a circa 290 yuan.

Questo confronto è prezioso perché sposta l'attenzione dalla concezione semplicistica che "la programmazione IA sia magica o pessima".

Due diversi agenti di programmazione possono ricevere lo stesso ampio compito e produrre risultati utilizzabili, pur differendo in velocità, costi e comportamento del flusso di lavoro.

Anche il team di Anthropic ha notato questo esperimento.

Secondo quanto riportato, il creatore di Claude Code, Boris Cherny, ha risposto pubblicamente ai risultati, mentre il ricercatore di Anthropic Thariq ha chiesto a DHH quanto lavoro di pianificazione o progettazione del flusso di lavoro avesse investito nella riscrittura.

La risposta di DHH è stata probabilmente la parte più sorprendente.

Ha detto che ha sostanzialmente lasciato che fosse Claude a elaborare il piano e poi se n'è lavato le mani.

Nessun flusso di lavoro predefinito e meticolosamente progettato, nessuna lunga lista di traguardi definiti manualmente, nessun intervento continuo per guidare il processo.

L'approccio è stato deliberatamente improntato al non intervento.

Un colpo solo non significa alla cieca

C'è una distinzione importante qui.

Un compito di codifica completamente autonomo dipende comunque dal fatto che l'agente abbia informazioni sufficienti per giudicare cosa significhi successo.

L'articolo originale afferma che DHH ha prima chiesto a Claude di elaborare un piano e poi ha lasciato che l'agente eseguisse, testasse e iterasse per conto proprio.

Questo è più simile a delegare un progetto di ingegneria del software che a chiedere a un sistema di autocompletamento di generare le prossime dieci righe di codice.

Questo stile di sviluppo agentico dipende in larga misura da:

• Repository di codice con struttura comprensibile.
• Suite di test automatizzate robuste.
• Comandi di build e esecuzione chiari.
• Capacità di creare branch e unire modifiche.
• Agenti in grado di esaminare i fallimenti e riprovare.

Senza queste fondamenta, l'automazione "in un colpo solo" diventa molto più inaffidabile.

La dimostrazione più grande: la migrazione di un milione di righe di Bun

TerminalTextEffects è ancora un progetto relativamente piccolo.

Pertanto, l'articolo originale indica un caso più grande: Bun, il runtime JavaScript creato da Jarred Sumner.

Bun è stato storicamente costruito attorno a Zig. Nel 2026, la sua codebase ha subito una migrazione significativa verso Rust, con un uso estensivo di agenti di codifica IA.

L'articolo originale descrive questo lavoro come una migrazione di circa un milione di righe, completata in meno di due settimane.

Registri pubblici successivi hanno confermato che la riscrittura in Rust di Bun è stata integrata nel suo repository principale. La pull request su GitHub per la riscrittura è stata unita il 14 maggio 2026, e la migrazione ha sostituito il precedente percorso di build basato su Zig con un'architettura Rust-first.

La migrazione è più sfumata di un semplice "l'IA ha riscritto Bun".

La narrazione pubblica di Jarred Sumner, riassunta da Simon Willison, descrive un flusso di lavoro agenziale complesso che includeva scomposizione dinamica dei compiti, prove a secco, revisioni avversariali e verifiche iterate.

Questa è una distinzione significativa.

Le migrazioni software assistite dall'IA su larga scala richiedono ancora una notevole architettura ingegneristica. La differenza è che, una volta progettati adeguatamente i sistemi circostanti, gran parte del lavoro di implementazione può ora essere delegato agli agenti.

Il costo marginale del codice sta tendendo a zero

L'articolo originale trae da questi esempi una conclusione più ampia.

Con il miglioramento delle capacità degli agenti di codifica, il costo marginale di generare un'altra implementazione continua a diminuire.

Generare codice sta diventando sempre più economico.

Test, refactoring, porting tra linguaggi e iterazione sui difetti possono sempre più essere eseguiti in parallelo dagli agenti.

Questo cambia la struttura dei costi dello sviluppo software.

La domanda non è più semplicemente:

Quanti sviluppatori possiamo assumere per scrivere questo codice?

Diventa sempre più:

Quanti compiti software utili può delegare un singolo sviluppatore a un gruppo di agenti IA?

Questa è la transizione dalla programmazione assistita dall'IA allo sviluppo software gestito dall'IA.

La prossima generazione di programmatori potrebbe essere più simile ad addestratori di draghi

La paura ovvia è che, se ci sono meno persone che scrivono o leggono direttamente il codice, i programmatori scompariranno.

L'articolo originale sostiene che questa conclusione è troppo semplicistica.

"Nessuno scrive codice a mano" non significa "non ci sono programmatori".

La natura del lavoro può trasformarsi.

Invece di passare gran parte della giornata a implementare funzionalità riga per riga, gli sviluppatori potrebbero dedicare più tempo a:

1. Definire ciò che deve essere costruito.
2. Stabilire vincoli e interfacce.
3. Progettare i sistemi di test.
4. Esaminare l'architettura e i compromessi.
5. Verificare che il codice generato dall'IA sia effettivamente corretto.
6. Decidere cosa dovrebbe essere automatizzato e cosa no.

In questo modello, l'abilità scarsa non è più la digitazione della sintassi.

È sapere cosa vale la pena costruire e cosa significa realmente il comportamento corretto.

Quando l'IA scrive codice, cosa diventa prezioso?

Se l'implementazione diventa sempre più economica, altre competenze diventano più preziose.

Giudizio di prodotto

Serve ancora qualcuno che decida quali problemi vale la pena risolvere.

L'IA

Può generare rapidamente dieci implementazioni, ma questo non ti dice quale problema ha valore commerciale, quale compromesso è cruciale, o quale funzionalità dovrebbe essere costruita per prima.

Progettazione di sistema

Gli agenti possono scrivere funzioni e classi, ma i sistemi più grandi richiedono comunque confini, interfacce, modelli di dati, regole di deployment e requisiti di affidabilità.

Test

Più codice l'IA è in grado di generare, più importanti diventano i test automatizzati.

Senza un robusto livello di validazione, aumentare la velocità di scrittura del codice non fa che incrementare la quantità di codice che potrebbe contenere errori.

Direzione tecnica

Qualcuno deve dire all'agente quali vincoli rispettare.

Questo include budget di prestazioni, requisiti di compatibilità, confini di sicurezza, dipendenze e obiettivi di manutenzione a lungo termine.

In altre parole, il ruolo dell'essere umano si sposta verso un livello di astrazione più alto.

In futuro potrebbe trattarsi meno di scrivere codice e più

di guidare

Gli esempi nell'articolo originale indicano una definizione alternativa di programmazione.

Gli sviluppatori potrebbero ancora aver bisogno di comprendere a fondo il codice, ma il prodotto principale non è più necessariamente il file sorgente in sé.

Il prodotto è il sistema di requisiti, vincoli, test e giudizio che consente al software corretto di emergere.

Questo è il motivo per cui gli ingegneri esperti potrebbero mantenere il loro valore anche se la scrittura manuale del codice diventa meno centrale.

Coloro che comprendono architettura, modalità di guasto, esigenze degli utenti e comportamento del sistema saranno più capaci di dirigere agenti di codifica autonomi.

Domande frequenti

DHH ha davvero riscritto una libreria Python usando l'IA?

Secondo l'articolo originale, sì. Il fondatore di Rails, David Heinemeier Hansson, ha usato Claude Fable 5, attraverso un workflow multi-agente altamente permissivo, per riscrivere TerminalTextEffects da Python a Rust.

Cos'è TerminalTextEffects?

TerminalTextEffects (in breve TTE) è un motore di effetti visivi per terminale, disponibile anche come libreria Python. La sua documentazione pubblica descrive effetti per movimento del testo, colori, gradienti, animazioni e altre elaborazioni visive per terminale.

In cosa la riscrittura in Rust differisce dalla normale codifica con IA?

L'articolo originale descrive più agenti che lavorano su branch indipendenti, compilano codice, eseguono test, correggono i fallimenti e integrano i risultati. La differenza chiave è che l'IA ha gestito gran parte del ciclo di sviluppo, non solo suggerendo righe di codice isolate.

Anche Codex ha completato la riscrittura?

L'articolo originale afferma che a Codex è stato assegnato lo stesso compito ampio, ottenendo anche un altro risultato eccellente. Secondo quanto riportato, ha impiegato circa il 30% di tempo in più, con un costo di circa 43 dollari.

Anche Bun è stato riscritto con agenti IA?

Sì. La riscrittura su larga scala di Bun da Zig a Rust è stata completata con un ampio supporto di agenti IA, e il codice risultante in Rust è stato integrato nel repository principale a maggio 2026.

Se l'IA scrive la maggior parte del codice, i programmatori spariranno?

Non necessariamente. Il cambiamento probabile è che i programmatori passino meno tempo a digitare dettagli implementativi e più tempo a definire requisiti, vincoli, architettura, test e criteri di accettazione.

Nei flussi di lavoro di codifica con IA, quali competenze sono più importanti?

Una solida progettazione di sistema, test, debugging, capacità di giudizio sul prodotto e la capacità di definire vincoli chiari diventano particolarmente rilevanti. Sapere come rivedere e validare il codice generato dall'IA è altrettanto cruciale.

Strumenti correlati

• Claude Code: l'ambiente di codifica agentico di Anthropic per lo sviluppo software a livello di repository.
• OpenAI Codex: l'agente di codifica di OpenAI per attività di sviluppo software multi-step.
• TerminalTextEffects: il progetto di effetti terminali in Python discusso nell'articolo originale.
• Bun: un runtime JavaScript che ha completato una riscrittura importante da Zig a Rust nel 2026.
• Rust: il linguaggio di programmazione di sistema usato per riscrivere le implementazioni di TTE e Bun.

Link correlati

• Repository GitHub di TerminalTextEffects: il repository ufficiale del codice sorgente di TTE.
• Documentazione di TerminalTextEffects: documentazione di utilizzo e sviluppo del progetto.
• Repository GitHub di Bun: il repository ufficiale del codice sorgente di Bun.
• Pull request per la riscrittura in Rust di Bun: la pull request integrata per la migrazione da Zig a Rust.
• Sito ufficiale di Rust: documentazione ufficiale e risorse dell'ecosistema del linguaggio Rust.
• Claude Code: informazioni ufficiali sull'agente di programmazione di Anthropic.

Riepilogo

L'esperimento di DHH con TerminalTextEffects è un esempio utile di come gli agenti di programmazione IA possano cambiare l'unità di lavoro del software. Gli sviluppatori non chiedono più all'IA di scrivere una funzione alla volta, ma delegano sempre più interi refactoring e migrazioni a squadre di agenti.

La riscrittura di Bun punta nella stessa direzione su scala più ampia: quando repository, test, strumenti e flussi di lavoro sono sufficientemente robusti, l'IA può ora partecipare a vaste attività di ingegneria del software multi-step.

Il cambiamento più grande potrebbe non essere che l'IA scrive più codice, ma che il lavoro del programmatore si sposta dallo scrivere codice al definire ciò che il codice dovrebbe realizzare e dimostrare che lo realizza effettivamente.