Quando dovresti chiedere a un'IA di scrivere codice da zero rispetto a rivedere o refactorizzare codice esistente?

Question

Accepted Answer

La regola d'oro: lascia che l'IA **scriva** dove gli errori sono economici e ovvi, e usala per **rivedere/refactorizzare** dove gli errori sono costosi o sottili. Il fattore decisivo è quanto ti costa verificare l'output.

## Quando lasciarla scrivere da zero

- **Greenfield e boilerplate** — un nuovo util, un file di configurazione, un endpoint CRUD, una regex. Non c'è contesto nascosto da rompere.
- **API/librerie sconosciute** — l'IA conosce la superficie di una libreria che tu non conosci, e tu verifichi rispetto alla documentazione.
- **Codice temporaneo/prototipo** — la velocità conta più della perfezione.

In questi casi il costo di un bug è basso e puoi leggere il risultato da capo a fondo.

## Quando usarla solo per rivedere/refactorizzare

- **Logica business-critical** — fatturazione, autenticazione, calcoli con denaro. Una risposta sbagliata che sembra plausibile è pericolosa.
- **Codice subtile** — concorrenza, sicurezza, algoritmi pieni di edge case dove "sembra giusto" non significa "è giusto".
- **Grandi sistemi esistenti** — l'IA non riesce a vedere tutti gli invarianti su cui si basa il vostro codebase, quindi generare al suo interno rischia di causare rotture silenziose.

Qui mantieni l'IA come un **secondo paio di occhi**: suggerisce, tu decidi.

```text
                 Cost of a bug LOW          Cost of a bug HIGH
New code          ✅ let AI write           ⚠️ AI drafts, you verify hard
Existing code     ✅ AI refactors           ✅ AI reviews, you write the change
```

## Trade-off e rischi

Scrivere da zero è veloce ma l'IA potrebbe inventare API (**hallucination**) o mancare il contesto che non riesce a vedere. Rivedere è più sicuro ma più lento e vale solo quanto il contesto che fornisci. In ogni caso sei tu l'**autore responsabile** — l'IA è uno strumento, non chi firma il commit.

## Perché è importante

Sbagliare questo è dove lo sviluppo assistito da IA va male: le persone lasciano che l'IA generi logica critica che poi non riescono a verificare completamente, oppure scrivono a mano boilerplate banale che l'IA avrebbe potuto produrre in pochi secondi. Associare la modalità (**scrivi** vs **rivedi/refactorizza**) al **costo di sbagliarsi** ti mantiene veloce su cose economiche e attento su cose pericolose. L'abilità testata è il giudizio su dove spendere il tuo sforzo di verifica — non se sai come fare un prompt a un'IA.