Mga nadagdag:
- Kakayahang epektibong ilarawan ang isang bug sa AI na may mensahe ng error, stack trace, at pinakamaliit na instance ng reproduction
- Kakayahang magpatakbo ng isang sistematikong daloy ng pag-debug gamit ang AI upang mahanap ang pangunahing dahilan sa pamamagitan ng pag-hypothesize at pagpapaliit nito nang hakbang-hakbang
- Kakayahang i-verify na ang pag-aayos na iminungkahi ng AI ay aktwal na naayos ang problema sa pamamagitan ng muling paggawa at pagsubok ng regression
Ang pag-debug ay ang gawain ng pag-alam kung bakit ang isang programa ay kumikilos nang iba kaysa sa inaasahan at inaayos ito, at ito ay gumagamit ng maraming oras ng karamihan sa mga inhinyero. Ang mahusay na pag-debug ay hindi batay sa isang laro ng paghula, ngunit sa sistematikong pagpapaliit: linawin ang sintomas, hypothesize, subukan ang hypothesis, makarating sa ugat na sanhi. Ang AI ay isang napakalakas na kasosyo sa cycle na ito; Ngunit kung bibigyan mo lamang siya ng tamang impormasyon. Ang pagsasabi ng "code ay hindi gumagana, ayusin ito" ay pinipilit ang AI na hulaan at gumawa ng mga mungkahi. Ibigay dito ang buong mensahe ng error, ang stack trace, at ang pinakamaliit na sample ng reproduction, at magkakasamang makikita mo ang ugat na dahilan.
Sa unit na ito, makikita natin kung paano epektibong ilarawan ang isang bug sa AI, paliitin ang mga hypotheses nang hakbang-hakbang, at i-verify sa pamamagitan ng regression testing na ang iminungkahing pag-aayos ay talagang malulutas ang problema. Tandaan: "pag-aayos" ng bug at "pagpigil sa sintomas ng bug" ay dalawang magkaibang bagay; Ang pagwawasto na ginawa nang hindi hinahanap ang ugat na dahilan ay naglilipat ng error sa ibang lugar.
Mga Konsepto: Stack trace: Isang dump na nagpapakita kung aling mga function ang tinawag sa anong pagkakasunud-sunod sa oras ng error. Minimal repro: Ang pinakasimple, pinakamaikling code/input na nagti-trigger ng error. Root cause: Ang tunay na pinagmulan ng problema, hindi ang sintomas. Pagsusuri ng regression: Pagsubok na tinitiyak na hindi mauulit ang parehong error.
Naglalarawan ng Bug sa AI
Ang posibilidad na mahanap ng AI ang ugat na dahilan ay direktang proporsyonal sa kalidad ng impormasyong ibibigay mo. Kasama sa isang magandang paglalarawan ng error ang: kung ano ang sinubukan mong gawin, kung ano ang iyong inaasahan, kung ano ang nangyari, ang eksaktong error na text at stack trace, ang code na kasangkot, ang kapaligiran (wika/bersyon/OS), at ang pinakamaliit na sample na gumawa ng error.
- Linawin ang sintomas. Sa format na "Inaasahang X, aktuwal na Y".
- I-paste ang buong text ng error at stack trace. Huwag itong paikliin, i-censor ito, ngunit huwag sirain ang istraktura.
- Ibigay ang pinakamaliit na pagpaparami. Minimum na input at code na nagti-trigger ng error.
- Tukuyin ang kapaligiran. Bersyon ng wika, bersyon ng library, runtime environment.
Epektibong prompt para sa paglalarawan ng error: "Nagde-debug ako ng bug. Impormasyon:- Ano ang sinusubukan kong gawin: [X]- Inaasahang pag-uugali: [Y]- Aktwal na pag-uugali: [Z]- Buong mensahe ng error at stack trace: [i-paste]- Environment: [wika/bersyon, library/bersyon]- Minimum na code na kasangkot: [code] Huwag bigyan ako ng direktang pag-aayos. Ilista muna ang posibilidad ng pag-aayos. bawat isa."
Pagpapaliit ng Daloy sa pamamagitan ng Hypothesis
Ang sistematikong pag-debug ay ang sining ng pag-aalis ng mga posibilidad nang paisa-isa. Gamitin ang AI upang bumuo ng mga hypothesis at idisenyo ang eksperimento upang subukan ang bawat hypothesis; Pagkatapos ay patakbuhin ang eksperimento at ibalik ang resulta. Ang cycle na ito ay mas mabilis kaysa sa ugali ng paggawa ng mga random na pagbabago at paghinto, na tinatawag na "shotgun debugging".
Binary search (bisection) helper prompt: "Ang error na ito ay wala kahapon, ito ay nandiyan ngayon. Gusto kong malaman kung alin sa huling 20 pagbabago ang nagdala ng error na may bisect. Bigyan mo ako ng step-by-step na plano: saang punto ko dapat subukan, sa aling kalahati ang dapat kong puntahan depende sa resulta. Sabihin din sa akin kung ano mismo ang susuriin sa bawat hakbang."
Prompt ng diskarte sa pagpasok ng log: "Hindi ko mahanap ang error dahil hindi ko makita ang mga intermediate na halaga sa function na ito. Sabihin sa akin kung aling mga punto ang kailangan kong magdagdag ng mga linya ng log na nagpi-print kung aling mga variable. Magdagdag ng paliwanag na 'ano ang matututunan ko mula sa log na ito' para sa bawat log. Tukuyin din ang mga babala na hahadlang sa akin sa pag-log ng kumpidensyal na data."
Tip: Kung hindi mo mareresolba ang isang error, kadalasan ang problema ay nasa lugar kung saan mali mong inakala. Tanungin ang AI "anong palagay ko ang maaaring mali?" Ang pagtatanong ay masisira ang iyong pagkabulag. Ang pinakamahirap na pagkakamali ay nagtatago sa lugar kung saan mo sinasabing "I'm sure this is working right".
Mahina Prompt / Malakas na Prompt
MAHINA:"Nagbibigay ng error ang aking code, ayusin ito: [200 linya ng code]"(Resulta: Hindi alam ng AI kung anong error ito, kung ano ang inaasahan; nagbibigay ito ng mga pangkalahatang suhestiyon batay sa hula, karamihan sa mga ito ay walang silbi.) MALAKAS:"Nakakuha ako ng NullPointerException. Inaasahan: dapat ibalik ang listahan ng user. Aktwal: Sumasabog sa tawag para makakuha ngUsers:(). 17. Minimum na pag-uulit: Nangyayari ito kapag walang laman ang listahan ng mga user, ngunit hindi kapag puno na ito ng 15 linya: [code].
Inilalagay ng malakas na prompt ang error sa konteksto: kung saan mangyayari ito (walang laman na listahan), kung saan hindi ito mangyayari (buong listahan). Ang nag-iisang pahiwatig na ito ("nangyayari kapag walang laman") ay halos direktang tumuturo sa ugat na dahilan. Dahil hindi available ang impormasyong ito sa mahinang prompt, bulag na hula ang AI.
Pagpapatunay sa Pag-aayos
Ang isang pag-aayos ay isang tunay na pag-aayos lamang kung ito ay gumagawa ng tatlong bagay:
kontrol
Tanong
Paano i-verify
Nawala na ba ang error?
Gumagana ba ang parehong entry ngayon?
Patakbuhin muli ang minimal repro
Walang bagong error?
May sira pa ba?
Patakbuhin ang buong test suite
Hindi ba mauulit?
Magkakaroon ba muli ng parehong error?
Magdagdag ng regression test para sa sitwasyong ito
Ang mga pagwawasto na ginawa nang hindi nahanap ang ugat na sanhi ay kadalasang pinipigilan ang sintomas. Halimbawa, ang pag-gloss sa isang null na error na may "laktawan kung null" ang tunay na dahilan, "bakit ang data ay magiging null?" hindi nakikita, at ang error ay naulit sa ibang lugar.
Mga Mini Case
Kaso 1 — Ang bitag sa pagsugpo ng sintomas. Pinapatahimik ng isang koponan ang paminsan-minsang null error sa pamamagitan ng try-catch; Ang error ay nawawala ngunit pagkatapos ng 2 linggo ang data ay lumilitaw na nawawala. Ang tunay na dahilan ay ang isang serbisyo ay nagbabalik ng null sa timeout. Kapag tinanong mo ang AI "bakit nagiging null?", lalabas ang ugat; Ang tunay na pag-aayos ay tumatagal ng 1 oras ngunit permanente.
Case 2 — Minimal na repro power. Ang isang developer ay hindi maaaring ayusin ang isang bug na nagsasabing "ito ay nag-crash paminsan-minsan." Binabawasan nito ang error sa pinakamaliit na input na may mungkahi ng AI: ang problema ay nangyayari lamang sa mga filename na naglalaman ng mga Turkish na character (error sa pag-encode). Kapag ang 300 linya ng kawalan ng katiyakan ay nabawasan sa 5 linya ng tiyak na repro, nagiging malinaw ang solusyon.
Case 3 — Anti-regression test. Inaayos ng AI ang isang error sa pagkalkula ng petsa. Ang inhinyero ay hindi nasisiyahan dito; nagdaragdag ng regression test para sa maling senaryo (katapusan ng buwan, Enero 31 + 1 buwan). Kapag ang isa pang pagbabago ay tumama sa parehong lugar pagkalipas ng 4 na buwan, ang pagsubok ay nagiging pula at ang bug ay nahuli bago ito umabot sa produksyon.
Mga karaniwang pagkakamali
- Ibig sabihin ay "hindi gumagana, ayusin mo". Nang walang error na text, inaasahan at repro, hula ng AI.
- Hindi nagbibigay ng stack trace. Ang stack trace ay kadalasang direktang nagpapahiwatig ng ugat na sanhi.
- Patuloy na gumawa ng mga random na pagbabago. Ang mga eksperimento nang hindi nagtatatag ng hypothesis ay nag-aaksaya ng oras.
- Pinipigilan ang sintomas at nawawala ang ugat na sanhi. Ang pagkakamali ay muling isilang sa ibang lugar.
- Hindi sinigurado ang pag-aayos gamit ang regression testing. Ang parehong error ay bumalik nang tahimik sa hinaharap.
Sa buod
Ang epektibong pag-debug ay sistematikong pagpapaliit, hindi paghula. Ang pagbibigay sa AI ng buong teksto ng error, stack trace, minimal na pagpaparami at impormasyon sa kapaligiran ay lubos na nagpapataas ng mga pagkakataong mahanap ang ugat na sanhi. Gamitin ang AI upang bumuo ng mga hypothesis at idisenyo ang eksperimento upang subukan ang bawat hypothesis; Patakbuhin mo ang eksperimento. Isaalang-alang ang isang pag-aayos na "tapos na" lamang kapag nakita mo na ang bug ay nawala, walang bagong mga bug na ipinakilala, at ito ay protektado ng regression testing.
Gawain ng aplikasyon
Isaalang-alang ang isang tunay o artipisyal na pagkakamali. Bawasan muna ang error sa pinakamaliit na pagpaparami (kung saan nangyayari ang input, kung saan hindi). Gamit ang epektibong bug recipe prompt, humingi sa AI ng 3 root cause hypotheses at isang hakbang sa pag-verify para sa bawat isa. Hanapin ang ugat na sanhi sa pamamagitan ng pagsubok sa mga hypotheses nang paisa-isa, ayusin ito, pagkatapos ay magsulat at magpatakbo ng regression test para sa senaryo na ito upang ipakita na ang bug ay nawala at ang pagsubok ay nagbibigay ng proteksyon.
checklist
- [ ] Nilinaw ko ang sintomas bilang "expected vs realized".
- [ ] Ibinigay ko ang buong error na text at stack trace sa AI.
- [ ] Binawasan ko ang error sa pinakamaliit na pagpaparami.
- [ ] Sa pamamagitan ng pagsubok sa mga hypotheses isa-isa, natagpuan ko ang ugat na dahilan.
- [ ] Sa halip na pigilan ang sintomas, inayos ko ang ugat.
- [ ] Nagdagdag ako at nagpatakbo ng regression test para sa parehong error.