Winst:
- Mogelijkheid om functies, klassen en modules naar AI te schrijven met duidelijke input-output- en beperkingsdefinities
- Mogelijkheid om AI te gebruiken als een programmeerpartner en stap voor stap vooruitgang te boeken, in kleine, verifieerbare brokken
- Mogelijkheid om logica- en edge-case-fouten op te sporen door de door AI gegenereerde code te compileren en deze uit te voeren met kleine voorbeelden
Bij pair programming werken twee ontwikkelaars aan hetzelfde probleem, waarbij de een schrijft en de ander revisiet. Coderen met AI is de digitale versie van deze relatie: jij bepaalt de richting, beperkingen en acceptatiecriteria; AI produceert een snelle diepgang; Je verifieert elke stap door deze te compileren en te testen. De grootste valkuil hier is om tegen de AI te zeggen “schrijf mij deze applicatie van begin tot eind” en blindelings een blok van 200 regels te accepteren. Een goede paarprogrammering verloopt in kleine stappen: elke stap moet begrijpelijk, testbaar en omkeerbaar zijn.
In deze unit leer je hoe je functies, klassen en modules kunt printen met een duidelijk input-output contract; Hoe je AI stap voor stap begeleidt; en we zullen zien hoe we logica- en edge-case-fouten kunnen opsporen door de code die het produceert uit te voeren met kleine voorbeelden. Het doel is niet snelheid, maar geverifieerde snelheid.
Concepten: Input-output contract: Een duidelijke definitie van welke input een functie nodig heeft en welk output- en foutgedrag deze belooft. Randgeval: invoer die niet gewoon is, maar wel daadwerkelijk kan voorkomen (leeg, nul, negatief, zeer groot, nul). Incrementele ontwikkeling: Doorgaan met kleine, werkstukken en elke stap valideren.
Code afdrukken met nettocontract
De basis van kwaliteitscode is om precies te definiëren “wat je wilt” voordat je aan het werk gaat. Wanneer u een functie naar AI schrijft, geef deze dan vijf dingen: taal en versie, invoertypen en betekenissen, uitvoer, foutcondities en beperkingen (prestaties, verbod op externe bibliotheken, stijl). Dit voorkomt dat de AI gaat raden.
- Schrijf het contract. Invoer, uitvoer, fout, beperking.
- Vraag om een kleine eenheid. Een functie met één verantwoordelijkheid; Het is geen enorme module.
- Vraag een proefblok aan. Voeg een paar voorbeeldruns/tests toe naast de code.
- Compileren en uitvoeren. Probeer het met randgevallen, controleer de uitvoer met het oog.
- Ga naar de volgende stap. Zodra een stuk is bevestigd, bouwt u erop verder.
Gecontracteerde functieprompt: "Schrijf een functie voor TypeScript 5. Doel: bereken het totale aantal items in een winkelwagentje. Invoer: { prijs: aantal, hoeveelheid: aantal }[] array. Uitvoer: aantal (totaal). Regels: gooi een fout als hoeveelheid of prijs negatief is; retourneer 0 voor een lege array; rond het bedrag af op 2 decimalen voor decimale fouten. Gebruik geen externe bibliotheek. Voeg 5 testgevallen toe onder de functie (normaal, leeg, negatieve hoeveelheid, decimale prijs, enkel item)."
AI begeleiden als een paar
Goede vooruitgang bij het programmeren van paren is eerder een dialoog dan één groot verzoek. Vraag eerst het skelet aan en voer het uit; voeg vervolgens een randstatus toe; laat dan een bug repareren. Deze aanpak houdt de code begrijpelijk en geeft u bij elke stap de controle.
Incrementele voortgangsprompt: "We zullen een reader schrijven die een CSV-bestand leest en de regels omzet in een object. Laten we STAP VOOR STAP gaan en doorgaan naar de volgende stap zonder dat ik elke stap bevestig. Stap 1: schrijf gewoon het skelet dat het bestand in regels splitst en de kopregel scheidt. Voeg nog geen typeconversie of foutafhandeling toe. Houd het kort, leg uit."
Leg de codeprompt uit en rechtvaardig deze: "Leg de functie uit die je zojuist hebt geschreven, niet regel voor regel, maar beslissing voor beslissing: welke ontwerpbeslissing je hebt genomen en waarom, welke randgevallen je hebt afgehandeld en hoe, welke gevallen je opzettelijk hebt uitgesloten? Noem 3 aannames in de code die ik niet mag missen."
Tip: Accepteer de door AI gegenereerde code niet zonder deze te begrijpen. “Leg mij dit eens uit, welke aannames heb je gemaakt?” De vraag onthult zowel verborgen fouten als stelt u in staat die code te verdedigen, aangezien de code uw verantwoordelijkheid blijft. Code die u niet begrijpt, in productie nemen, is hetzelfde als het versturen van een contract zonder het te ondertekenen.
Zwakke prompt/sterke prompt
ZWAK:"Schrijf een sorteerfunctie." (Resultaat: welke taal, wat wordt gesorteerd, is het stabiel, wat is de prestatiebeperking, code die vaag is en waarschijnlijk niet aan de vereisten voldoet.) STERK:"Schrijf voor Java 17 een methode die een List<Employee>-object eerst sorteert op afdeling (alfabetisch) en vervolgens op salaris (aflopend). VERVANG NIET de originele lijst, retourneer de nieuwe lijst. Laat nul-afdeling als laatste komen. Leg de complexiteit uit van de methode in de commentaarregel specificeert, voeg een hoofdtestblok toe met 4 monsters."
Krachtige prompt; Inclusief sorteercriterium (twee niveaus), neveneffectregel (ter vervanging van het origineel), nulgedrag en testverwachting. Zonder deze details levert AI een plausibele maar onjuiste oplossing; Het kan bijvoorbeeld de originele lijst beschadigen en dit zal elders tot een stille fout leiden.
Validatie met randgevallen en kleine monsters
De code die in het gelukkige scenario werkt, is niet de juiste code. Forceer bewust elke geproduceerde functie:
Type randbehuizing
voorbeeldinvoer
verwacht gedrag
blanco invoer
Lege array/tekenreeks
Geen fout, logisch leeg resultaat
Nul/negatief
0, -1
Gedefinieerd en correct gedrag
grote waarde
Miljoenen records
Overloop-/prestatiecontrole
nul/ongedefinieerd
ontbrekende ruimte
Gecontroleerde fout of standaard
Dubbel/ongebruikelijk
repetitieve, omgekeerde volgorde
juiste resultaat
Mini-hoesjes
Geval 1 — Stille afrondingsfout. AI schrijft een functie die geld verzamelt met decimale (float) typen; 0,1 + 0,2 geeft 0,30000000000000004. De fout wordt opgelost wanneer de ingenieur de regel "Rond af op 2 cijfers en gebruik hele centen" toevoegt. Een 3-regelige regel voorkomt duizenden centen afwijking in de maandelijkse afstemming.
Geval 2 — Valkuil van bijwerkingen. De AI schrijft een methode die een lijst ‘sorteert’, maar de originele lijst op zijn plaats aanpast. Onverwacht gedrag treedt op omdat een andere module dezelfde lijst gebruikt. Als de beperking "origineel wijzigen" in de prompt stond, zou de fout nooit optreden; raakt verstrikt in codebeoordeling en voorkomt 2 uur foutopsporing.
Geval 3 — Verdiensten stap voor stap. Een ontwikkelaar drukt in één keer een importmodule van 150 regels af; Als hij een fout ontdekt, kan hij niet vinden waar deze vandaan komt. Een andere ontwikkelaar verdeelt hetzelfde werk in 5 kleine stappen, test elke stap in 2 minuten en vangt de fout meteen op in de 3e stap.
Veel voorkomende fouten
- Grote blokken in één keer printen. Risicovolle code die moeilijk te begrijpen en te debuggen is, is geboren.
- Een code vragen zonder een contract te geven. Als de input-output-fout dubbelzinnig is, zal AI raden en ongelijk hebben.
- Even het gelukkige scenario testen. Als lege, null, negatieve en grote invoer niet wordt geprobeerd, wordt de fout aan de productie overgelaten.
- Accepteren zonder te begrijpen. De code die u niet openbaar maakt, is een schuld die u niet kunt verdedigen.
- Het negeren van gevoelige typen zoals bijwerkingen en geld/date. Zwevend geld met een tijdloze geschiedenis is een klassieke bron van fouten.
Samengevat
Code schrijven met AI is gedisciplineerd programmeren in paren: duidelijk contract, kleine stappen, bouwen en testen bij elke stap. Het geven van het invoer-uitvoer-fout-beperkingskwartet vanaf het begin bepaalt de kwaliteit van de code. Door de code die het produceert uit te leggen en deze met randgevallen te forceren, komen de fouten aan het licht die verborgen zijn in het gelukkige scenario. De bron van snelheid is niet blinde acceptatie; is een snelle conceptversie plus snelle verificatie.
Applicatie taak
Kies een kleine maar echte functie (bijvoorbeeld mandtotaal, datumverschil, tekstparsering). Afdrukken met behulp van de gecontracteerde functieprompt; Voeg er minimaal 5 testscenario’s aan toe. Voer de code uit en probeer bewust vijf randgevallen, waarbij u de tabel als richtlijn gebruikt. Zoek een bug in ten minste één randgeval (zo niet, ontwerp dan een nieuwe invoer om de functie te forceren), repareer deze met AI en verifieer door opnieuw te testen of de oplossing werkte.
controlelijst
- [ ] Ik heb een contract geschreven waarin input, output, fouten en beperkingen zijn opgenomen.
- [ ] Ik heb de code in kleine stappen gegenereerd in plaats van in één groot blok.
- [ ] Ik heb een test/sample run-blok toegevoegd naast de code.
- [ ] Ik heb bewust minimaal 5 randgevallen getest.
- [ ] Ik heb de code aan de AI uitgelegd en de aannames ervan beoordeeld.
- [ ] Ik heb de gevonden fout gecorrigeerd en de oplossing bevestigd door opnieuw te testen.