Artipisyal na Katalinuhan para sa Mga Koponan ng Software: Gumagana na Modelo at Mga Limitasyon

Mga nadagdag:

• Kakayahang ipaliwanag kung paano gumagana ang isang coding assistant bilang isang modelo ng wika at ang mga konsepto ng token, window ng konteksto, guni-guni
• Kakayahang tukuyin ang mga gawain sa software kung saan malakas at mahina ang AI gamit ang isang mental na mapa
• Kakayahang ilapat ang pangunahing siklo ng trabaho ng imungkahi-produce-verify sa kanilang sariling mga gawain

Ang araw ng developer ng software ay bihirang ginugugol sa "pagsusulat ng code mula sa simula." Tunay na oras; Pagbabasa ng code na isinulat ng ibang tao, sinusubukang gumawa ng isang bug, pag-scan sa log (mga linya ng log na ginawa ng application habang tumatakbo), pagsulat ng mga pagsubok, pagsulat ng PR (paghiling ng paghila - isang kahilingan sa pagsasama kung saan isinumite ang pagbabago ng code para sa pagsusuri ng koponan) paliwanag at pag-update ng dokumentasyon. Ang artificial intelligence (AI) ay isang speed multiplier na maaaring mahawakan ang halos lahat ng hindi nakikitang mga trabahong ito. Ngunit ang unang kondisyon para sa ligtas na paggamit nito ay upang maunawaan nang tama kung ano ito at kung ano ito ay hindi.

Sa unit na ito, ipinapaliwanag muna namin ang pinagbabatayan na teknolohiya ng isang coding assistant sa simpleng wika; pagkatapos ay lumikha kami ng isang mental na mapa ng mga kalakasan at kahinaan ng modelo; Sa wakas, itinatatag namin ang pangunahing disiplina sa pagtatrabaho na gagamitin namin sa buong module: magmungkahi, gumawa, mag-verify. Ang tatlong hakbang na ito ay ang gulugod ng susunod na labing-isang yunit.

Tandaan: Ang modyul na ito ay isang pangkalahatang pagsasanay. Sa software na kritikal sa seguridad (pagproseso ng pagbabayad, pangangalaga sa kalusugan, pagpapatunay, kritikal na imprastraktura) ang output ng AI ay hindi kapalit para sa pagsusuri at pag-apruba ng isang kwalipikadong engineer. AI ay isang katulong; Ang pumirma ay ang inhinyero.

Ano ang Talagang Ginagawa ng Coding Assistant?

Karamihan sa mga coding assistant ay binuo sa isang malaking modelo ng wika (LLM—isang AI na sinanay sa malaking halaga ng text at code na hinuhulaan ang susunod na malamang na "chunk"). Ang modelo ay hindi "naiintindihan" ang code tulad ng isang tao; Binubuo nito ang pinakamalamang na pagpapatuloy ng kontekstong ibibigay mo dito, batay sa mga pattern na natutunan nito mula sa isang malaking pool ng mga halimbawa. Ang tila simpleng mekanismong ito ay nagbubunga ng nakakagulat na mahusay na mga resulta sa pagsasanay — dahil karamihan sa software ay binubuo ng mga umuulit na pattern: isang kahilingan sa HTTP, isang loop, isang null check, isang pattern ng pagsubok.

Tatlong termino ang kritikal dito. Ang Token ay ang pinakamaliit na yunit na pinoproseso ng modelo sa pamamagitan ng paghahati ng teksto; Ito ay halos ilang letra o bahagi ng isang salita. Ang window ng konteksto ay ang dami ng mga token na maaaring "makita" ng modelo nang sabay-sabay; Ang iyong code, mensahe ng error, at pagtuturo ay dapat magkasya sa window na ito. Ang prompt ay ang lahat ng mga tagubilin at konteksto na ibibigay mo sa modelo. Ang kalidad ng output na nakukuha mo ay direktang nakasalalay sa dalawang ito: ang mas mahusay na konteksto at mas malinaw na mga tagubilin na ibibigay mo sa modelo, mas mahusay na resulta ang iyong makukuha. Ang masamang input ay gumagawa ng masamang output, kahit na ito ay isang matalinong modelo — ang klasikong "basura sa loob, basura palabas" na panuntunan ng software ay nalalapat din sa AI.

Mapa ng Kalakasan at Kahinaan

Upang idirekta ang AI sa mga tamang trabaho, kinakailangang malaman kung saan ito kumikinang at kung saan ito natitisod. Ang pagsasaulo sa mapa na ito ay magtatanong sa iyo sa bawat susunod na misyon, "Dapat ko bang i-outsource ang trabahong ito sa AI ​​o ako mismo ang gumawa nito?" Pinapayagan ka nitong sagutin ang tanong sa ilang segundo.

Ang mga kalakasan nito ay: Pagbuo ng boilerplate code, pagsasalin mula sa isang wika patungo sa isa pa, pagsulat ng isang regular na expression (regex), paglalarawan ng isang function, paggawa ng isang test skeleton, pag-interpret ng isang error na mensahe, pag-draft ng dokumentasyon, pagmumungkahi ng mga variable/function na pangalan, at minor refactorings (pagpapabuti ng istraktura ng code nang hindi binabago ang pag-uugali nito).

Mga Kahinaan: Ang pag-alam sa iyong mga panuntunan sa negosyo na partikular sa kumpanya, pag-alala sa iyong buong code base, aktwal na pagpapatakbo at pag-verify ng code, alam ang pinakabagong mga bersyon ng library para sigurado, pag-detect ng mga kahinaan sa seguridad na may daang porsyentong garantiya. Ang pinaka-mapanganib na bagay ay guni-guni: ang modelo ay nag-imbento ng isang hindi umiiral na function, library o API (interface na nagbibigay-daan sa pagpapalitan ng data sa pagitan ng mga application) sa isang napakakumbinsi na wika. Ang panganib na ito ay maaaring gawin sa iyong kalamangan, dahil ang code, hindi tulad ng plain text, ay maaaring masuri upang makita kung ito ay "gumagana" — huwag lang laktawan ang hakbang sa pag-verify.

Uri ng misyon

Ang papel ng AI

tungkulin ng tao

Gumawa ng boilerplate/skeleton

gumagawa ng draft

Mga adaptasyon, mga pagsusuri

Paglalarawan ng code

Nagbibigay ng mabilis na buod

Bine-verify ang kritikal na bahagi sa code

mga pagsusulit sa pagsulat

Kaso nagmumungkahi

Kinukumpirma ang saklaw at katumpakan

Logic na kritikal sa seguridad

kapaki-pakinabang na ideya

Ang desisyon at responsibilidad ay ganap na nakasalalay sa mga tao.

Paggamit ng API/library

Bumubuo ng sample

Bine-verify ang pagkakaroon at bersyon

desisyon sa arkitektura

Mga uri ng mga pagpipilian

Pinipili at ipinagtatanggol ang pag-alam sa konteksto

Hakbang sa Hakbang: Basic Working Cycle

1. Linawin ang gawain. Kung hindi mo maisulat ang gusto mo sa isang pangungusap, hindi rin maisusulat ang modelo. Ang mas maagang kawalan ng katiyakan ay tumagos sa input, mas lumalaki ito sa output.
2. Magbigay ng konteksto. Idagdag ang nauugnay na code, buong mensahe ng error, bersyon ng wika/framework at mga hadlang sa prompt. Huwag sabihing "ayusin ito", sabihin ang "Python 3.11, FastAPI 0.110; nagbibigay ang function na ito ng 500 error, sumasabog ito kapag walang laman ang request body".
3. Pagpapataw ng tungkulin at pormat. Ang isang framework tulad ng "Ikaw ay isang senior na developer ng Go; ibigay lang ang code at dalawang pangungusap na katwiran" ay nakatutok sa output.
4. Humingi ng maliit. Hatiin ito sa mga hakbang sa halip na isang higanteng kahilingan; I-verify ang bawat hakbang nang hiwalay. Mapanganib ang mga malalaking pagbabago dahil mahirap i-verify at madaling magtago ng mga error.
5. I-verify. Patakbuhin ito, subukan ito, basahin ito nang biswal. Ang hindi na-verify na AI code ay isang "sketch", hindi isang "solusyon". Ito ang pinaka-non-negotiable na hakbang ng cycle.

Tatlong Mini Case

Kaso 1 — Ang pagtitipid ng oras ay totoo ngunit katamtaman. Nang gumawa ng balangkas ang isang team ng mga bagong CRUD (Create-Read-Update-Delete) na mga endpoint gamit ang AI, bumaba ang oras ng unang draft mula sa humigit-kumulang 40 minuto hanggang 8 minuto. Gayunpaman, sa pagsusuri at pagsubok, ang kabuuang oras ay 25 minuto; kaya ang tunay na pakinabang ay mula 40 hanggang 25, mga 38%. Ang rate na ito, na sinusukat sa halip na inaasahan na "namin ay bumilis ng 10 beses", ay isang napapanatiling pakinabang.

Kaso 2 — Mahal ang hallucination. Ginamit ng isang developer ang tawag na requests.get_json() na iminungkahi ng AI nang walang pagpapatunay; Walang ganoong paraan (tumpak na response.json()). Nawala ang 20 minuto nang hindi na-compile ang code. Isang simpleng "umiiral ba talaga ang pamamaraang ito?" ire-reset ng pag-verify ang pagkawala.

Case 3 — Ang magandang konteksto ay nagdodoble ng output. Para sa parehong bug, isinulat lang ng isang developer ang "Nagkakaroon ako ng error" at idinagdag ng isa ang buong stack trace, bersyon, at sample ng input. Nakuha ng huli ang tamang solusyon sa unang pagsubok; Ang una ay gumugol ng tatlong liko. Ang pagkakaiba ay wala sa modelo, ngunit sa input.

Apat na Nakokopyang Template

Isang pangkalahatang layunin, malakas na startup prompt:

Tungkulin: Isa kang makaranasang developer ng {{language}}. Gawain: {{what_want}}Context:- Framework/version: {{framework_and_version}}- Constraints: {{performance, style, dependency rules}}Rule:- Do not use non-existent library/function; Kung hindi ka sigurado, markahan ito bilang "i-verify". - Una, magbigay ng maikling plano, pagkatapos ay ang code, pagkatapos ay 2 pangungusap ng pagbibigay-katwiran. - Gumawa ng masusubok, gumaganang code.

Upang i-filter ang kawalan ng katiyakan pabalik sa modelo:

Bago lutasin ang gawain sa ibaba, ilista ang hindi bababa sa 3 puntos na nakikita mong nawawala o hindi malinaw bilang mga tanong. HUWAG magsulat ng code bago ako tumugon. Gawain: {{task}}

Upang masuri ang output sa sarili:

Nagawa mo ang sumusunod na code. Baguhin ngayon ang iyong tungkulin at punahin ang code na ito:- Maglista ng 3 kaso (mga edge na kaso) na maaaring hindi gumana.- Mayroon bang anumang mga API/function na maaari mong gawin? Markahan.- Magbigay ng naitama na bersyon. Code:{{code}}

Upang hatiin ang isang desisyon sa mga opsyon:

Magmungkahi ng 2-3 solusyon para sa {{problem}}. Para sa bawat isa: maikling paglalarawan, plus/minus, kung kailan pipiliin. Ibigay sa anyong tabular. HUWAG pumili para sa akin; linawin lamang ang pagpipilian.

Mahinang prompt / Malakas na prompt

Mahina: "Ayusin ang bug sa code na ito." (Aling error? Aling wika? Ano ang inaasahang pag-uugali?)

Strong: "Python 3.11 / FastAPI 0.110. Ang sumusunod na endpoint ay nagbabalik ng 500 kasama ang KeyError kapag ang request body ay walang laman; Gusto kong ibalik nito ang 400 at makabuluhang mensahe sa empty body. Ipaliwanag muna ang dahilan, pagkatapos ay ibigay ang naitama na function, pagkatapos ay magsulat ng pagsubok para sa sitwasyong ito. [code]"

Napakahusay na bersyon; Nagbibigay ito ng wika, bersyon, aktwal na error, inaasahang pag-uugali at format ng output. Hindi na kailangang hulaan ng modelo.

Mga karaniwang pagkakamali

• Nagtitiwala nang walang verification. Ang pinakakaraniwan at pinakamahal na pagkakamali. Huwag sabihin ang "solved" hanggang sa ma-compile at masuri ang code.
• Pagtatanong nang walang konteksto. Ang sagot na walang bersyon, error na text at mga paghihigpit ay generic at kadalasang mali.
• Isang malaking kahilingan. Ang hindi magagawang humiling at masuri ang isang 300-linya na produksyon nang sabay-sabay ay gumagawa ng mga pagkakamali na hindi nakikita.
• Napagkakamalang patunay ang tiwala sa sarili ng modelo. May kumpiyansa na masasabi ng AI ang isang bagay na mali; Ang tono ay hindi isang tagapagpahiwatig ng katumpakan.
• Random na i-paste ang sikreto ng kumpanya. Ang mga pribadong key, data ng customer, o pribadong source code ay hindi dapat ilagay sa mga hindi naaprubahang tool (susuriin natin ang paksang ito sa unit 10).

Tip: Tratuhin ang bawat output ng AI bilang "ito ay isang draft." Ang nag-iisang mental na ugali na ito ay pumapatay sa karamihan ng mga panganib na makikita mo sa buong modyul.

Sa buod

Ang coding assistant ay isang modelo ng wika na hinuhulaan ang susunod na malamang na fragment; Hindi nito naiintindihan ang code, gumagawa ito ng mga pattern. Iyon ang dahilan kung bakit siya ay malakas sa paulit-ulit, formulaic na mga trabaho; Dapat itong gamitin nang maingat para sa trabahong nangangailangan ng pag-verify na partikular sa iyong konteksto. Ang pinakamalaking panganib ay guni-guni, at ang tanging panlunas ay ang pagpapatunay. Malinaw ang disiplinang susundin natin sa buong modyul: linawin ang gawain, bigyan ng konteksto, humingi ng maliit, patunayan ang bawat maihahatid.

Gawain ng aplikasyon

Isulat ang tatlong gawain sa software na ginawa mo noong nakaraang linggo (hal. isang bug fix, isang pagsubok, isang README update). Tingnan ang "mapa ng mga lakas at kahinaan" para sa bawat isa at ilarawan sa isang pangungusap kung ano ang magiging papel mo at ng AI kung gagawin mo ito sa AI. Pagkatapos ay ibigay ang isa sa mga gawaing ito sa AI na may template na "start prompt" sa itaas at patakbuhin at i-verify ang output; Tandaan kung gaano karaming minuto ang iyong na-save at kung gaano karaming mga pagkakamali ang kailangan mong ayusin.

checklist

• [ ] Napagtanto ko na ang LLM ay gumagawa ng mga pattern, hindi "nakakaintindi" ng code.
• [ ] Maaari kong ipaliwanag ang mga konsepto ng token, window ng konteksto at prompt sa isang pangungusap.
• [ ] Nakikilala ko ang mga uri ng gawain kung saan malakas at mahina ang AI.
• [ ] Alam ko kung ano ang guni-guni at ang tanging panlunas ay ang pagpapatunay.
• [ ] Iniangkop ko ang siklo ng "propose, produce, verify" sa sarili kong gawain.
• [ ] Maaari kong ipakita ang pagkakaiba sa pagitan ng malakas na prompt at mahinang prompt sa isang kongkretong halimbawa.