Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Refactoring e miglioramento del codice esistente

Lezione 6 di 20 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Trasformare il codice legacy in codice moderno
  2. Refactoring strutturale
  3. Modernizzazione del codice
  4. Miglioramento della qualità
  5. Refactoring basato su pattern
  6. Verifica del refactoring
  7. Punti chiave

Trasformare il codice legacy in codice moderno

Il refactoring è uno dei compiti più dispendiosi in termini di tempo nello sviluppo e raramente il più gratificante: nessuno ti fa i complimenti per aver suddiviso un file da 800 righe. È proprio per questo motivo che si accumula, sprint dopo sprint, fino a diventare la vera causa del tuo rallentamento. Codex riduce ore di lavoro manuale a pochi minuti preservando il comportamento esistente: l’unica cosa che conta davvero in un refactoring.

Refactoring strutturale

Il caso più comune è il file “contenitore” che nessuno osa toccare perché viene importato ovunque.

"Refactor src/utils/helpers.ts: this file is 800 lines long. 
Split it into thematic modules in src/utils/ (string.ts, 
date.ts, validation.ts, formatting.ts). Update all imports 
across the project."

Codex gestisce eccezionalmente bene questa famiglia di compiti: identifica le funzioni, le raggruppa per tema, crea i nuovi file e aggiorna quindi tutti gli import nell’intero progetto. Quest’ultimo passaggio è solitamente ciò che scoraggia il refactoring manuale: quaranta file da correggere, un import dimenticato e la build si interrompe nel momento peggiore. Inoltre, il risultato è oggettivamente verificabile: se i test passavano prima e passano ancora, la suddivisione è corretta.

Modernizzazione del codice

L’altro caso principale riguarda l’aggiornamento a pattern moderni, dove la trasformazione è meccanica ma così ripetitiva da finire costantemente rimandata nel backlog.

"Migrate all callbacks in src/lib/database.ts to 
async/await. Preserve existing error handling."

Il punto di partenza è un JavaScript basato su callback con la sua gestione degli errori a cascata:

function getUser(id, callback) {
  db.query("SELECT * FROM users WHERE id = ?", [id], 
    (err, rows) => {
      if (err) return callback(err);
      callback(null, rows[0]);
    });
}

Ecco cosa produce Codex:

async function getUser(id: string): Promise<User> {
  const rows = await db.query(
    "SELECT * FROM users WHERE id = ?", 
    [id]
  );
  return rows[0];
}

Sono accadute tre cose in un’unica passata: sono apparsi i tipi TypeScript, le callback hanno lasciato spazio ad async/await e la gestione degli errori si è semplificata poiché le eccezioni ora si propagano naturalmente. La logica di business rimane identica ed è esattamente questo che devi verificare in fase di revisione, non l’eleganza del risultato.

Miglioramento della qualità

Puoi anche mirare a una specifica dimensione della qualità piuttosto che a una trasformazione sintattica, a patto di elencare i requisiti.

"In src/api/, improve error handling:
- Replace generic try/catch blocks with typed errors
- Add appropriate HTTP error codes
- Add logging with request context
- Ensure Prisma errors are mapped correctly"

Formulato in questo modo, la richiesta diventa verificabile punto per punto durante la revisione. Un prompt generico come “migliora la gestione degli errori” produrrebbe qualcosa di plausibile ma inutilizzabile, perché né tu né l’agente sapreste quando l’obiettivo è stato raggiunto.

Refactoring basato su pattern

La variante più potente consiste nell’indicare un file già conforme e richiederne la generalizzazione.

"All React components in src/components/ that use 
useState for forms must migrate to react-hook-form. 
Apply the same pattern as src/components/LoginForm.tsx, 
which is already migrated."

Codex legge il componente di riferimento, estrae il pattern e lo applica ai componenti target gestendo i casi limite (validazione personalizzata, effetti collaterali) invece di effettuare una sostituzione cieca. L’implicazione pratica è interessante: il primo componente, quello che migri tu stesso, ripaga tutti gli altri. Investi cura in questo file modello; vale quanto una specifica.

Verifica del refactoring

Codex esegue i test dopo ogni refactoring, ma un refactoring che supera i test non è necessariamente pronto per la produzione. Quattro controlli costituiscono il minimo indispensabile e ciascuno affronta un rischio diverso.

ControlloComandoCosa verifica
Test unitarinpm run testComportamento preservato
Tipinpx tsc --noEmitAssenza di errori di tipo
Lintingnpm run lintRispetto delle convenzioni
Buildnpm run buildPronto per la produzione

Il caso tipico che giustifica questo elenco: lo spostamento di file lascia i test verdi perché importano da un file barrel, ma rompe la build di produzione a causa di un import circolare che nient’altro rivela. Aggiungi questi quattro comandi al tuo file AGENTS.md e Codex li eseguirà dopo ogni modifica senza che tu debba pensarci o ricordarglielo.

Punti chiave

  • Il refactoring è il compito in cui Codex offre il maggior risparmio di tempo
  • Fai riferimento a un file modello per guidare il pattern di refactoring
  • Codex aggiorna import e riferimenti in tutto il progetto
  • Verifica sempre con test, controllo dei tipi e build dopo un refactoring
  • Documenta i comandi di verifica in AGENTS.md