ലക്ഷ്യം വെക്കുന്ന വായനക്കാർ: Cursor, Windsurf, trae തുടങ്ങിയ AI പ്രോഗ്രാമിംഗ് ടൂളുകൾ ഉപയോഗിക്കുന്ന ഡെവലപ്പർമാർ, AI ചെലവുകളെക്കുറിച്ച് വേണ്ടത്ര ധാരണയില്ലാത്ത ടെക്നിക്കൽ മാനേജർമാർ.

പ്രധാന ആശയം: ടോക്കൺ എന്നത് ഒരു സാധാരണ ബില്ലിംഗ് യൂണിറ്റ് മാത്രമല്ല, ഒരുതരം 'ശ്രദ്ധാ കേന്ദ്രീകരണത്തിനുള്ള ഉപാധിയും', 'കമ്പ്യൂട്ടിംഗ് പവറിൻ്റെ കറൻസിയുമാണ്'. Agent മോഡലുകളുടെ ദുരുപയോഗം, കോൺടെക്സ്റ്റ് മാനേജ്മെൻ്റിനെ അവഗണിക്കൽ എന്നിവ യഥാർത്ഥത്തിൽ തന്ത്രപരമായ സ്ഥിരോത്സാഹത്തിലൂടെ (AI-യെ ഉപയോഗിച്ച് അന്ധമായി പ്രവർത്തിപ്പിക്കുക) തന്ത്രപരമായ മടിയെ (സ്വന്തമായി ചിന്തിക്കാതിരിക്കുക) മറയ്ക്കുന്നതിന് തുല്യമാണ്.

നിങ്ങളുടെ 'AI ചെലവ്' നിങ്ങളുടെ ശമ്പളത്തേക്കാൾ ഉയർന്നതായിരിക്കാം

കഴിഞ്ഞ ദിവസം ഞാൻ എൻ്റെ ടോക്കൺ ബില്ലുകൾ പരിശോധിച്ചു. ആ സംഖ്യ കണ്ടപ്പോൾ ഞാൻ അത്ഭുതപ്പെട്ടുപോയിരുന്നു: 10 ദശലക്ഷം ടോക്കണുകൾ. ശ്രദ്ധിക്കുക, ഇത് ഒരു മാസത്തെ ഉപയോഗമല്ല, ഒരു ദിവസത്തേതാണ്.

ഇത് വളരെ കൂടുതലാണെന്ന് ഞാൻ കരുതി. പിന്നീട് ഞാൻ ടോക്കൺ കണക്കുകൂട്ടലുമായി ബന്ധപ്പെട്ട ഒരു വീഡിയോ പോസ്റ്റ് ചെയ്തു.

അതിൻ്റെ ഫലമായി, കമൻ്റ് ബോക്സിൽ ഞാൻ കണ്ടത് ഇതിലും വലിയ അത്ഭുതമായിരുന്നു.

ചുവടെയുള്ള ചിത്രം 'ഓൾഡ് കെ ഡെയ്‌ലി' എന്ന ഉപയോക്താവിൻ്റെ ഒരു ദിവസത്തെ രണ്ട് കോടി ടോക്കണുകൾ ഉപയോഗിച്ചതിൻ്റെ സ്ക്രീൻഷോട്ടാണ്:

ഇതൊരു ഒറ്റപ്പെട്ട സംഭവമാണെന്ന് ആദ്യം ഞാൻ കരുതി, എന്നാൽ നിരവധി ഉപയോക്താക്കൾ ഒരു ദിവസം ഒരു കോടി ടോക്കണുകൾ ഉപയോഗിക്കുന്നുണ്ടെന്ന് പറഞ്ഞപ്പോൾ, ഇത് വളരെ സാധാരണമായ ഒരു പ്രതിഭാസമാണെന്ന് എനിക്ക് മനസ്സിലായി.

ഒരു കോടി ടോക്കണുകൾ എന്നാൽ എന്താണ് അർത്ഥമാക്കുന്നത്? ചില പ്രധാന വാണിജ്യ മോഡലുകളുടെ സാധാരണ നിരക്ക് അനുസരിച്ച് (ഇൻപുട്ട് / ഔട്ട്പുട്ട് എന്നിവയ്ക്ക് പ്രത്യേകം നിരക്ക് ഈടാക്കുകയും ഏകദേശം 10 ഡോളർ / ദശലക്ഷം ടോക്കണുകൾക്ക് തുല്യമായി കണക്കാക്കുകയും ചെയ്താൽ), ഒരു ദിവസം 1000 ഡോളർ വരെ ചിലവാകും. ഒരു ദിവസം 7000 രൂപ വരെ. ഒരു സാധാരണ പ്രോഗ്രാമറുടെ ഒരു മാസത്തെ ശമ്പളം പോലും AI 'ചിന്തിക്കുന്നതിന്' തികഞ്ഞെന്ന് വരില്ല.

(ശ്രദ്ധിക്കുക: വ്യത്യസ്ത മോഡലുകൾ / വെണ്ടർമാർക്ക് വിലയിൽ വലിയ വ്യത്യാസങ്ങളുണ്ടാകാം, ഇൻപുട്ടിനും ഔട്ട്പുട്ടിനുമുള്ള വിലകൾ പലപ്പോഴും വ്യത്യസ്തമായിരിക്കും. ഇവിടെ ലക്ഷ്യമിടുന്നത് കൃത്യമായ കണക്കുകൂട്ടലുകൾ നടത്തുക എന്നതല്ല, മറിച്ച് ഏകദേശ ധാരണ നൽകുക എന്നതാണ്.)

നിങ്ങൾക്ക് സ്വയം കണക്കുകൂട്ടാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഇതാണ് പൊതുവായ ഫോർമുല (കാഷെ / ഡിസ്കൗണ്ട് തുടങ്ങിയ പ്രത്യേക നിയമങ്ങൾ ഒഴിവാക്കുക): ചെലവ് ≈ (ഇൻപുട്ട് ടോക്കണുകൾ / 1,000,000) × യൂണിറ്റ് വില_in + (ഔട്ട്പുട്ട് ടോക്കണുകൾ / 1,000,000) × യൂണിറ്റ് വില_out

ഇത് വളരെ വിചിത്രമായി തോന്നാം. AI വളരെ കുറഞ്ഞ ചിലവേറിയതാണെന്ന് നമ്മൾ കരുതുന്നു, OpenAI വില കുറയ്ക്കാൻ പോലും പോകുന്നു. എന്നാൽ യഥാർത്ഥ പ്രോജക്റ്റുകളിൽ ടോക്കണുകളുടെ ഉപഭോഗം ഒരു എക്സ്പോണൻഷ്യൽ സ്ഫോടനമായി മാറുന്നത് എന്തുകൊണ്ട്?

ഇന്ന്, ഈ 'ടോക്കൺ ബ്ലാക്ക് ഹോളിന്' പിന്നിലെ ലോജിക് എന്താണെന്നും, എങ്ങനെ ഈ നഷ്ടം ഒഴിവാക്കാമെന്നും നമുക്ക് ആഴത്തിൽ പരിശോധിക്കാം.

ഒന്ന്, എന്തുകൊണ്ട് ടോക്കണുകൾ 'എക്സ്പോണൻഷ്യൽ ആയി വർദ്ധിക്കുന്നു'?

പല ആളുകൾക്കും ടോക്കണുകളുടെ അളവിനെക്കുറിച്ച് ശരിയായ ധാരണയില്ല. അവർ ചിന്തിക്കുന്നു: "ഓ, കുറച്ച് കോഡുകളല്ലേ ഉണ്ടാകൂ? എത്ര ടോക്കണുകൾ ഉണ്ടാകാൻ ആണ്?"

1. വ്യക്തമായ ഒരു കണക്ക്

ആദ്യം, നമുക്ക് പ്രായോഗികമായി ഉപയോഗിക്കാൻ കഴിയുന്ന ഒരു അളവ് ഉണ്ടാക്കിയെടുക്കാം. ഒരു കാര്യം ഉറപ്പിച്ചു പറയാം: ടോക്കൺ എന്നത് അക്ഷരങ്ങളുടെ എണ്ണമല്ല, വാക്കുകളുടെ എണ്ണവുമല്ല. മോഡലുകൾ ടെക്സ്റ്റിനെ വിഭജിച്ചതിനുശേഷമുള്ള 'എൻകോഡിംഗ് ഭാഗങ്ങളാണ്' ടോക്കണുകൾ. ഓരോ മോഡലുകളും വ്യത്യസ്ത ടോക്കണൈസറുകളാണ് ഉപയോഗിക്കുന്നത്, അതിനാൽ ഒരു ഏകദേശ കണക്ക് മാത്രമേ നൽകാൻ കഴിയൂ.

താഴെ പറയുന്നവ ഒരു ഏകദേശ അളവായി കണക്കാക്കാം (ചെലവ് അറിയാനും, നഷ്ടം സംഭവിക്കാതെ നോക്കാനും ഇത് സഹായിക്കും):

• 1 ചൈനീസ് വാക്ക്: സാധാരണയായി 1–2 ടോക്കണുകൾ (കൂടുതൽ ഉപയോഗിക്കുന്ന വാക്കുകൾക്ക് 1-നോട് അടുത്തും, അല്ലാത്തവയ്ക്ക് 2–3 വരെയും)

• 1 ഇംഗ്ലീഷ് വാക്ക്: സാധാരണയായി 1.2–1.5 ടോക്കണുകൾ (ഏകദേശം 1.3 ആയി കണക്കാക്കാം)

• 1 ലൈൻ കോഡ് ≈ 10–50 ടോക്കണുകൾ (ഇൻഡൻ്റേഷൻ, കമൻ്റുകൾ, ടൈപ്പ് ഡിക്ലറേഷൻ എന്നിവ ഉൾപ്പെടെ)

• ലളിതമായ ബിസിനസ് ലോജിക് ≈ 12–20 ടോക്കണുകൾ

• ടൈപ്പ് അനോട്ടേഷൻ, ഇൻ്റർഫേസ്, ജെ.എസ്.ഡോക്, 4 സ്പേസ് ഇൻഡൻ്റേഷൻ എന്നിവയുൾപ്പെടെ ≈ 20–35 ടോക്കണുകൾ

• ധാരാളം ഇംപോർട്ട് / ഡെക്കറേറ്ററുകൾ / കമൻ്റുകൾ എന്നിവയുൾപ്പെടെ ≈ 30–50+ ടോക്കണുകൾ

• 1 സോഴ്സ് ഫയൽ (400–600 ലൈനുകൾ, ആധുനിക TS/Java പ്രോജക്റ്റ്) ≈ 4,000–24,000 ടോക്കണുകൾ സാധാരണമാണ് (ശരാശരി ≈ 12,000–18,000)

• 1 ഇടത്തരം പ്രോജക്റ്റ് (100–200 സോഴ്സ് ഫയലുകൾ, src/ മാത്രം, node_modules/ / ജനറേറ്റഡ് കോഡ് എന്നിവ ഇല്ലാതെ)

• പ്രധാന സോഴ്സ് കോഡ് 'ഒന്ന് വായിച്ചെടുക്കാൻ' തന്നെ ലക്ഷക്കണക്കിന് ടോക്കണുകൾ വേണ്ടിവരും.

• ടെസ്റ്റുകൾ, കോൺഫിഗറേഷനുകൾ, സ്ക്രിപ്റ്റുകൾ, ഡിപെൻഡൻസി ഡിക്ലറേഷനുകൾ, ലോഗുകൾ എന്നിവ കൂടി ചേർത്താൽ, കോടിക്കണക്കിന് ടോക്കണുകൾ ചിലവാകും.

ഇപ്പോഴത്തെ ഫ്രണ്ടെൻഡ് പ്രോജക്റ്റുകൾ മിക്കവയും TypeScript-ൽ ഉള്ളതും, സങ്കീർണ്ണമായ ഇൻ്റർഫേസ് ഡെഫനിഷനുകൾ നിറഞ്ഞതുമാണ്. അല്ലെങ്കിൽ Java ആണെങ്കിൽ, ധാരാളം ഇംപോർട്ടുകൾ ഉണ്ടാകും. ഈ 'ബോയിലർപ്ലേറ്റ് കോഡുകൾ' ടോക്കണുകൾ കൂടുതൽ ഉപയോഗിക്കുന്നതിന് കാരണമാകുന്നു. ഒരു ഇടത്തരം പ്രോജക്റ്റിൽ 100 ഫയലുകൾ ഉണ്ടെങ്കിൽ, AI ആ കോഡ് വായിച്ചെടുക്കാൻ തന്നെ 10 ലക്ഷം ടോക്കണുകൾ വരെ ചിലവായേക്കാം.

2. ടോക്കണുകളുടെ 'സ്നോബോൾ' ഇഫക്റ്റ്

ഒറ്റത്തവണത്തെ സംഭാഷണത്തേക്കാൾ കൂടുതൽ ടോക്കൺ ഉപഭോഗം ഉണ്ടാകുന്നത്, തുടർച്ചയായ സംഭാഷണങ്ങളിൽ കോൺടെക്സ്റ്റ് വർദ്ധിക്കുന്നതിനാലാണ്.

LLM-ൻ്റെ മെക്കാനിസം സ്റ്റേറ്റ്ലെസ്സ് ആണ്. AI-ക്ക് നിങ്ങളുടെ അവസാനത്തെ ചോദ്യം ഓർമ്മയുണ്ടാകാൻ, സിസ്റ്റം സാധാരണയായി 'സിസ്റ്റം പ്രോംപ്റ്റ് + പഴയ സംഭാഷണങ്ങൾ + നിങ്ങൾ നൽകിയിട്ടുള്ള ഫയലുകൾ / കോഡ് ഭാഗങ്ങൾ + ടൂൾ ഉപയോഗിച്ചുള്ള ഔട്ട്പുട്ടുകൾ (ഉദാഹരണത്തിന് സെർച്ച് റിസൾട്ടുകൾ, എറർ ലോഗുകൾ)' എന്നിവ ഒരുമിപ്പിച്ച് മോഡലിലേക്ക് അയയ്ക്കുന്നു. നിങ്ങൾ ഒരു ചോദ്യം മാത്രമേ ചോദിച്ചുള്ളൂ എന്ന് നിങ്ങൾ വിചാരിക്കും, എന്നാൽ നിങ്ങൾ ആവർത്തിച്ച് 'മുഴുവൻ കോൺടെക്സ്റ്റ് പാക്കേജിനും' പണം നൽകുകയാണ്.

• ഒന്നാമത്തെ റൗണ്ട്: 10,000 ടോക്കണുകൾ അയയ്ക്കുന്നു, AI 1,000 ടോക്കണുകൾ മറുപടി നൽകുന്നു.

• രണ്ടാമത്തെ റൗണ്ട്: (10,000 + 1,000 + പുതിയ ചോദ്യം) അയയ്ക്കുന്നു, AI മറുപടി നൽകുന്നു...

• പത്താമത്തെ റൗണ്ട്: നിങ്ങളുടെ കോൺടെക്സ്റ്റ് 2 ലക്ഷം ടോക്കണുകളായി വർദ്ധിച്ചിരിക്കാം.

ഈ സമയം, നിങ്ങൾ ഒരു വേരിയബിളിൻ്റെ പേര് മാറ്റാൻ ആവശ്യപ്പെട്ടാൽ പോലും, 2 ലക്ഷം ടോക്കണുകളുടെ ഫീസാണ് ഈടാക്കുന്നത്. അതുകൊണ്ടാണ് നിങ്ങൾ ഒന്നും ചെയ്തില്ലെങ്കിലും ബില്ലുകൾ കുതിച്ചുയരുന്നത്.

കൂടുതൽ ഗുരുതരമായ കാര്യം: Agent മോഡൽ 'സ്വയം ഫയലുകൾ വായിക്കുന്നു' എന്നതാണ്. നിങ്ങൾ "എൻ്റെ യൂസർ മൊഡ്യൂൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ സഹായിക്കാമോ" എന്ന് ചോദിച്ചാൽ, അത് ആദ്യം ബന്ധപ്പെട്ട ഡയറക്ടറി സ്കാൻ ചെയ്യുകയും, തുടർന്ന് ഡിപെൻഡൻസികളിലേക്ക് പോകുകയും, പിന്നീട് കോൺഫിഗറേഷനുകളിലേക്കും, ടെസ്റ്റുകളിലേക്കും പോകുന്നു... ഇത് മടി കാണിക്കുകയല്ല, മറിച്ച് 'സ്ഥിരമായ രീതിയിൽ ഉത്തരവാദിത്തം നിറവേറ്റുകയാണ്', സ്ഥിരമായ രീതി എന്നത്: കൂടുതൽ വായിക്കുക, കൂടുതൽ ശ്രമിക്കുക, കൂടുതൽ ആവർത്തിക്കുക എന്നതാണ്.

രണ്ട്, രണ്ട് തരം 'മടികൾ' നിങ്ങളുടെ എഞ്ചിനീയറിംഗ് കഴിവുകളെ നശിപ്പിക്കുന്നു

കമൻ്റ് ബോക്സിലെ ചില 'ഒരു കോടി സഹോദരന്മാരെ'ക്കുറിച്ച് പഠിച്ചതിന് ശേഷം, ടോക്കണുകൾ കുതിച്ചുയരാനുള്ള കാരണം AI-യുടെ ഉപഭോഗം മാത്രമല്ല, ആളുകളുടെ മടിയും ഒരു കാരണമാണെന്ന് ഞാൻ കണ്ടെത്തി.

താഴെ പറയുന്നവ രണ്ട് തരത്തിലുള്ള 'ചിന്താപരമായ മടികളാണ്'.

മടി ഒന്ന്: ഉത്തരവാദിത്തമില്ലാത്ത മാനേജർ

നിങ്ങൾക്കും ഈ മനോഭാവം ഉണ്ടായിരിക്കാം:

• "ഈ പഴയ പ്രോജക്റ്റ് വളരെ മോശമാണ്, എനിക്ക് ലോജിക് മനസ്സിലാക്കാൻ മടിയാണ്, അതിനാൽ AI-ക്ക് നൽകാം."

• "Cursor-ൽ Agent മോഡ് ഉണ്ട്, വളരെ നല്ലത്, അതിനെക്കൊണ്ട് തന്നെ ബഗുകൾ പരിഹരിപ്പിക്കാം."

തുടർന്ന്, നിങ്ങൾ src ഫോൾഡർ മുഴുവനായി Agent-ന് നൽകി, അവ്യക്തമായ ഒരു നിർദ്ദേശം നൽകുന്നു: "എൻ്റെ യൂസർ മൊഡ്യൂൾ ഒപ്റ്റിമൈസ് ചെയ്യാൻ സഹായിക്കൂ." Agent പ്രവർത്തിക്കാൻ തുടങ്ങുന്നു:

• ഇത് 50 ഫയലുകൾ വായിക്കുന്നു (5 ലക്ഷം ടോക്കണുകൾ ഉപയോഗിക്കുന്നു).

• ഇത് utils ഉപയോഗിക്കുന്നുവെന്ന് കണ്ടെത്തുന്നു, തുടർന്ന് ടൂൾ ക്ലാസുകൾ വായിക്കുന്നു (2 ലക്ഷം ടോക്കണുകൾ ഉപയോഗിക്കുന്നു).

• ഇത് മാറ്റങ്ങൾ വരുത്താൻ ശ്രമിക്കുന്നു, പിശക് സംഭവിക്കുന്നു, പിശക് ലോഗുകൾ വായിക്കുന്നു (1 ലക്ഷം ടോക്കണുകൾ ഉപയോഗിക്കുന്നു).

• ഇത് വീണ്ടും നന്നാക്കാൻ ശ്രമിക്കുന്നു, വീണ്ടും പിശക് സംഭവിക്കുന്നു...

ഇത് ഭ്രാന്തമായി ശ്രമിച്ചുകൊണ്ടേയിരിക്കുന്നു, ടോക്കണുകൾ ഉപയോഗിച്ചുകൊണ്ടേയിരിക്കുന്നു. എന്നാൽ നിങ്ങൾ എന്ത് ചെയ്യുന്നു? നിങ്ങൾ ഫോൺ നോക്കുന്നു, നിങ്ങളുടെ കാര്യക്ഷമതയെക്കുറിച്ച് സ്വയം അഭിനന്ദിക്കുന്നു. സത്യം ഇതാണ്: നിങ്ങൾ പണം കൊടുത്ത് വാങ്ങുന്നത് വ്യാജമായ കാര്യക്ഷമതയാണ്, അത് പിന്നീട് നിങ്ങൾക്ക് പരിപാലിക്കാൻ കഴിയാത്ത കോഡുകൾ ഉണ്ടാക്കുന്നു.

കൂടുതൽ വ്യക്തമായി പറഞ്ഞാൽ, ഇവിടെ രണ്ട് തരത്തിലുള്ള നഷ്ടങ്ങളുണ്ട്:

• ചെലവ്: ഇൻപുട്ട് ടോക്കണുകൾ വലുതാകുന്നു, ആവർത്തനങ്ങളുടെ എണ്ണം കൂടുന്നു, അതിനാൽ ചെലവ് കൂടിക്കൊണ്ടേയിരിക്കുന്നു.

• എഞ്ചിനീയറിംഗ്: നിങ്ങൾക്ക് കോൺടെക്സ്റ്റും തീരുമാനമെടുക്കാനുള്ള കഴിവും നഷ്ടപ്പെടുന്നു, അവസാനം നിയന്ത്രിക്കാൻ കഴിയാത്ത ഒരു സിസ്റ്റം അവശേഷിക്കുന്നു.

മടി രണ്ട്: എല്ലാം ഒരുമിച്ചുള്ള സമീപനം

ഒരു ബഗ് ഉണ്ടാകുമ്പോൾ, നിങ്ങൾ എങ്ങനെയാണ് AI-ക്ക് നൽകുന്നത്? നിങ്ങൾ നേരിട്ട് Ctrl+A അമർത്തി മുഴുവൻ എറർ കൺസോൾ കോപ്പി ചെയ്ത് നൽകുകയോ, അല്ലെങ്കിൽ AI സ്വയം കണ്ടെത്താനായി @Codebase ഉപയോഗിച്ച് നൽകുകയോ ചെയ്യുമോ?

ഇതിനെയാണ് 'എല്ലാം ഒരുമിച്ചുള്ള സമീപനം' എന്ന് പറയുന്നത്. പ്രശ്നത്തിൻ്റെ പ്രധാന ഭാഗം കണ്ടെത്താൻ നിങ്ങൾക്ക് മടിയാണ്, പ്രധാന കോഡ് ഭാഗങ്ങൾ തിരഞ്ഞെടുക്കാൻ നിങ്ങൾക്ക് മടിയാണ്. നിങ്ങൾ 99% ഉപയോഗമില്ലാത്ത വിവരങ്ങളും (ശബ്ദം) 1% ഉപയോഗപ്രദമായ വിവരങ്ങളും (സിഗ്നൽ) AI-ക്ക് നൽകുന്നു.

AI ഒരു ആംപ്ലിഫയർ പോലെയാണ്.

• നിങ്ങൾ വ്യക്തമായ ലോജിക് (സിഗ്നൽ) നൽകുകയാണെങ്കിൽ, അത് നിങ്ങളുടെ ബുദ്ധിയെ വർദ്ധിപ്പിക്കുന്നു, ടോക്കണുകൾ കുറച്ച് മാത്രം ഉപയോഗിക്കുകയും നല്ല ഫലം നൽകുകയും ചെയ്യുന്നു.

• നിങ്ങൾ ആശയക്കുഴപ്പവും അവ്യക്തതയും നൽകുകയാണെങ്കിൽ, അത് നിങ്ങളുടെ ആശയക്കുഴപ്പം വർദ്ധിപ്പിക്കുന്നു, ടോക്കണുകൾ കുതിച്ചുയരുന്നു, ഉപയോഗശൂന്യമായവ മാത്രം ഉത്പാദിപ്പിക്കുന്നു.

മൂന്ന്, പരിഹാരം: AI എങ്ങനെ കാര്യക്ഷമമായി ഉപയോഗിക്കാം, ടോക്കൺ ഉപഭോഗം എങ്ങനെ കുറയ്ക്കാം

നിങ്ങളുടെ പണം സംരക്ഷിക്കാൻ, നിങ്ങളുടെ എഞ്ചിനീയറിംഗ് നിയന്ത്രണം നിലനിർത്തേണ്ടത് പ്രധാനമാണ്, AI-യുമായുള്ള നിങ്ങളുടെ സഹകരണ രീതി നമ്മൾ മാറ്റണം.

1. ഏറ്റവും കുറഞ്ഞ കോൺടെക്സ്റ്റ് തത്വം

ഇതാണ് AI പ്രോഗ്രാമിംഗിൻ്റെ അടിസ്ഥാന തത്വം. നിലവിലെ പ്രശ്നം പരിഹരിക്കുന്നതിന് ആവശ്യമായ ഏറ്റവും കുറഞ്ഞ കോഡ് മാത്രം AI-ക്ക് നൽകുക.

Cursor-ൽ, ഈ ഓപ്പറേറ്ററുകൾ നന്നായി ഉപയോഗിക്കുക:

• @File: മുഴുവൻ ഫോൾഡറും നൽകുന്നതിന് പകരം, ബന്ധപ്പെട്ട ഫയലുകൾ മാത്രം നൽകുക.

• Ctrl+L കോഡ് തിരഞ്ഞെടുക്കുക: മുഴുവൻ ഫയലും നൽകുന്നതിന് പകരം, നിങ്ങൾ സെലക്ട് ചെയ്ത 50 ലൈനുകൾ മാത്രം Chat-ലേക്ക് അയയ്ക്കുക.

• @Docs: മൂന്നാമത്തെ പാർട്ടിയുടെ ലൈബ്രറികൾക്കായി, AI-യോട് ഊഹിക്കാൻ പറയുന്നതിന് പകരം ഡോക്യുമെൻ്റേഷൻ നൽകുക.

ഞാൻ പതിവായി ഉപയോഗിക്കുന്നതും, ഘടനാപരമായതും, വീണ്ടും ഉപയോഗിക്കാൻ കഴിയുന്നതുമായ SOP ഇതാ (നിങ്ങൾ ഇത് ചെയ്താൽ, ടോക്കണുകൾ കുറയുന്നത് നിങ്ങൾക്ക് കാണാൻ കഴിയും):

ഇതിൻ്റെ അർത്ഥം ഇതാണ്: AI-യുമായി സഹകരിക്കുമ്പോൾ, കാര്യക്ഷമതയും കൃത്യതയും ശ്രദ്ധിക്കുക. എങ്ങനെ ചെയ്യാമെന്ന് താഴെ നൽകുന്നു:

• ആദ്യം ലക്ഷ്യം വ്യക്തമാക്കുക: AI-യോട് നിലവിലെ പ്രശ്നവും നിങ്ങൾ പ്രതീക്ഷിക്കുന്ന ഫലവും വ്യക്തമായി പറയുക, അത് സ്വയം ഊഹിക്കാൻ അനുവദിക്കരുത്.

• പ്രശ്നം ലളിതമാക്കുക: സങ്കീർണ്ണമായ രീതി ഉപയോഗിക്കുന്നതിന് പകരം ലളിതമായ രീതിയിൽ പ്രശ്നം ആവർത്തിക്കുക, കുറഞ്ഞതും പ്രധാനപ്പെട്ടതുമായ കോഡുകൾ മാത്രം നൽകുക, ധാരാളം ആവശ്യമില്ലാത്തവ നൽകരുത്.

• ഏറ്റവും കുറഞ്ഞ വിവരങ്ങൾ നൽകുക: 1-3 ഫയലുകൾ, പ്രധാനപ്പെട്ട ഫംഗ്ഷനുകൾ, എറർ സ്റ്റാക്കിൻ്റെ ആദ്യത്തെ കുറച്ച് ലൈനുകൾ എന്നിവ മാത്രം നൽകുക, എല്ലാ വിവരങ്ങളും നൽകേണ്ടതില്ല.

• മാറ്റങ്ങൾ മാത്രം നൽകാൻ ആവശ്യപ്പെടുക: AI എവിടെയാണ് മാറ്റം വരുത്തേണ്ടതെന്നും, എന്തുകൊണ്ട് മാറ്റം വരുത്തണമെന്നും മാത്രം പറയാൻ ആവശ്യപ്പെടുക, മുഴുവൻ കോഡും വീണ്ടും എഴുതാൻ പറയരുത്.

• അവസാനം നിങ്ങൾ തന്നെ ഉറപ്പുവരുത്തുക: മാറ്റങ്ങൾ വരുത്തിയത് മറ്റ് ഭാഗങ്ങളെ ബാധിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുക.

ചുരുക്കത്തിൽ, ഏറ്റവും കുറഞ്ഞതും പ്രധാനപ്പെട്ടതുമായ വിവരങ്ങൾ ഉപയോഗിച്ച് AI-യെ പ്രവർത്തിപ്പിക്കുക, കൂടാതെ അന്തിമ നിയന്ത്രണവും തീരുമാനമെടുക്കാനുള്ള കഴിവും നിലനിർത്തുക.

2. ഏറ്റവും പ്രധാനപ്പെട്ടത്: ആദ്യം ചിന്തിക്കുക, പിന്നീട് പ്രോംപ്റ്റ് നൽകുക, ആദ്യം പ്ലാൻ ചെയ്യുക, പിന്നീട് പ്രവർത്തിക്കുക

Enter അമർത്തുന്നതിന് മുമ്പ്, 10 സെക്കൻഡ് നിർത്തി സ്വയം മൂന്ന് ചോദ്യങ്ങൾ ചോദിക്കുക:

• ഞാൻ എന്താണ് പരിഹരിക്കുന്നത്? (അതിരുകൾ നിർവ്വചിക്കുക)

• ഈ പ്രശ്നത്തിൽ ഏതൊക്കെ പ്രധാന മൊഡ്യൂളുകളാണ് ഉൾപ്പെട്ടിരിക്കുന്നത്? (കോൺടെക്സ്റ്റ് തിരഞ്ഞെടുക്കുക)

• ഞാനാണ് ഇത് എഴുതുന്നതെങ്കിൽ, ഞാൻ എങ്ങനെ എഴുതും? (ഒരു ആശയം നൽകുക)

നിങ്ങളാണ് 1, AI പിന്നിലുള്ള 0 ആണ്. 1 ശരിയായില്ലെങ്കിൽ, പിന്നിലുള്ള എത്ര പൂജ്യങ്ങൾ ഉണ്ടായാലും അത് ഉപയോഗശൂന്യമാണ്.

ചില ആത്മാർത്ഥമായ വാക്കുകൾ

"ഒരു ദിവസം ഒരു കോടി ടോക്കണുകൾ" എന്ന കഥ ഒരുപക്ഷേ എല്ലാവർക്കും സംഭവിക്കണമെന്നില്ല. എന്നാൽ ടോക്കണുകൾ പാഴാക്കുന്ന സ്വഭാവം, AI പ്രോഗ്രാമിംഗ് ഉപയോഗിക്കുന്ന മിക്ക പ്രോഗ്രാമർമാർക്കും ഉണ്ടാകാറുണ്ട്.

AI പ്രോഗ്രാമിംഗ് എളുപ്പമാക്കിയെങ്കിലും, ഇപ്പോളും ചില തടസ്സങ്ങളുണ്ട്. ശരിയായി ഉപയോഗിക്കുന്നവർക്ക് മാത്രമേ ഇതിലൂടെ നേട്ടമുണ്ടാക്കാൻ കഴിയൂ.

മുമ്പ്, നിങ്ങൾ മോശം കോഡുകൾ എഴുതിയാൽ അത് നിങ്ങളുടെ സഹപ്രവർത്തകരെ മാത്രമേ ബുദ്ധിമുട്ടിക്കുകയുള്ളൂ. ഇപ്പോൾ, നിങ്ങൾ കാണിക്കുന്ന മടി നിങ്ങളുടെ ബില്ലിൽ കാണാൻ കഴിയും, അത് നിങ്ങളുടെ വർദ്ധിച്ചുവരുന്ന ചെലവുകളിലൂടെ നിങ്ങളെത്തന്നെ ശിക്ഷിക്കും.അതുകൊണ്ട്, "കൈകഴുകുന്ന മാനേജരാകരുത്." ആഴത്തിലുള്ള ചിന്തയും കൃത്യമായ ആവിഷ്കാരവും ആസൂത്രണത്തിന് ശേഷം പ്രവർത്തനവും ഉള്ള ഒരു AI ആർക്കിടെക്റ്റ് ആകുക. ഈ കാലഘട്ടത്തിലെ നമ്മുടെ ഏറ്റവും വലിയ മാറ്റമില്ലാത്ത സ്വഭാവവും ഇതുതന്നെയാണ്.