Vinster:
- Ability to write functions, classes and modules to AI with clear input-output and constraint definitions
- Möjlighet att använda AI som en parprogrammeringspartner och framsteg steg för steg, i små, verifierbara bitar
- Möjlighet att fånga logik- och kantfallsfel genom att kompilera koden som genereras av AI och köra den med små exempel
Parprogrammering är när två utvecklare arbetar med samma problem, där den ena skriver och den andra reviderar. Kodning med AI är den digitala versionen av just denna relation: du anger riktning, begränsningar och acceptanskriterier; AI producerar snabbt utkast; Du verifierar varje steg genom att kompilera och testa det. Den största fällan här är att säga till AI:en "skriv den här applikationen till mig från början till slut" och blint acceptera ett block på 200 rader. Bra parprogrammering sker i små steg: varje steg ska vara begripligt, testbart och reversibelt.
I den här enheten lär du dig att skriva ut funktioner, klasser och moduler med ett tydligt input-output kontrakt; Hur man vägleder AI steg för steg; och vi ska se hur man fångar upp logik- och kantfallsfel genom att köra koden den producerar med små exempel. Målet är inte hastighet, utan verifierad hastighet.
Begrepp: Input-output kontrakt: En tydlig definition av vilken ingång en funktion tar och vilket output och felbeteende den lovar. Kantfall: Indata som inte är vanlig men som faktiskt kan förekomma (tom, noll, negativ, mycket stor, noll). Inkrementell utveckling: Fortsätt med små, arbetande bitar och validera varje steg.
Utskrift av kod med nätkontrakt
Grunden för kvalitetskoden är att definiera exakt "vad du vill ha" innan arbetet påbörjas. När du skriver en funktion till AI, ge den fem saker: språk och version, indatatyper och betydelser, utdata, felförhållanden och begränsningar (prestanda, externt biblioteksförbud, stil). Detta förhindrar AI från att gissa.
- Skriv kontraktet. Ingång, utgång, fel, begränsning.
- Be om en liten enhet. En funktion med ett enda ansvar; Det är ingen stor modul.
- Begär ett testblock. Lägg till några exempelkörningar/tester bredvid koden.
- Kompilera och kör. Prova det med kantfodral, kontrollera resultatet med ögat.
- Gå till nästa steg. När en bit är bekräftad, bygg på den.
Kontrakterad funktionsuppmaning: "Skriv en funktion för TypeScript 5. Syfte: beräkna det totala antalet artiklar i en kundvagn. Inmatning: { pris: antal, kvantitet: antal }[] array. Utdata: antal (totalt). Regler: kast Fel om kvantitet eller pris är negativt; returnera 0 för tom array; avrunda felbelopp till 2. Använd inte decimalt antal decimaler till 2. 5 testfall under funktionen (normal, tom, negativ kvantitet, decimalpris, enstaka artikel)."
Guidande AI som ett par
Goda framsteg i parprogrammering är en dialog snarare än en enda stor begäran. Begär först skelettet och kör det; lägg sedan till ett kanttillstånd; sedan fixa en bugg. Detta tillvägagångssätt håller koden begriplig och ger dig kontroll i varje steg.
Inkrementell framstegsprompt: "Vi kommer att skriva en läsare som läser en CSV-fil och konverterar raderna till ett objekt. Låt oss gå STEG FÖR STEG och gå vidare till nästa steg utan att jag bekräftar varje steg. Steg 1: skriv bara skelettet som delar upp filen i rader och separerar rubrikraden. Lägg inte till typkonvertering eller felhantering ännu.".
Förklara och motivera koduppmaningen: "Förklara funktionen du just skrev, inte rad för rad, utan beslut för beslut: vilket designbeslut du tog och varför, vilket kantfall du hanterade och hur, vilka fall du medvetet uteslöt? Lista upp 3 antaganden i koden som jag inte bör missa."
Tips: Acceptera inte den AI-genererade koden utan att förstå den. "Förklara detta för mig, vilka antaganden gjorde du?" Frågan avslöjar både dolda fel och låter dig försvara den koden, eftersom koden förblir ditt ansvar. Att sätta kod som du inte förstår i produktion är som att skicka ut ett kontrakt utan att skriva på det.
Svag prompt / Stark prompt
SVAG:"Skriv en sorteringsfunktion."(Resultat: vilket språk, vad som sorteras, är det stabilt, vad är prestationsrestriktionen, kod som är vag och förmodligen inte passar kravet.)STARK:"För Java 17, skriv en metod som sorterar ett List<Anställd>-objekt först efter avdelning (alfabetisk), sedan efter lön (Skriv inte tillbaka den nya listan, låt INTE returnera den nya avdelningen). Förklara metodens komplexitet i kommentarsraden, lägg till ett huvudtestblock med 4 exempel."
Kraftfull uppmaning; Inkluderar sorteringskriterier (två nivåer), bieffektregel (ersätter original), nollbeteende och testförväntningar. Utan dessa detaljer producerar AI en rimlig men felaktig lösning; det kan till exempel skada den ursprungliga listan och detta kommer att leda till ett tyst fel någon annanstans.
Validering med kantfodral och små prover
Koden som fungerar i det lyckliga scenariot är inte rätt kod. Tvinga medvetet varje funktion som produceras:
Kantfodral typ
provinmatning
förväntat beteende
tom ingång
Tom array/sträng
Inte ett fel, logiskt tomt resultat
Noll/negativ
0, -1
Definierat och korrekt beteende
stort värde
Miljontals rekord
Overflow/prestandakontroll
null/odefinierad
saknar utrymme
Kontrollerat fel eller standard
Dubblett/ovanligt
repetitiv, omvänd ordning
rätt resultat
Minifodral
Fall 1 — Tyst avrundningsfel. AI skriver en funktion som samlar in pengar med decimaltyper (float); 0,1 + 0,2 ger 0,300000000000000004. Felet löses när ingenjören lägger till regeln "Avrunda till 2 siffror och använd hela pennies". En 3-radsregel förhindrar tusentals öre av avvikelse i den månatliga avstämningen.
Fall 2 — Biverkningsfälla. AI:n skriver en metod som "sorterar" en lista, men modifierar den ursprungliga listan på plats. Unexpected behavior occurs because another module uses the same list. Om "ändra original"-begränsningen fanns i prompten skulle felet aldrig inträffa; fastnar i kodgranskning och förhindrar 2 timmars felsökning.
Fall 3 — Resultat steg för steg. En utvecklare skriver ut en 150-rads importmodul på en gång; När han hittar ett misstag kan han inte hitta var det kom ifrån. En annan utvecklare delar upp samma arbete i 5 små steg, testar varje steg på 2 minuter och fångar felet direkt i det 3:e steget.
Vanliga misstag
- Utskrift av stora block på en begäran. Riskfylld kod som är svår att förstå och felsökning föds.
- Be om en kod utan att ge ett kontrakt. Om input-output-error är tvetydigt kommer AI att gissa och ha fel.
- Testar bara det lyckliga scenariot. Om tom, null, negativ och stor inmatning inte provas lämnas felet till produktionen.
- Acceptera utan att förstå. Koden du inte avslöjar är en skuld du inte kan försvara.
- Ignorera känsliga typer som biverkningar och pengar/datum. Flytande pengar med tidlös historia är en klassisk felkälla.
Sammanfattningsvis
Att skriva kod med AI är disciplinerad parprogrammering: tydligt kontrakt, små steg, bygg och testa vid varje steg. Att ge kvartetten input-output-error-constraint från början avgör kodens kvalitet. Att förklara koden som den producerar och tvinga den med kantfall tar upp de fel som göms under det lyckliga scenariot. Källan till hastighet är inte blind acceptans; är snabbt utkast plus snabb verifiering.
Applikationsuppgift
Välj en liten men verklig funktion (t.ex. korgtotal, datumskillnad, texttolkning). Skriv ut med den kontrakterade funktionsuppmaningen; Lägg till minst 5 testscenarier bredvid. Kör koden och prova 5 kantfall medvetet, använd tabellen som vägledning. Find a bug in at least one edge case (if not, design a new input to force the function), fix it with AI, and verify by retesting that the fix worked.
checklista
- [ ] Jag skrev ett kontrakt som inkluderar input, output, fel och begränsningar.
- [ ] Jag genererade koden i små steg istället för ett stort block.
- [ ] Jag lade till ett test-/provkörningsblock bredvid koden.
- [ ] Jag har medvetet testat minst 5 kantfodral.
- [ ] Jag förklarade koden för AI och granskade dess antaganden.
- [ ] Jag korrigerade det hittade felet och bekräftade korrigeringen genom att testa om.