Humingi ang isang developer sa isang assistant ng isang function na sumusuri kung maaaring mag-download ng ulat ang isang user. Nagko-compile ang code. Nakapasa ang happy-path test. Mukhang maayos ang pull request. Pagkalipas ng dalawang linggo, napansin ng isang kasamahan na sinusuri ng function na naka-sign in ang user, ngunit hindi kailanman sinusuri kung pagmamay-ari nila ang ulat.
Ito ay isang naglalarawang senaryo, hindi isang dokumentadong insidente. Inilalarawan nito ang kakulangan na kailangang tapusin ng pagsasanay sa pagsusuri ng code na binuo ng AI: ang nabuong code na pumasa sa isang pangunahing pagsusuri ay maaari pa ring maglaman ng depekto sa awtorisasyon o concurrency, at kailangang hanapin ito ng taong sumusuri nito at sabihin kung bakit ito mahalaga.
Ang gabay na ito ay para sa mga engineering enablement lead at engineering manager. Saklaw nito kung paano ilarawan ang problema sa pagganap, suriin ang mga kakulangan, paghahanda at pagsasanay sa disenyo, pag-aralan ang isang kaso at suriin kung ang kasanayan ay nalilipat sa mga totoong pagsusuri. Ito ay tungkol sa disenyo ng pagsasanay. Ang bawat depekto, pagsubok at tuntunin sa pagsusuri sa iyong programa ay dapat na mapatunayan ng mga senior engineer at ng iyong security team.
Ano ang pagsasanay sa pagsusuri ng code na binuo ng AI?
Ang pagsasanay sa pagsusuri ng code na binuo ng AI ay nagtuturo sa mga developer na malinaw na magbigay ng payo sa isang assistant, pagkatapos ay suriin at i-audit ang mga sumusunod: tama ba ito, ligtas ba ito, gumagana ba ito sa ilalim ng sabay-sabay na pag-load, sapat ba itong mahusay? Hindi ito isang kurso sa isang partikular na tool. Sinasanay nito ang isang gawi sa pagsusuri na nananatiling pareho kapag nagbago ang tool.
Mabilis na katotohanan
| Tanong | Maikling sagot |
|---|---|
| Ano ang gawain? | Nabuo ang code sa pag-audit at pinatutunayan ang bawat panganib gamit ang isang pagsubok. |
| Ano ang iyong iskor? | Kalidad ng beripikasyon at kung natagpuan ang mga kaugnay na depekto. |
| Sapat na ba ang isang pagsusulit tungkol sa mga panuntunan sa secure coding? | Hindi. Kinukumpirma nito ang mga kinakailangan, ngunit hindi kung makakakita ang isang developer ng isang depekto sa code na mukhang kapani-paniwala. |
| Sino ang nagpapatunay sa nilalaman? | Isang engineering manager at ang iyong security team. |
| Ano ang hindi kayang ayusin ng pagsasanay? | Oras ng pagsusuri, mga kagamitan, hindi malinaw na pagmamay-ari, at presyon na mabilis na magsanib. |
| Paano mo nalaman na gumana ito? | Isang bago at hindi pa nakikitang pagsasanay sa code, na binigyan ng puntos batay sa napagkasunduang pamantayan, na may kasamang follow-up sa mga totoong review. |
1. Ilarawan ang problema sa pagganap
Magsimula sa gawain: i-audit ang nabuong code at patunayan ang mga panganib gamit ang mga pagsubok. Ang pag-audit ay pagbabasa nang may hinala. Ang pagpapatunay ay paggawa ng isang hinala tungo sa ebidensya, kadalasan ay isang pagsubok na nabigo o isang reproduksyon na nagpapakita ng depekto.
Ipinahihiwatig ng pananaliksik kung bakit kailangan nito ng sinadyang pagsasanay. Sa isang pag-aaral ng GitHub Copilot, si Pearce at mga kasamahan ay nakabuo ng 1,689 na programa sa 89 na senaryo na pinili para sa mga kilalang uri ng kahinaan at natuklasan na humigit-kumulang 40 porsyento sa mga ito ay mahina (Pearce at mga kasamahan, 2021). Iyon ay isang sinaunang kagamitan at isang partikular na hanay ng mga senaryo, kaya huwag ituring ang bilang bilang isang rate para sa mga assistant ngayon. Isang hiwalay na pag-aaral ng user ang humiling sa mga kalahok na magsulat ng code nang mayroon at walang AI assistant. Ang mga may assistant ay sumulat ng mas hindi gaanong secure na code, at mas malamang na maniwala na ang kanilang code ay secure (Perry at mga kasamahan, 2023). Natuklasan sa parehong pag-aaral na ang mga kalahok na hindi gaanong nagtitiwala sa assistant at mas nakikibahagi sa kanilang mga prompt ay nakabuo ng mas kaunting mga kahinaan.
Dalawang aralin ang sumusunod para sa disenyo ng pagsasanay. Ang kapani-paniwalang output ay nangangailangan ng isang aktibong tagasuri. At ang kumpiyansa ay hindi ebidensya, kaya ang pagsasanay ay dapat humingi ng pagsubok, hindi ng opinyon.
Isulat ang pahayag ng pagganap sa isang pangungusap at ipasuri ito sa isang engineering manager: "Kung may nabuong pagbabago, inililista ng developer ang mga panganib sa seguridad, sabay-sabay na paggamit, at kahusayan na nakikita nila, at para sa bawat isa ay naglalarawan o nagsusulat ng isang pagsubok na magpapakita nito."
2. Suriin ang mga kakulangan sa pagkatuto at konteksto
Bago ka bumuo ng kahit ano, ihambing ang gawain sa kung ano ang ginagawa at sinusuri ng iyong kasalukuyang programa. Tatlong tanong ang karaniwang naghihiwalay sa isang training gap mula sa ibang bagay:
- Ginagamit ba ng kasalukuyang kasanayan ang totoong gawain? Kung ang pagsasanay ay sumasaklaw sa mabilisang pagsulat ngunit hindi kailanman hinihiling sa mga developer na repasuhin ang output, walang sinuman ang nagsanay ng pag-awdit. Kung ang pagtatasa ay isang multiple-choice na pagsusulit na gumagamit ng mga panuntunan sa secure coding, sinusukat nito ang pag-alala.
- Ano ang pangangailangang kognitibo? Sa binagong taxonomy ni Bloom, ang paghusga kung ligtas ang code at pagpili ng pagsubok na nagpapatunay na ito ay nasa antas ng pagsusuri at pagsusuri, at pagdidisenyo ng mas mahusay na prompt o pag-aayos ay umaabot sa antas ng paglikha. Ang pagtutugma ng mga aktibidad sa mga antas na iyon ay sakop sa aming gabay sa pagtutugma ng mga aktibidad sa pagkatuto sa Bloom's Taxonomy.
- May iba pa bang nakaharang bukod sa kasanayan? Suriin ang oras ng pagsusuri, mga kagamitan, at pagmamay-ari. Kung ang mga tagasuri ay may limang minuto bawat kahilingan sa paghila, walang pagsasanay ang makakabuo ng isang audit. Kung walang static analysis o test harness na nasa pipeline, maaaring makahanap ang isang developer ng panganib ngunit hindi ito mapatunayan. Iulat ang mga sanhi na hindi dahil sa pagsasanay sa mga taong maaaring mag-ayos ng mga ito.
3. Paghahanda at pagsasanay sa disenyo
Kapag alam mo na kung aling mga puwang ang maaaring isara ng pagsasanay, bigyan ang bawat yugto ng isang natatanging trabaho.
Paghahanda Suriin ang mga kinakailangan gamit ang isang maikling pagsusuri: ang mga karaniwang kategorya ng kahinaan na kinakaharap ng iyong stack, kung paano nakabalangkas ang iyong mga pagsubok, ang checklist ng pagsusuri na ginagamit ng iyong koponan. Angkop sa yugtong ito ang pag-aaral na may sariling bilis. Kinukumpirma lamang ng recall check ang mga kinakailangan.
Practice. Gumamit ng mga pagsasanay sa pag-audit na binuo mula sa makatotohanang nabuong code. Maglagay ng maliit na bilang ng mga depekto sa bawat isa na may iba't ibang uri, tulad ng nawawalang pagsusuri ng pagmamay-ari, isang karera sa pagitan ng dalawang kahilingan at isang hindi episyenteng loop, kasama ang ilang code na ayos lang. Sinusuri ng developer, binabanggit ang bawat panganib, sinasabi kung gaano ito kalubha at nagmumungkahi ng pagsubok na magpapakita nito. Humingi ng pangangatwiran, hindi ng isang listahan ng mga numero ng linya.
Feedback. Iugnay ito sa mga desisyon sa halip na sa kabuuang iskor. Mas kapaki-pakinabang ang "Na-flag mo ang loop pero hindi ang karera sa shared counter, at hindi ito masalo ng iyong pagsubok dahil paisa-isang pinapatakbo nito ang mga kahilingan" kaysa sa "2 of 3 found".
Live na input o asynchronous na pagsusuri? Ang live input ay nagdaragdag ng pinakamalaking halaga kapag ang isang panganib ay hindi malinaw at ang mga developer ay natututo mula sa pakikinig sa isang senior engineer na nagpapaliwanag kung bakit nila haharangan ang merge. Ang asynchronous na pagsusuri ay sapat na para sa paghahambing ng mga natuklasan ng isang developer sa isang may anotasyong pagsusuri ng eksperto. Maraming mga koponan ang gumagamit ng pareho: paghahanda sa sarili muna, pagkatapos ay isang pinadali na sesyon sa mga mahihirap na kaso.
4. Gumawa ng isang makatotohanang halimbawa
Paglalarawan. Dapat patunayan ng isang engineering manager ang kaso at ang pamantayan ng sagot bago gamitin.
Ang kaso. Ang isang nabuong endpoint ay nagbabalik ng invoice ng customer sa pamamagitan ng invoice ID. Sinusuri nito kung ang tumatawag ay may wastong sesyon, gumagamit ng parameterized query at pumasa sa basic test. Ang parehong function ay nagdaragdag ng shared download counter nang walang lock.
Ang gawain. Isinasaad ng developer ang bawat panganib na nakikita nila, niraranggo ang mga ito, at inilalarawan ang pagsubok na magpapatunay sa bawat isa.
Isang unang pagsubok. "Mukhang maayos naman. Na-parameterize na ang query at pumasa ang pagsubok." Itinuring ng developer ang pagpasa sa pagsubok bilang patunay at hindi nagtanong kung ano ang hindi sakop ng pagsubok.
Magbigay ng feedback at subukan muli. Hihilingin ng tagasuri sa developer na pangalanan kung ano ang pinatutunayan at kung ano ang hindi pinatutunayan ng pagsusuri ng sesyon. Hihilingin sa kanila ng muling pagsubok na isaalang-alang ang dalawang magkaibang customer at dalawang sabay na kahilingan.
Isang mas malakas na pagtatangka. "Pinatutunayan ng session check kung sino ang tumatawag, hindi na sa kanila ang invoice. Magsusulat ako ng isang pagsubok kung saan hihilingin ng customer A ang invoice ID ng customer B at aasahan ang isang pagtanggi. Ang counter ay dinadagdagan nang walang synchronization, kaya maaaring mawalan ng update ang dalawang kahilingan nang sabay-sabay. Magpapatakbo ako ng isang sabay-sabay na pagsubok at ikukumpara ang bilang. Ang query mismo ay naka-parameterize, kaya hindi ako maglalaan ng oras doon." Pansinin na ang sagot na ito ay niraranggo ang mga panganib at iniuugnay ang bawat isa sa isang pagsubok.
Kung bakit ang bawat tugon ay maipagtatanggol o hindi kumpleto. Husgahan ang bawat isa batay sa naaprubahang pamantayan, hindi batay sa kagustuhan ng tagasuri. Ang unang pagtatangka ay sumusunod sa isang nakagawian ngunit hindi kasama ang ebidensya. Ang mas malakas na pagtatangka ay tiyak, inuuna, at nasusubukan.
5. Suriin ang kakayahan at planuhin ang paglipat
Ang ebidensya ng kakayahan ay ang pagganap sa isang bagong pagsasanay na hindi pa nakikita ng mag-aaral. Kalidad ng pagpapatunay ng iskor at ang pagtukoy ng mga kaugnay na depekto. Ang isang simpleng rubric ay gumagamit ng 0 hanggang 2 na iskala bawat pamantayan:
| Saligan | Napapansing ebidensya |
|---|---|
| Pagpapatupad ng gawain | Sinusuri ang nabuong code at itinatala ang ebidensya sa likod ng bawat natuklasan. |
| pangangatwiran | Ipinapaliwanag ang mga limitasyon, alternatibo at kung ano ang nananatiling hindi tiyak, at niraranggo ang mga panganib. |
| Mga Hangganan | Sumusunod sa mga tuntunin sa pagsusuri ng pangkat at nagpapaabot ng impormasyon sa isang espesyalista sa seguridad kapag ang panganib ay lampas na sa kanilang kakayahan. |
Mga Anchor: 0 ay wala o hindi sinusuportahan, 1 ay bahagyang may mga kaugnay na kakulangan, at 2 ay kumpleto at makatwiran batay sa napagkasunduang pamantayan. Hiwalay na tukuyin ang mga kritikal na error, tulad ng pag-apruba ng code na may hindi protektadong access path, para hindi ito matagpuan ng pangkalahatang iskor. Ang rubric na ito ay isang panukala, hindi isang napatunayang pamantayan ng kahandaan: iakma ito kasama ang isang engineering manager at subukan ito. Ang aming gabay sa pagdidisenyo ng interaktibong pagsasanay na may kapaki-pakinabang na feedback nagpapakita kung paano sumulat ng feedback na nag-uugnay sa mga desisyon.
Sadyaing planuhin ang paglipat. Pagkatapos ng pagsasanay, ipares ang bawat developer sa isang tunay na pull request na may kasamang nabuong code at suriin ang kanilang mga natuklasan nang magkasama, o magsagawa ng isang maikling pagbabalik-tanaw sa isang kamakailang pagsusuri na may hindi napansin.
Kung saan nakakatulong ang interactive na paghahatid
Nakakatulong ang mga interactive na format kung saan dapat mangako ang lahat bago nila makita ang grupo. Sa isang live na sesyon, maaaring ipakita ng isang facilitator ang isang nabuong snippet, hilingin sa bawat developer na i-type ang mga panganib na nakikita nila at ang pagsubok na kanilang isusulat, at pagkatapos ay ibunyag ang spread bago ang talakayan. Ang parehong ehersisyo ay maaaring gawin nang mag-isa para sa paghahanda. AhaSlides Sinusuportahan ang interactive na pag-aaral at paglipat sa pagitan ng live at self-paced na paghahatid. Ito ay isang tool sa presentasyon at pag-aaral, hindi isang lugar para patakbuhin ang code, kaya patakbuhin ang mga pagsasanay sa code sa iyong sariling kapaligiran. Suriin ang anumang partikular na function ng pag-author, feedback o pag-uulat na plano mong asahan laban sa iyong sariling daloy ng trabaho. Para sa gabay sa pagpili ng mga format, tingnan ang aming artikulo sa kailan gagamit ng adaptive, interactive, at live learning.
Sukatin kung ano ang nagbago
Magpasya nang maaga kung ano ang magpapakita na kayang gawin ng mga developer ang gawain. Ihambing ang kalidad ng beripikasyon at pagtukoy ng depekto sa isang hindi pa nakikitang pagsasanay sa isang baseline. Tukuyin kung sino ang kasama, ang denominator at ang tiyempo. Kung bumuti ang mga resulta, suriin kung ano pa ang nagbago sa parehong panahon, tulad ng isang bagong tuntunin sa static analysis, isang binagong checklist ng pagsusuri o isang pagpapalit ng assistant, bago i-credit ang pagsasanay.
Mga limitasyon na maaaring manatili
- Oras ng pagsusuri. Mas matagal ang isang audit kaysa sa isang skim, at ang mga deadline ay mas mabilis pa sa skim.
- Tooling. Kung walang test harness o scanning na nakahanda, mahirap patunayan ang isang panganib.
- Pagpapalit ng mga kagamitan. Mabilis magpalit ang mga assistant, kaya mag-ehersisyo tungkol sa gawi sa pagrerebyu, hindi lang tungkol sa iisang produkto.
- Saklaw ng kaso. Isang pagsasanay ang nagpapakita ng ilang uri ng depekto. Hindi inilalarawan ng iskor ang pangkalahatang paghatol ng isang developer.
- Paglilipat. Ang pagganap sa isang workshop ay hindi katulad ng pagganap sa isang abalang pila para sa pagsusuri.
Ipaalam ang mga ito sa mga sponsor nang maaga at magplano ng magkakahiwalay na pag-aayos. Pinapabuti ng pagsasanay ang mga bagay na mahahanap at mapapatunayan ng isang developer. Hindi nito nililikha ang oras o ang mga kagamitan.
Mga madalas itanong
Ano ang pagsasanay sa pagsusuri ng code na binuo ng AI?
Tinuturuan nito ang mga developer na mag-prompt, mag-evaluate, at mag-audit ng code na ginawa ng isang AI assistant, hinahanap ang mga problema sa seguridad, concurrency, at kahusayan, at sinusuportahan ang bawat isa gamit ang isang pagsubok.
Hindi ba gaanong ligtas ang nabuong code kumpara sa human code?
Itinuturo ng mga pag-aaral ang panganib, ngunit ang mga resulta ay nakasalalay sa kagamitan, gawain, at disenyo ng pag-aaral. Natuklasan sa isang pag-aaral ng gumagamit na ang mga kalahok na may assistant ay sumulat ng hindi gaanong secure na code at mas kumpiyansa tungkol dito, na isang dahilan upang sanayin ang ugali ng pagsusuri.
Paano mo masusuri kung kayang i-audit ng mga developer ang nabuong code?
Magbigay ng bagong pagsasanay sa code at bigyan ng puntos ang kalidad ng beripikasyon at pagtukoy ng depekto batay sa napagkasunduang pamantayan. Ang pagsusulit sa mga panuntunan sa secure coding ay nagpapatunay lamang ng mga kinakailangan.
Kailangan mo ba ng code sandbox para sa training?
Kailangan mo ng lugar para mapagana ang mga ehersisyo, na kadalasan ay ang sarili mong kapaligiran. Tiyakin na ang anumang kagamitang gagamitin mo ay sumusuporta sa kailangan mo bago ka umasa dito.
Saan magsisimula
Pumili ng isang paulit-ulit na uri ng nabuong pagbabago sa iyong codebase. Isulat ang performance statement, ipa-validate sa isang engineering manager ang mga seeded defects at ang mga pagsubok na magpapakita ng mga ito, at magbalangkas ng isang three-criterion rubric na may 0 hanggang 2 scale at isang listahan ng mga kritikal na error. Subukan ito kasama ang isang maliit na grupo bago mo ito ilunsad.
Para makita kung paano maaaring gumana nang live ang isang audit exercise kasama ang sarili mong team, at magamit muli ayon sa iyong sariling bilis pagkatapos, tuklasin AhaSlides.
