Mga nadagdag:
- Kakayahang magsulat ng mga function, klase at module sa AI na may malinaw na input-output at mga kahulugan ng hadlang
- Kakayahang gamitin ang AI bilang isang pares na kasosyo sa programming at pag-unlad nang sunud-sunod, sa maliliit at nabe-verify na mga bahagi
- Kakayahang mahuli ang logic at edge case error sa pamamagitan ng pag-compile ng code na nabuo ng AI at pagpapatakbo nito na may maliliit na halimbawa
Ang pagpares ng programming ay kapag ang dalawang developer ay gumagawa sa parehong problema, na may isang pagsusulat at ang isa ay nagre-rebisa. Ang coding gamit ang AI ay ang digital na bersyon ng mismong relasyon na ito: itinakda mo ang direksyon, mga hadlang at pamantayan sa pagtanggap; Ang AI ay gumagawa ng mabilis na draft; Ibe-verify mo ang bawat hakbang sa pamamagitan ng pag-compile at pagsubok nito. Ang pinakamalaking bitag dito ay ang sabihin sa AI "isulat mo sa akin ang application na ito mula simula hanggang matapos" at bulag na tanggapin ang isang 200-line block. Ang magandang pares na programming ay nagpapatuloy sa maliliit na hakbang: ang bawat hakbang ay dapat na maunawaan, masusubok at mababalik.
Sa yunit na ito matututunan mo kung paano mag-print ng mga function, klase at module na may malinaw na kontrata ng input-output; Paano gabayan ang AI nang hakbang-hakbang; at makikita natin kung paano mahuli ang logic at edge case error sa pamamagitan ng pagpapatakbo ng code na ginagawa nito na may maliliit na halimbawa. Ang layunin ay hindi bilis, ngunit na-verify na bilis.
Mga Konsepto: Kontrata ng input-output: Isang malinaw na kahulugan ng kung ano ang input ng isang function at kung anong output at error na gawi ang ipinangako nito. Edge case: Input na hindi karaniwan ngunit maaaring aktwal na mangyari (walang laman, zero, negatibo, napakalaki, null). Incremental development: Nagpapatuloy sa maliliit, gumaganang piraso at pagpapatunay sa bawat hakbang.
Printing Code na may Net Contract
Ang batayan ng code ng kalidad ay upang tukuyin nang eksakto ang "kung ano ang gusto mo" bago simulan ang trabaho. Kapag nagsusulat ng function sa AI, bigyan ito ng limang bagay: wika at bersyon, mga uri at kahulugan ng input, output, kundisyon ng error, at mga hadlang (pagganap, pagbabawal sa panlabas na library, istilo). Pinipigilan nito ang AI mula sa paghula.
- Isulat ang kontrata. Input, output, error, hadlang.
- Humingi ng isang maliit na yunit. Isang function na may iisang responsibilidad; Ito ay hindi isang malaking module.
- Humiling ng test block. Magdagdag ng ilang sample run/test sa tabi ng code.
- Mag-compile at tumakbo. Subukan ito gamit ang mga edge case, i-verify ang output sa pamamagitan ng mata.
- Pumunta sa susunod na hakbang. Kapag nakumpirma na ang isang piraso, buuin ito.
Contracted function prompt: "Sumulat ng function para sa TypeScript 5. Layunin: kalkulahin ang kabuuang halaga ng mga item sa isang shopping cart. Input: { price: number, quantity: number }[] array. Output: number (total). Mga Panuntunan: throw Error kung negatibo ang dami o presyo; ibalik ang 0 para sa empty array; round amount sa 2 decimal na lugar para sa decimal na lugar, huwag gumamit ng external na case ng decimal, huwag gumamit ng external na library. presyo, solong item)."
Paggabay sa AI bilang isang Pares
Ang mabuting pag-unlad sa pares na programming ay isang dialogue sa halip na isang malaking kahilingan. Una, hilingin ang balangkas at patakbuhin ito; pagkatapos ay magdagdag ng isang gilid na estado; pagkatapos ay ayusin ang isang bug. Ang diskarte na ito ay nagpapanatili sa code na nauunawaan at binibigyan ka ng kontrol sa bawat hakbang.
Incremental progress prompt: "Magsusulat kami ng reader na nagbabasa ng CSV file at nagko-convert ng mga linya sa isang object. Magpatuloy tayo sa susunod na hakbang nang hindi ko kinukumpirma ang bawat hakbang. Step 1: isulat lang ang skeleton na naghahati sa file sa mga linya at naghihiwalay sa linya ng header. Huwag magdagdag ng uri ng conversion o paghawak ng error. Panatilihin itong maikli, ipaliwanag."
Ipaliwanag at bigyang-katwiran ang code prompt: "Ipaliwanag ang function na isinulat mo lang, hindi linya sa linya, ngunit desisyon ayon sa desisyon: aling desisyon sa disenyo ang ginawa mo at bakit, aling edge case ang iyong hinahawakan at paano, aling mga kaso ang sinasadya mong ibinukod? Maglista ng 3 pagpapalagay sa code na hindi ko dapat palampasin."
Tip: Huwag tanggapin ang code na binuo ng AI nang hindi ito nauunawaan. "Ipaliwanag mo sa akin ito, anong mga pagpapalagay ang ginawa mo?" Ang tanong ay parehong nagpapakita ng mga nakatagong error at nagbibigay-daan sa iyong ipagtanggol ang code na iyon, dahil ang code ay nananatiling iyong responsibilidad. Ang paglalagay ng code na hindi mo naiintindihan sa produksyon ay parang pagpapadala ng kontrata nang hindi ito pinipirmahan.
Mahina Prompt / Malakas na Prompt
WEAK:"Write a sorting function."(Resulta: aling wika, ano ang pinag-uuri-uri, ito ba ay stable, ano ang performance constraint, code na malabo at malamang na hindi akma sa requirement.)STRONG:"Para sa Java 17, sumulat ng isang paraan na nag-uuri ng List<Employee> object muna ayon sa departamento (alphabetical), pagkatapos ay HUWAG ibalik ang listahan ng orihinal (pababang listahan). huling.
Napakahusay na prompt; May kasamang pamantayan sa pag-uuri (dalawang antas), panuntunan sa side effect (pinapalitan ang orihinal), null na gawi, at inaasahan sa pagsubok. Kung wala ang mga detalyeng ito, ang AI ay gumagawa ng isang makatotohanan ngunit hindi tamang solusyon; halimbawa maaari itong masira ang orihinal na listahan at ito ay hahantong sa isang tahimik na error sa ibang lugar.
Pagpapatunay gamit ang Mga Edge Case at Maliit na Sample
Ang code na gumagana sa masayang senaryo ay hindi ang tamang code. Sinasadyang pilitin ang bawat function na ginawa:
Uri ng kaso ng gilid
sample input
inaasahang pag-uugali
walang laman na input
Walang laman ang array/string
Hindi isang error, lohikal na walang laman na resulta
Zero/negatibo
0, -1
Tinukoy at wastong pag-uugali
malaking halaga
Milyun-milyong mga rekord
Overflow/kontrol sa pagganap
null/undefined
nawawalang espasyo
Kinokontrol na error o default
Doble/hindi karaniwan
paulit-ulit, reverse order
tamang resulta
Mga Mini Case
Case 1 — Tahimik na error sa pag-ikot. Nagsusulat ang AI ng isang function na nangongolekta ng pera na may mga uri ng decimal (float); Ang 0.1 + 0.2 ay nagbibigay ng 0.30000000000000004. Nalutas ang error kapag idinagdag ng engineer ang panuntunang "I-round sa 2 digit at gumamit ng buong pennies". Pinipigilan ng 3-line na panuntunan ang libu-libong sentimos ng pagkakaiba sa buwanang pagkakasundo.
Kaso 2 — Side effect trap. Nagsusulat ang AI ng isang paraan na "nag-uuri" ng isang listahan, ngunit binabago ang orihinal na listahan sa lugar. Nangyayari ang hindi inaasahang pag-uugali dahil ang isa pang module ay gumagamit ng parehong listahan. Kung ang hadlang na "baguhin ang orihinal" ay nasa prompt, hindi mangyayari ang error; ay nahuhuli sa pagsusuri ng code at pinipigilan ang 2 oras na pag-debug.
Case 3 — Mga kita ng hakbang-hakbang. Ang isang developer ay nagpi-print ng 150-line na module ng pag-import nang sabay-sabay; Kapag nakakita siya ng pagkakamali, hindi niya mahanap kung saan ito nanggaling. Hinahati ng isa pang developer ang parehong gawain sa 5 maliliit na hakbang, sinusubok ang bawat hakbang sa loob ng 2 minuto at nahuli kaagad ang error sa ika-3 hakbang.
Mga karaniwang pagkakamali
- Pag-print ng malalaking bloke sa isang kahilingan. Mapanganib na code na mahirap maunawaan at isinilang ang pag-debug.
- Humihingi ng code nang hindi nagbibigay ng kontrata. Kung ang input-output-error ay malabo, hulaan ng AI at mali.
- Testing lang yung happy scenario. Kung walang laman, null, negatibo at malaking input ay hindi sinubukan, ang error ay naiwan sa produksyon.
- Pagtanggap nang walang pag-unawa. Ang code na hindi mo isiwalat ay isang utang na hindi mo maaaring ipagtanggol.
- Hindi pinapansin ang mga sensitibong uri tulad ng mga side effect at pera/petsa. Ang float na pera na may walang hanggang kasaysayan ay isang klasikong pinagmumulan ng pagkakamali.
Sa buod
Ang pagsulat ng code gamit ang AI ay disiplinadong pares na programming: malinaw na kontrata, maliliit na hakbang, bumuo at sumubok sa bawat hakbang. Ang pagbibigay ng input-output-error-constraint quartet mula sa simula ay tumutukoy sa kalidad ng code. Ang pagpapaliwanag sa code na ginagawa nito at pagpilit dito gamit ang mga edge case ay nagdudulot sa ibabaw ng mga error na nakatago sa ilalim ng masayang senaryo. Ang pinagmulan ng bilis ay hindi bulag na pagtanggap; ay mabilis na draft at mabilis na pag-verify.
Gawain ng aplikasyon
Pumili ng maliit ngunit tunay na function (hal. kabuuang basket, pagkakaiba ng petsa, pag-parse ng text). Mag-print gamit ang kinontratang function prompt; Magdagdag ng kahit man lang 5 pagsubok na sitwasyon sa tabi nito. Patakbuhin ang code at subukan ang 5 edge case nang may kamalayan, gamit ang talahanayan bilang gabay. Maghanap ng bug sa kahit man lang isang edge case (kung hindi, magdisenyo ng bagong input para pilitin ang function), ayusin ito gamit ang AI, at i-verify sa pamamagitan ng muling pagsusuri kung gumana ang pag-aayos.
checklist
- [ ] Sumulat ako ng kontrata na may kasamang input, output, error at constraints.
- [ ] Binuo ko ang code sa maliliit na hakbang sa halip na isang malaking bloke.
- [ ] Nagdagdag ako ng test/sample run block sa tabi ng code.
- [ ] Sinasadya kong nasubok ang hindi bababa sa 5 edge case.
- [ ] Ipinaliwanag ko ang code sa AI at sinuri ang mga pagpapalagay nito.
- [ ] Itinama ko ang nakitang error at kinumpirma ko ang pag-aayos sa pamamagitan ng muling pagsusuri.