Target na mambabasa: Mga developer na gumagamit ng mga AI programming tool (tulad ng Cursor, Windsurf, trae...) at mga technical manager na walang kamalayan sa gastos ng AI.

Pangunahing punto: Ang Token ay hindi lamang isang simpleng yunit ng pagsingil, kundi isang "resource ng atensyon" at "currency ng computing power". Ang pag-abuso sa Agent mode at pagpapabaya sa pamamahala ng konteksto ay aktwal na gumagamit ng tactical na kasipagan (pagpapahirap sa AI) upang takpan ang strategic na katamaran (hindi pag-iisip).

Ang iyong "Gastos sa AI" ay Maaaring Mas Mataas pa sa Iyong Sahod

Ilang araw na ang nakalipas, sinuri ko ang aking Token bill. Nagulat ako nang makita ko ang numero: 10 milyong Token. Tandaan, hindi ito ang paggamit sa isang buwan, ito ay sa isang araw.

Akala ko sobra na ito. Pagkatapos ay nag-post ako ng isang maikling video tungkol sa pagkalkula ng Token.

Bilang resulta, nakita ko sa seksyon ng mga komento kung ano ang "may mas mataas pa sa langit."

Ang sumusunod na larawan ay isang screenshot ng talaan ng pagkonsumo ng 200 milyong Token sa isang araw ng netizen na si "Old K's Daily":

Sa simula, akala ko ito ay isang isolated case, ngunit nang maraming netizens ang nagsabi na kumokonsumo sila ng 100 milyon araw-araw, napagtanto ko na ito ay isang napakalaganap na phenomenon.

Ano ang konsepto ng isang daang milyong Token? Kung kalkulahin batay sa karaniwang antas ng pagsingil ng "ilang pangunahing komersyal na modelo" (ang input/output ay sinisingil nang hiwalay, at tinatayang kalkulahin sa $10 bawat milyon Token), ang araw na ito ay sumunog ng $1000. Sumunog ng 7000 RMB sa isang araw. Ang sahod ng maraming junior programmer sa isang buwan ay maaaring hindi sapat para sa "pag-iisip" ng AI sa araw na ito.

(Tandaan: Ang mga pagkakaiba sa presyo sa pagitan ng iba't ibang modelo/supplier ay malaki, at ang presyo bawat yunit ng input at output ay madalas na iba. Ang layunin dito ay hindi upang kalkulahin nang eksakto hanggang sa ikalawang decimal place, ngunit upang itatag muna ang "sense of magnitude.")

Kung gusto mong kalkulahin ito nang mag-isa, narito ang pangkalahatang formula (hindi kasama ang mga espesyal na panuntunan tulad ng caching/discounts): Gastos ≈ (Input Token / 1,000,000) × Presyo_in + (Output Token / 1,000,000) × Presyo_out

Ito ay masyadong counterintuitive. Palagi nating iniisip na mura ang AI, at nagbaba pa nga ng presyo ang OpenAI. Ngunit bakit sa aktwal na engineering, ang pagkonsumo ng Token ay sumasabog nang exponentially?

Ngayon, dadalhin ko kayo upang lubos na suriin ang lohika sa likod ng "Token black hole" na ito, at kung paano natin dapat pigilan ang pagkalugi.

I. Bakit "Sumasabog nang Exponentially" ang Token?

Maaaring walang ideya ang maraming kapatid tungkol sa laki ng Token. Iniisip nila: "Ay, hindi ba't ilang linya lang ng code? Magkano ba iyon?"

1. Kalkulahin ang isang malinaw na account

Magtatag muna tayo ng isang quantitative perception na sapat para sa engineering. Sabihin muna natin ito nang direkta: Ang Token ay hindi bilang ng mga salita, ni bilang ng mga character. Ito ay isang "encoded fragment" pagkatapos hatiin ng modelo ang teksto. Iba ang tokenizer na ginagamit ng iba't ibang modelo, kaya maaari lamang itong magbigay ng interval, hindi isang pare-parehong constant na "angkop sa lahat ng sitwasyon."

Gamitin lamang ang mga numerong ito bilang isang "estimating ruler" (ang layunin ay upang hatulan ang magnitude, tantiyahin ang gastos, at gumawa ng mga desisyon sa pagpigil sa pagkalugi):

• 1 Chinese character: Karaniwan sa 1–2 Token (ang mga madalas na character ay mas malapit sa 1, at ang mga hindi karaniwang character/kumbinasyon ay mas malamang na umabot sa 2–3)

• 1 English word: Karaniwan sa humigit-kumulang 1.2–1.5 Token (maaari mo ring gamitin ang 1.3 para sa magaspang na pagtatantya)

• 1 linya ng code ≈ 10–50 Token (kabilang ang indentation, mga komento, mga deklarasyon ng uri)

• Maikling lohika ng negosyo ≈ 12–20 Token

• May mga anotasyon ng uri, interface, JSDoc, 4-space indentation ≈ 20–35 Token

• May maraming import / decorator / komento ≈ 30–50+ Token

• 1 source file (400–600 linya, modernong TS/Java project) ≈ 4,000–24,000 Token ay karaniwan (median ≈ 12,000–18,000)

• 1 medium-sized na proyekto (100–200 source file, src/ lamang, hindi kasama ang node_modules/ / nabuong code)

• Ang "pagbabasa sa pamamagitan ng" pangunahing source code ay madalas na nagsisimula sa milyun-milyong Token

• Kung isasama mo ang mga pagsubok, configuration, script, deklarasyon ng dependency, at mga log, hindi nakakagulat na umabot sa sampu-sampung milyong Token

Ang mga modernong proyekto sa frontend ay TypeScript, na puno ng mga kumplikadong kahulugan ng Interface; o Java, na madalas na may dose-dosenang linya ng Import. Ang mga "boilerplate code" na ito ay talagang mga mamamatay-Token. Kung ang isang medium-sized na proyekto ay may 100 file, ang pagpapaalam sa AI na "basahin ang code" ay maaaring direktang pumatay ng 1 milyong Token.

2. Ang "snowball" effect ng token

Ang pinakanakakatakot na pagkonsumo ng Token ay hindi ang isang beses na pag-uusap, ngunit ang akumulasyon ng konteksto sa maraming round ng pag-uusap.

Ang mekanismo ng LLM ay stateless. Upang matandaan ng AI kung ano ang sinabi mo sa nakaraang pangungusap, karaniwang pinagsasama-sama ng system ang "system prompt + kasaysayan ng pag-uusap + mga file/code snippet na iyong binanggit + output ng pagtawag sa tool (tulad ng mga resulta ng paghahanap, mga log ng error)" at ipinapadala ito sa modelo. Akala mo isang tanong lang ang tinanong mo, ngunit paulit-ulit kang nagbabayad para sa "buong context package."

• Round 1: Nagpadala ng 10,000 Token, sumagot ang AI ng 1,000.

• Round 2: Nagpadala ng (10,000 + 1,000 + bagong tanong), sumagot ang AI...

• Round 10: Maaaring lumaki na ang iyong Konteksto sa 200,000 Token.

Sa oras na ito, kahit na magtanong ka lang ng "tulungan mo akong baguhin ang pangalan ng variable", ang gastos ay 200,000 Token. Ito ang dahilan kung bakit pakiramdam mo ay wala kang ginagawa, ngunit ang iyong bill ay tumataas.

Ang mas nakakabahala ay: Ang Agent mode ay "aktibong nagbabasa ng mga file". Kung sasabihin mo ang isang pangungusap na "tulungan mo akong i-optimize ang module ng gumagamit", maaari nitong i-scan muna ang mga nauugnay na direktoryo, pagkatapos ay subaybayan ang mga dependency, pagkatapos ay subaybayan ang mga configuration, at pagkatapos ay subaybayan ang mga pagsubok... Hindi ito nagtatamad, ito ay "responsableng gumaganap ayon sa default na patakaran", at ang default na patakaran ay madalas na: magbasa nang higit pa, subukan nang higit pa, umulit nang higit pa.

II. Dalawang Uri ng "Katamaran" ang Sumisira sa Iyong Kakayahan sa Engineering

Pagkatapos suriin ang mga "100 Million Brothers" sa seksyon ng mga komento, natuklasan ko na ang ugat ng pagtaas ng Token ay hindi lamang ang problema sa mekanismo ng pagkonsumo ng AI, kundi pati na rin ang katamaran ng mga tao.

Narito ang dalawang tipikal na uri ng "mental laziness".

Katamaran 1: Uri ng Tagapamahala na Nagpapasa ng Trabaho

Mayroon ka rin bang ganitong mindset?

• "Ang lumang proyekto na ito ay masyadong magulo, tinatamad akong tingnan ang lohika, ipapasa ko na lang sa AI."

• "Naglabas ang Cursor ng Agent mode, napakagandang balita, hayaan itong ayusin ang Bug mismo."

Kaya, ipinasa mo ang buong src folder sa Agent at nagbigay ng malabong tagubilin: "Tulungan mo akong i-optimize ang module ng gumagamit." Nagsimula nang gumana ang Agent:

• Nagbasa ito ng 50 file (kumonsumo ng 500,000).

• Natuklasan nito na binanggit nito ang utils, at nagbasa ng mga utility class (kumonsumo ng 200,000).

• Sinubukan nitong baguhin, nagkaroon ng error, nagbasa ng mga log ng error (kumonsumo ng 100,000).

• Sinubukan nitong ayusin, nagkaroon muli ng error...

Ito ay baliw na sumusubok at nagkakamali, baliw na kumokonsumo ng Token. At ikaw? Nagba-browse ka sa iyong telepono, iniisip na napakataas ng iyong kahusayan. Ang katotohanan ay: ang "pseudo-efficiency" na binayaran mo ng pera ay gumawa ng isang tumpok ng code na hindi mo mapapanatili sa ibang pagkakataon.

Sa mas propesyonal na paraan, mayroong dalawang layer ng pagkalugi dito:

• Layer ng gastos: Ang input Token ay lumalaki, ang bilang ng mga pag-ulit ay tumataas, at ang mga gastos ay linear na nagdaragdag

• Layer ng engineering: Nawalan ka ng konteksto at kapangyarihan sa paggawa ng desisyon, at sa huli ay mayroon ka lamang isang hindi makontrol na sistema na "gumagana."

Katamaran 2: Uri ng Paghahalo ng Lahat

Kapag nakatagpo ka ng Bug, paano mo ito ipinapasa sa AI? Kinokopya mo ba nang direkta ang buong error console gamit ang Ctrl+A, o direktang @Codebase upang hayaan ang AI na hanapin ito mismo?

Ito ay tinatawag na "paghahalo ng lahat". Tinatamad kang hanapin ang core ng problema, tinatamad kang i-filter ang mga pangunahing snippet ng code. Ipinapasa mo ang 99% ng walang-saysay na impormasyon (ingay) at 1% ng mahalagang impormasyon (signal) sa AI.

Ang AI ay parang isang amplifier.

• Kung bibigyan mo ito ng malinaw na lohika (signal), pinalalaki nito ang iyong karunungan, mas kaunting Token ang ginagamit, at mas mahusay ang epekto.

• Kung bibigyan mo ito ng kalituhan at kalabuan, pinalalaki nito ang iyong kalituhan, ang Token ay tumataas, at gumagawa ng basura.

III. Solusyon: Paano Gumamit ng AI nang Mahusay at Bawasan ang Pagkonsumo ng Token

Upang maprotektahan ang iyong wallet, ang mas mahalaga ay protektahan ang iyong kontrol sa engineering. Dapat nating baguhin ang ating modelo ng pakikipagtulungan sa AI.

1. Prinsipyo ng Pinakamababang Konteksto

Ito ang unang prinsipyo ng AI programming. Palaging bigyan lamang ang AI ng pinakamababang hanay ng code na tumutugma sa kasalukuyang problema.

Sa Cursor, gamitin nang mahusay ang mga operator na ito:

• @File: Banggitin lamang ang mga nauugnay na file, hindi ang buong folder.

• Ctrl+L Piliin ang code: Ipadala lamang ang 50 linya ng code na pinili ng cursor sa Chat, hindi ang buong file.

• @Docs: Para sa mga third-party na library, banggitin ang dokumentasyon sa halip na hayaan itong hulaan.

Ito ang madalas kong ginagamit, structured, at reusable na SOP (kung gagawin mo ito, ang Token ay bababa nang kapansin-pansin):

Ang ibig sabihin ng talatang ito ay: Kapag nakikipagtulungan sa AI, bigyang-pansin ang kahusayan at katumpakan. Ang mga partikular na kasanayan ay ang mga sumusunod:

• Tukuyin muna ang layunin: Sabihin sa AI ang kasalukuyang problema at ang nais na resulta nang maikli at concisely, at huwag hayaan itong hulaan.

• Pasimplehin ang pagpaparami ng problema: Kung magagamit mo ang pinakasimpleng paraan upang muling buuin ang problema, huwag gumamit ng mga kumplikadong paraan, i-paste ang pinakamaliit at pinakamahalagang code, at huwag mag-stack ng maraming walang kaugnayang nilalaman.

• Magbigay ng pinakamababang kinakailangang impormasyon: Magbigay lamang ng 1-3 nauugnay na file, mga pangunahing function, at ang unang ilang linya ng error stack, hindi ang buong impormasyon.

• Hilingin na ibalik ang mga pagbabago: Hayaan ang AI na sabihin lamang sa iyo kung saan babaguhin at kung bakit babaguhin, at huwag hayaan itong muling isulat ang lahat sa mahabang haba.

• Sa wakas, suriin mo mismo: Gumawa ng pinakasimpleng pagpapatunay upang matiyak na ang mga pagbabago ay hindi nakakaapekto sa ibang mga lugar.

Sa madaling salita, gumamit ng pinakamaliit at pinakamahalagang impormasyon upang hayaan ang AI na gawin ang mga bagay, at panatilihin ang panghuling kontrol at paghatol.

2. Gayundin ang pinakamahalaga: Mag-isip muna, pagkatapos ay Prompt, magplano muna, pagkatapos ay kumilos

Bago pindutin ang enter, pilitin ang iyong sarili na huminto ng 10 segundo at tanungin ang iyong sarili ng tatlong tanong:

• Anong problema ang sinusubukan kong lutasin? (Tukuyin ang mga hangganan)

• Aling mga pangunahing module ang kasangkot sa problemang ito? (I-filter ang Konteksto)

• Kung ako mismo ang sumulat nito, paano ko ito isusulat? (Magbigay ng mga ideya)

Ikaw ang 1, at ang AI ang 0 sa likod. Kung ang 1 ay hindi maaaring tumayo, gaano man karaming 0 ang nasa likod, ito ay walang kahulugang pagkonsumo lamang.

Ilang Taos-pusong Salita

Ang kuwento ng "Isang Bilyong Token sa Isang Araw" ay maaaring hindi mangyari sa lahat. Ngunit ang pag-aaksaya ng Token ay isang bagay na halos bawat programmer na gumagamit ng AI programming ay nakaranas.

Bagama't pinadali ng AI ang programming, mayroon pa ring threshold. Ang mga taong talagang marunong gumamit nito ay magkakaroon ng pakinabang.

Dati, ang iyong masamang code ay "nakakadiri" lamang sa iyong mga kasamahan. Ngayon, ang katamaran na iyong ginawa ay direktang magiging isang numero sa bill, na pinarurusahan ang iyong sarili sa pamamagitan ng tumataas na gastos.Kaya, huwag maging "pabigat". Maging isang AI architect na may malalim na pag-iisip, tumpak na pagpapahayag, at nagpaplano bago kumilos. Ito rin ang ating pinakamalaking hindi mapapalitang katangian sa panahong ito.