Pag-script at AutoComplete

Mga nadagdag:

• Kakayahang mag-map ng chat mode upang itama ang uri ng gawain na may inline na pagkumpleto
• Kakayahang magsulat ng makapangyarihang mga senyas sa produksyon na kinabibilangan ng mga kontrata ng input/output, mga edge case at mga hadlang sa istilo
• Kakayahang patunayan ang nabuong code at anumang bagong iminungkahing dependency bago pagsamahin

Ang unang punto ng pakikipag-ugnayan ng developer sa AI ay kadalasang autocomplete — isang feature na nagmumungkahi ng susunod na linya habang nagta-type ka — o sinasabing "i-type ang function na iyon" sa isang chat window. Pareho silang gumagamit ng parehong makina ngunit nangangailangan ng magkaibang disiplina. Sa unit na ito, binabago namin ang pagbuo ng code mula sa isang random na "isulat ito" sa isang hakbang sa engineering na ang output ay predictable at nabe-verify.

Ang layunin ay gawing apprentice ang AI mula sa isang tool na nagpapabilis sa iyong typing machine na gumagana sa loob ng mga limitasyon na iyong itinakda. Ang isang well-guided apprentice ay nakakatipid ng oras; Ang isang hindi gabay na apprentice ay gumagawa ng gulo na kailangan mong linisin sa ibang pagkakataon.

Dalawang Mode ng Paggamit: Inline na Pagkumpleto at Chat

Ang inline na pagkumpleto ay naglalaro habang nagta-type ka sa iyong editor; Nag-type ka ng isang function signature o isang linya ng komento at iminumungkahi nito ang iba pa. Ito ay mahusay para sa bilis, ngunit mayroon itong isang makitid na konteksto: nakikita lamang nito ang code sa agarang lugar. Iyon ang dahilan kung bakit ito ay pinakamahusay na gumagana kapag isinulat mo nang malinaw ang iyong intensyon sa isang komento. Halimbawa, ang //validate ang email ng user, throw ValidationError kung hindi wastong komento ay makabuluhang nagpapabuti sa mungkahi sa ibaba.

Ang chat mode ay para sa mas malaki at structured na mga gawain: "Magdagdag ng pagination sa klase na ito", "Mag-extract ng interface ng serbisyong iyon." Dito mayroon kang karangyaan sa pagbibigay ng papel, konteksto at format. Ang pangkalahatang tuntunin ay: pagkumpleto para sa maliliit at dumadaloy na gawain, pag-uusap para sa mga gawain na nangangailangan ng pag-iisip at istraktura.

Tip: Huwag basta-basta tanggapin ang mungkahi sa pagkumpleto gamit ang "Tab". Basahin ang iminungkahing linya nang isang segundo; Isang maling pangalan ng variable o isang baligtad na kundisyon na kadalasang tumutulo mula rito.

Mga Hakbang sa Isalin ang Intensiyon sa Code

1. Tukuyin ang kontrata. Ano ang pag-uugali ng input, output at error ng function? Tulad ng "Kumuha ng email, gawing normal kung wasto, throw error kung hindi wasto."
2. Sabihin ang mga hadlang. Huwag gumamit ng panlabas na dependency? Isang tiyak na gabay sa istilo? Mayroon bang limitasyon sa pagganap?
3. Magbigay ng halimbawa. Ang isang pares ng input–output (“ali@x.com → valid, ali@ → error”) ay naglilipat sa pagkaunawa ng modelo sa layunin mula sa hula patungo sa katumpakan.
4. Humingi ng maliliit na piraso. Isang tungkulin, isang responsibilidad. Pagkatapos ay lumipat sa susunod.
5. Basahin at patakbuhin ang nabuong code. Ang pag-compile + ng isang mabilis na manu-manong pagsubok ay ang pinakamurang hakbang sa pagtiyak.

Tatlong Mini Case

Kaso 1 — Ang produksyon na hinimok ng komento ay nagpapataas ng katumpakan. Unang humiling ang isang developer ng function ng pag-parse ng petsa na may walang laman na katawan at nakuha ang tamang resulta sa loob ng 3 round. Sa pangalawang pagtatangka, kapag tinukoy ko ang function na may 4-line na komento (mga tinatanggap na format, panuntunan ng time zone, kundisyon ng error) at hiniling ito, dumating ang code na gumana sa unang round. Parehong modelo, parehong araw; ang pagkakaiba ay ang kalinawan lamang ng layunin.

Kaso 2 — Ang hindi pagtukoy ng bersyon ay mahal. Nahirapan ang isang team sa legacy na callback-based na API na pinapalitan ang fs.promises sa code na ginawa para sa Node.js. Kapag ang linyang "Gumamit ng Node 20, ESM, async/wait" ay idinagdag sa prompt, sinundan ng produksyon ang proyekto sa unang pagkakataon; Na-reset ang average na 12 minutong ginugol sa pagwawasto.

Kaso 3 — Tunay na pakinabang sa boilerplate code. Ang isang microservice ay nangangailangan ng 6 na bagong DTO (Data Transfer Object — isang simpleng klase ng data na nagdadala ng data sa pagitan ng mga layer) at ang kanilang mga panuntunan sa pagpapatunay. Ang dating tinatayang 90 minuto ng manu-manong trabaho ay nabawasan sa 35 minuto kapag ginawa at sinuri ng AI; Dahil mataas ang pag-uulit ng code at malinaw ang pattern, nagtrabaho ang AI sa pinaka-epektibong lugar dito.

Apat na Nakokopyang Template

Pagbuo ng function na nakabatay sa kontrata:

Tungkulin: Isa kang masipag na developer ng {{language}}. Function contract:- Name: {{name}}- Input: {{types and their meaning}}- Output: {{type and meaning}}- Error status: {{what is thrown/returned when}}Constraints: {{no external dependencies / style / performance}}Examples:- {} {1} {{entry_2}} -> {{error_2}}Bigyan muna ng lagda + maikling plano, pagkatapos ay mag-code. Pagsusulit sa pagsulat, function lang.

Upang tumugma sa kasalukuyang istilo (i-adapt sa code base):

Nasa ibaba ang isang halimbawang function mula sa aming proyekto; Alamin ang pagbibigay ng pangalan, paghawak ng error at istilo ng pagkokomento dito. Sumulat ng function para sa {{new_task}} na may PAREHONG istilo. Halimbawa: {{current_code}}

Mula sa balangkas hanggang sa pagpuno (stub → pagpapatupad):

Punan ang function skeleton sa ibaba ayon sa mga TODO sa mga komento. PALITAN ang pirma at uri ng pagbabalik. Huwag gumawa ng helper function na hindi umiiral; kung kinakailangan, ipaalam sa akin na "kailangan ang katulong na ito". {{skelet_kod}}

Alternatibong paghahambing ng app:

Magbigay ng 2 magkakaibang pagpapatupad para sa {{task}}: (a) pagbibigay-priyoridad sa pagiging madaling mabasa, (b) pagbibigay-priyoridad sa pagganap. Sumulat ng 1 pangungusap na "kailan mas kanais-nais" sa ilalim ng bawat isa.

Mahinang prompt / Malakas na prompt

Mahina: "Sumulat ako ng function sa pag-verify ng email."

Strong: "TypeScript 5, karaniwang library lang. Sumulat ng isValidEmail(input: string): boolean. I-trim ang mga puwang, gawin itong case insensitive, a@b.co ay valid, a@, @b.co, walang laman na string ay hindi wasto. Kung gagamit ka ng regex, huwag masyadong kumplikado; magdagdag ng 2 linya ng mga komento."

Napakahusay na bersyon; Ibinabalik ang wika, bersyon, lagda, edge case, at isang hadlang sa istilo. Kaya, ang nabuong code ay parehong gumagana at umaangkop sa iyong proyekto.

Diskarte

Kailan gagamitin

Pansin

Inline na pagkumpleto

Maliit na pagsingit sa daloy

Huwag tanggapin ang mungkahi nang hindi ito binabasa

Contract based production sa chat

Bagong function/klase

Magbigay ng halimbawa at edge case

Produksyon ayon sa sample ng istilo

Pagdaragdag sa umiiral na code

Piliin ang kasalukuyang sample code

pagpupuno ng balangkas

Naayos ang lagda, blangko ang katawan

Pagbabago ng lagda

Pagdoble ng Code at ang Dependency Trap

Ang AI ay madalas na nagrerekomenda ng isang bagong library upang gawing mas madali ang trabaho nito. Minsan ito ay tumpak, kung minsan ay nagdaragdag ito ng hindi kinakailangang dependency sa iyong proyekto o nagmumungkahi ng isang pakete na hindi umiiral (isang guni-guni). Panuntunan: kinukumpirma mo ang bawat bagong dependency. Huwag idagdag ito sa proyekto nang hindi bini-verify na ang package ay aktwal na umiiral, pinananatili, at may naaangkop na lisensya. Kadalasan ang isang katulong na nasa proyekto ay mas mahusay kaysa sa isang bagong pakete.

Babala: Suriin ang mga linya ng pag-import na iminungkahi ng AI. Ang isang hindi umiiral na pangalan ng package (na maaari ding maging katulad ng mga pekeng pakete na tinatawag na "typo-squatting") ay parehong sumisira sa compilation at nagdudulot ng panganib sa seguridad.

Mga karaniwang pagkakamali

• Ang pagkakaroon ng lagda na tinutukoy ng modelo. Kung hindi mo aayusin ang mga uri ng input/output, may ibang signature na kasama sa bawat produksyon at nagiging mahirap ang pagsasama.
• Hindi banggitin ang mga edge case. Walang laman na input, null, negatibong numero, napakalaking halaga — kung hindi mo tutukuyin ang mga ito, isusulat ng modelo ang "masayang landas", laktawan ang mga gilid.
• Pinagsasama-sama ang mungkahi nang hindi sinusuri ito. Ang code na mukhang gumagana ay hindi nangangahulugang gumagana ito.
• Pagtanggap ng hindi kinakailangang dependency. Ang pagdaragdag ng isang buong library para sa isang one-liner ay lumilikha ng teknikal na utang.
• Hindi pagkakapare-pareho ng istilo. Ang iba't ibang pagbibigay ng pangalan at paghawak ng error mula sa natitirang bahagi ng proyekto ay ginagawang tagpi-tagpi ang base ng code.

Sa buod

Makapangyarihan ang pagbuo ng code kapag isinalin mo ang layunin sa isang malinaw na kontrata. Gumamit ng inline na pagkumpleto para sa maliliit, in-stream na gawain, at para sa mga gawaing nagtatatag ng istruktura sa pag-uusap. Tinukoy mo ang mga uri ng input/output, edge case, bersyon, at istilo; Magbigay ng halimbawa ng modelo; i-verify ang bawat bagong dependency; at tumakbo at basahin ang bawat piraso na ginawa. Pinakamahusay na nagbabayad ang AI sa formulaic, paulit-ulit na code — patakbuhin ito doon, sa loob ng mga limitasyong itinakda mo.

Gawain ng aplikasyon

Pumili ng isang aktwal na maliit na function mula sa iyong proyekto na kailangan mong isulat. I-print muna ito sa AI na may template na "contract-based function generation", na nagbibigay ng mga uri ng input/output, dalawang edge na case, at isang hadlang sa istilo. I-compile ang nabuong code at subukan ito gamit ang dalawang magkaibang input. Pagkatapos ay tanungin muli ang parehong function, sa pagkakataong ito "isulat mo sa akin ito" nang walang anumang konteksto, at ihambing ang dalawang mga output nang linya sa linya: aling mga edge na kaso ang napalampas, gaano karaming mga pagwawasto ang kinakailangan?

checklist

• [ ] Alam ko kung saan gagamitin ang chat mode na may inline na pagkumpleto.
• [ ] Tinutukoy ko ang kontrata ng input/output at mga edge na kaso sa pagbuo ng function.
• [ ] Nakaugalian ko nang magdagdag ng impormasyon sa wika at bersyon sa prompt.
• [ ] Kino-compile at sinusuri ko ang bawat ginawang piraso bago ito tipunin.
• [ ] Kinukumpirma ko ang bawat bagong dependency na iminungkahi ng AI sa pamamagitan ng pag-verify ng pagkakaroon at pangangailangan nito.
• [ ] Sinusuri ko na ang nabuong code ay tumutugma sa istilo ng proyekto.