Guadagni:
- Capacità di scrivere funzioni, classi e moduli nell'intelligenza artificiale con chiare definizioni di input-output e vincoli
- Capacità di utilizzare l'intelligenza artificiale come partner di programmazione e di progredire passo dopo passo, in piccole parti verificabili
- Capacità di individuare errori logici e casi limite compilando il codice generato dall'intelligenza artificiale ed eseguendolo con piccoli esempi
La programmazione in coppia è quando due sviluppatori lavorano sullo stesso problema, uno scrive e l'altro rivede. Il coding con l’AI è la versione digitale proprio di questa relazione: sei tu a stabilire la direzione, i vincoli e i criteri di accettazione; L'intelligenza artificiale produce una bozza rapida; Verifichi ogni passaggio compilandolo e testandolo. La trappola più grande qui è dire all’IA “scrivimi questa applicazione dall’inizio alla fine” e accettare ciecamente un blocco di 200 righe. Una buona programmazione di coppia procede a piccoli passi: ogni passo dovrebbe essere comprensibile, verificabile e reversibile.
In questa unità imparerai come stampare funzioni, classi e moduli con un chiaro contratto input-output; Come guidare l'IA passo dopo passo; e vedremo come individuare errori logici e casi limite eseguendo il codice prodotto con piccoli esempi. L’obiettivo non è la velocità, ma la velocità verificata.
Concetti: Contratto input-output: una chiara definizione di quale input riceve una funzione e quale output e comportamento di errore promette. Caso limite: input che non è ordinario ma che può effettivamente verificarsi (vuoto, zero, negativo, molto grande, nullo). Sviluppo incrementale: procedere con piccoli pezzi funzionanti e convalidare ogni passaggio.
Stampa Codice con Contratto Netto
La base del codice di qualità è definire esattamente "cosa vuoi" prima di iniziare il lavoro. Quando scrivi una funzione su AI, fornisci cinque cose: lingua e versione, tipi e significati di input, output, condizioni di errore e vincoli (prestazioni, divieto di libreria esterna, stile). Ciò impedisce all'IA di indovinare.
- Scrivi il contratto. Input, output, errore, vincolo.
- Richiedi una piccola unità. Una funzione con un'unica responsabilità; Non è un modulo enorme.
- Richiedi un blocco di prova. Aggiungi alcune esecuzioni/test di esempio accanto al codice.
- Compila ed esegui. Provalo con casi limite, verifica l'output a occhio.
- Vai al passaggio successivo. Una volta confermato un pezzo, costruisci su di esso.
Prompt della funzione contratta: "Scrivi una funzione per TypeScript 5. Scopo: calcolare la quantità totale di articoli in un carrello. Input: { prezzo: numero, quantità: numero }[] array. Output: numero (totale). Regole: lancia errore se la quantità o il prezzo sono negativi; restituisci 0 per un array vuoto; arrotonda l'importo a 2 cifre decimali per errore decimale. Non utilizzare la libreria esterna. Aggiungi 5 casi di test sotto la funzione (normale, vuoto, quantità negativa, prezzo decimale, singolo articolo)."
Guidare l’intelligenza artificiale come coppia
Un buon progresso nella programmazione in coppia è un dialogo piuttosto che una grande richiesta. Innanzitutto, richiedi lo scheletro ed eseguilo; quindi aggiungi uno stato limite; quindi risolvi un bug. Questo approccio mantiene il codice comprensibile e ti dà il controllo in ogni passaggio.
Prompt di avanzamento incrementale: "Scriveremo un lettore che legge un file CSV e converte le righe in un oggetto. Andiamo PASSO PER PASSO, passando al passaggio successivo senza che io confermi ogni passaggio. Passaggio 1: basta scrivere lo scheletro che divide il file in righe e separa la riga di intestazione. Non aggiungere ancora la conversione del tipo o la gestione degli errori. Sii breve, spiega."
Spiega e giustifica la richiesta del codice: "Spiega la funzione che hai appena scritto, non riga per riga, ma decisione per decisione: quale decisione di progettazione hai preso e perché, quale caso limite hai gestito e come, quali casi hai deliberatamente escluso? Elenca 3 presupposti nel codice che non dovrei perdere."
Suggerimento: non accettare il codice generato dall'intelligenza artificiale senza capirlo. "Spiegami questo, quali ipotesi hai fatto?" La domanda rivela errori nascosti e ti consente di difendere quel codice, poiché il codice rimane di tua responsabilità. Mettere in produzione un codice che non capisci è come inviare un contratto senza firmarlo.
Prompt debole / Prompt forte
DEBOLE: "Scrivi una funzione di ordinamento." (Risultato: quale lingua, cosa viene ordinato, è stabile, qual è il vincolo prestazionale, codice vago e probabilmente non soddisfa i requisiti.) STRONG: "Per Java 17, scrivere un metodo che ordina un oggetto List<Employee> prima per dipartimento (alfabetico), quindi per stipendio (discendente). NON SOSTITUIRE l'elenco originale, restituire il nuovo elenco. Lasciare che il dipartimento null venga per ultimo. Spiegare la complessità di il metodo nella riga di commento specificare aggiungere un blocco di test principale con 4 campioni."
Prompt potente; Include criterio di ordinamento (a due livelli), regola degli effetti collaterali (in sostituzione dell'originale), comportamento nullo e aspettativa del test. Senza questi dettagli, l’intelligenza artificiale produce una soluzione plausibile ma errata; ad esempio potrebbe corrompere l'elenco originale e ciò porterà a un errore silenzioso altrove.
Validazione con casi limite e piccoli campioni
Il codice che funziona nello scenario felice non è il codice corretto. Forza consapevolmente ogni funzione prodotta:
Tipo di caso limite
input del campione
comportamento atteso
ingresso vuoto
Array/stringa vuota
Non un errore, risultato logico vuoto
Zero/negativo
0, -1
Comportamento definito e corretto
grande valore
Milioni di record
Controllo del traboccamento/prestazioni
nullo/indefinito
spazio mancante
Errore controllato o default
Duplicato/insolito
ordine ripetitivo e inverso
risultato corretto
Mini custodie
Caso 1: errore di arrotondamento silenzioso. L'intelligenza artificiale scrive una funzione che raccoglie denaro con tipi decimali (float); 0,1 + 0,2 dà 0,30000000000000004. L'errore viene risolto quando l'ingegnere aggiunge la regola "Arrotonda a 2 cifre e usa i centesimi interi". Una regola a 3 righe impedisce migliaia di centesimi di varianza nella riconciliazione mensile.
Caso 2 – Trappola per effetti collaterali. L'intelligenza artificiale scrive un metodo che "ordina" un elenco, ma modifica l'elenco originale al suo posto. Si verifica un comportamento imprevisto perché un altro modulo utilizza lo stesso elenco. Se nel prompt fosse presente il vincolo "modifica originale", l'errore non si verificherebbe mai; viene bloccato nella revisione del codice e impedisce 2 ore di debug.
Caso 3 — Guadagni passo dopo passo. Uno sviluppatore stampa un modulo di importazione di 150 righe contemporaneamente; Quando trova un errore, non riesce a scoprire da dove provenga. Un altro sviluppatore divide lo stesso lavoro in 5 piccoli passaggi, testa ogni passaggio in 2 minuti e rileva immediatamente l'errore nel 3° passaggio.
Errori comuni
- Stampa di blocchi di grandi dimensioni in un'unica richiesta. Nasce codice rischioso difficile da comprendere ed eseguire il debug.
- Chiedere un codice senza dare un contratto. Se l'errore input-output è ambiguo, l'intelligenza artificiale indovinerà e sbaglierà.
- Sto solo testando lo scenario felice. Se non viene provato l'input vuoto, nullo, negativo e grande, l'errore viene lasciato alla produzione.
- Accettare senza comprendere. Il codice che non divulghi è un debito che non puoi difendere.
- Ignorare tipi sensibili come effetti collaterali e denaro/appuntamento. Il denaro fluttuante con una storia senza tempo è una classica fonte di errore.
In sintesi
Scrivere codice con l'intelligenza artificiale è una programmazione disciplinata in coppia: contratto chiaro, piccoli passaggi, creazione e test ad ogni passaggio. Fornire il quartetto input-output-errori-vincolo fin dall'inizio determina la qualità del codice. Spiegare il codice che produce e forzarlo con casi limite porta in superficie gli errori nascosti sotto lo scenario felice. La fonte della velocità non è l’accettazione cieca; è una bozza rapida e una verifica rapida.
Compito dell'applicazione
Scegli una funzione piccola ma reale (ad esempio totale del carrello, differenza di date, analisi del testo). Stampa utilizzando il prompt della funzione contratta; Aggiungi almeno 5 scenari di test accanto ad esso. Esegui il codice e prova consapevolmente 5 casi limite, utilizzando la tabella come guida. Trova un bug in almeno un caso limite (in caso contrario, progetta un nuovo input per forzare la funzione), correggilo con l'intelligenza artificiale e verifica ripetendo il test che la correzione abbia funzionato.
lista di controllo
- [ ] Ho scritto un contratto che comprende input, output, errori e vincoli.
- [] Ho generato il codice in piccoli passaggi anziché in un grande blocco.
- [ ] Ho aggiunto un blocco di esecuzione test/campione accanto al codice.
- [ ] Ho testato consapevolmente almeno 5 casi limite.
- [] Ho spiegato il codice all'IA e ho rivisto i suoi presupposti.
- [ ] Ho corretto l'errore rilevato e confermato la correzione eseguendo nuovamente il test.