ChatGPT, GitHub Copilot, Cursor എന്നിവയും അവയുടെ മറ്റ് സമാനമായ ടൂളുകളും നിങ്ങൾ പ്രോംപ്റ്റ് ടൈപ്പ് ചെയ്തു തീരുന്നതിന് മുമ്പ് തന്നെ ഒരു React component തയ്യാറാക്കാൻ സാധിക്കും. ഒരു Next.js റൂട്ടിനെ Supabase-മായി ബന്ധിപ്പിക്കണോ? നിമിഷങ്ങൾക്കുള്ളിൽ അത് നടക്കും. കുഴഞ്ഞുമറിഞ്ഞ ഒരു TypeScript utility റീഫാക്ടർ ചെയ്യണോ? ടൈപ്പ് ഗാർഡുകൾ ഉൾപ്പെടെ മൂന്ന് ഓപ്ഷനുകൾ ഇതാ. ആധുനിക വെബ് സ്റ്റാക്കുകളിൽ ജോലി ചെയ്യുന്ന ആർക്കും ഈ അനുഭവം ഒരു മാന്ത്രികത പോലെ തോന്നാം.

ഞാൻ ഈ ടൂളുകൾ ദിവസവും ഉപയോഗിക്കുന്നു. എന്റെ സ്റ്റാക്ക് Next.js, TypeScript, Supabase എന്നിവയാണ്; കസ്റ്റം ഹുക്കുകൾ നിർമ്മിക്കാനും, ഡാറ്റാബേസ് ക്വറികൾ തയ്യാറാക്കാനും, അല്ലെങ്കിൽ കുഴഞ്ഞുമറിഞ്ഞ കണ്ടീഷണൽ ലോജിക് ശരിയാക്കാനും AI എന്റെ എഡിറ്ററിൽ എപ്പോഴും തയ്യാറാണ്. ചെറിയ കാര്യങ്ങളിൽ, വളരെ വേഗതയുള്ള ഒരു ജൂനിയർ ഡെവലപ്പറെപ്പോലെ ഇത് പ്രവർത്തിക്കുന്നു. ഇതിന് സിന്റാക്സ് കൃത്യമായി അറിയാം. ഗൂഗിളിൽ തിരയേണ്ടി വരുന്ന API വിവരങ്ങൾ ഇത് ഓർത്തു വെക്കുന്നു. ബോയിലർപ്ലേറ്റ് കോഡുകൾ എഴുതി മടുപ്പും ഇതിനില്ല.

എന്നാൽ സോഫ്റ്റ്‌വെയറുകൾ ഇപ്പോഴും തകരാറിലാകുന്നു. ആപ്പുകൾ പതുക്കെയാകുന്നു. കസ്റ്റമർ ഡാഷ്‌ബോർഡുകൾ ലാഗ് ചെയ്യുന്നു. എഡ്ജ് കേസുകൾ ഫോമുകൾ ക്രാഷ് ചെയ്യുന്നു. AI കോഡിംഗ് ഇത്ര എളുപ്പമാക്കിയെങ്കിൽ, എന്തുകൊണ്ടാണ് ഏതാനും വർഷങ്ങൾക്കു മുൻപത്തേക്കാൾ സോഫ്റ്റ്‌വെയർ ഉപയോഗിക്കുന്നത് ഇപ്പോൾ മോശമായി തോന്നുന്നത്?

ഉത്തരം ഇതാണ്: സിന്റാക്സ് നിർമ്മിക്കുന്നതും സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതും ഒരേ കാര്യമല്ല.

സിന്റാക്സ് എന്നാൽ ആർക്കിടെക്ചർ അല്ല

AI ടോക്കണുകളെ അത്ഭുതകരമായ രീതിയിൽ കൈകാര്യം ചെയ്യുന്നു. ഒരു Supabase റിയൽ-ടൈം ചാനലിനെ നിരീക്ഷിക്കുന്ന ഒരു useEffect ഹുക്ക് എഴുതാൻ ആവശ്യപ്പെട്ടാൽ, നിങ്ങൾക്ക് കംപൈൽ ചെയ്യാൻ കഴിയുന്ന ഒന്ന് ലഭിക്കും. ഒരു ടൈപ്പ് ഇല്ലാത്ത JavaScript ഫയലിനെ സ്ട്രിക്റ്റ് TypeScript ആക്കി മാറ്റാനോ, അല്ലെങ്കിൽ നിങ്ങൾ കാപ്പി കുടിക്കുന്നതിന് മുമ്പ് തന്നെ Zod വാലിഡേഷനോടു കൂടിയ ഒരു ഫോം കോമ്പോണന്റ് തയ്യാറാക്കാനോ ഇതിന് കഴിയും.

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

ഒരു വീട്ടിൽ ഒരിക്കലും താമസിക്കാത്ത ഒരു ആർക്കിടെക്റ്റിനെക്കുറിച്ച് ചിന്തിക്കുക. അവർക്ക് മനോഹരമായ ഫ്ലോർ പ്ലാനുകൾ വരയ്ക്കാൻ കഴിയും. ഒരു ബെഡ്‌റൂമിൽ എത്ര ജനലുകൾ വേണമെന്ന് അവർക്കറിയാം. എന്നാൽ ഫെബ്രുവരി മാസത്തിൽ എവിടെയാണ് പൈപ്പുകൾ ചോരാൻ സാധ്യതയെന്നും, വേനൽക്കാലത്തെ ചൂടിൽ ഏത് ഇടനാഴി ഉപയോഗിക്കാൻ കഴിയില്ലെന്നും അവർക്കറിയില്ല. ആ പ്രായോഗിക അറിവാണ് ഒരു കെട്ടിടത്തെ നിലനിർത്തുന്നത്. കോഡിന്റെ കാര്യവും അതുപോലെ തന്നെയാണ്.

രണ്ട് തടസ്സങ്ങൾ (The Two Friction Points)

കർശനമായ നിയന്ത്രണങ്ങളില്ലാതെ AI-യെ വലിയ കോഡ് ഭാഗങ്ങൾ എഴുതാൻ അനുവദിക്കുമ്പോൾ, ഒരേ രണ്ട് പ്രശ്നങ്ങൾ വീണ്ടും വീണ്ടും ഉണ്ടാകുന്നത് ഞാൻ ശ്രദ്ധിക്കുന്നു.

ഒന്നാമതായി, നിങ്ങൾ നേരത്തെ നിശ്ചയിച്ചിട്ടുള്ള ഡിസൈൻ പാറ്റേണുകളെ അത് അവഗണിക്കുന്നു. ഒരുപക്ഷേ നിങ്ങളുടെ ടീം എല്ലാ ഡാറ്റാ ഫെച്ചിംഗും കസ്റ്റം ഹുക്കുകളുടെ ഒരു പ്രത്യേക ലെയറിലേക്ക് മാറ്റിക്കാണും. അല്ലെങ്കിൽ Supabase RLS പോളിസികൾ ഫ്രണ്ട്‌എൻഡ് ഹെൽപ്പർമാരുമായി എങ്ങനെ ബന്ധപ്പെടണം എന്നതിന് കൃത്യമായ നിയമങ്ങൾ ഉണ്ടാകാം. AI ഇതൊന്നും പരിഗണിക്കുന്നില്ല. പ്രോംപ്റ്റിന് ഉത്തരം നൽകാൻ അത് മതിയാകും എന്നതുകൊണ്ട് ഒരു ബട്ടണിന്റെ onClick-ൽ നേരിട്ട് ഒരു supabase.from().select() ഉപയോഗിച്ചേക്കാം. കോഡ് പ്രവർത്തിക്കും, അത് വൃത്തിയുള്ളതായും തോന്നും. എന്നാൽ അത് നിങ്ങളുടെ കോഡ്‌ബേസിലെ ഒരു വ്യതിയാനമാണ് (outlier), കൂടാതെ ഓരോ വ്യതിയാനവും ഭാവിയിൽ റീഫാക്റ്ററിംഗിനായുള്ള അധിക ജോലി തന്നെയാണ്. ആറ് മാസത്തിന് ശേഷം, ആ കോഡ് കണ്ടെത്താനും അത് എന്തുകൊണ്ട് അവിടെ വന്നു എന്ന് മനസ്സിലാക്കാനും അത് ശരിയായ രീതിയിലേക്ക് മാറ്റാനും ആരോ ഒരാൾക്ക് കഷ്ടപ്പെടേണ്ടി വരും.

രണ്ടാമതായി, ലളിതമായ രീതിയിൽ ചെയ്യാവുന്ന കാര്യങ്ങൾക്ക് പോലും അത് സങ്കീർണ്ണത ഉപയോഗിക്കുന്നു. അബ്‌സ്‌ട്രാക്റ്റ് ഫാക്ടറികൾ, സങ്കീർണ്ണമായ റിഡ്യൂസർ പാറ്റേണുകൾ, മൾട്ടി-ലെയർ ഹയർ-ഓർഡർ കോമ്പോണന്റുകൾ എന്നിവ ആവശ്യമായ വലിയ റെപ്പോസിറ്ററികളെ അടിസ്ഥാനമാക്കിയാണ് ഈ ടൂൾ പരിശീലിപ്പിക്കപ്പെട്ടിരിക്കുന്നത്. ഒരു ലളിതമായ കോൺടാക്റ്റ് ഫോം നിർമ്മിക്കാൻ ആവശ്യപ്പെട്ടാൽ, അത് ഒരു സ്റ്റേറ്റ് മെഷീനും, ഒരു കോൺടെക്സ്റ്റ് പ്രൊവൈഡറും, മൂന്ന് ഫയലുകളിലായി വ്യാപിച്ചു കിടക്കുന്ന ഒരു കസ്റ്റം ഹുക്ക് അബ്‌സ്‌ട്രാക്ഷനും നിങ്ങൾക്ക് നൽകിയേക്കാം. സാങ്കേതികമായി ആ പരിഹാരം തെറ്റല്ല. പക്ഷേ അത് അമിതഭാരമുള്ളതാണ്. ഓരോ അനാവശ്യ ലെയറും നിങ്ങളുടെ കോഗ്നിറ്റീവ് ഡെബ്റ്റ് (cognitive debt) വർദ്ധിപ്പിക്കുന്നു. നിങ്ങൾ ജോലി ഒഴിവാക്കുകയല്ല ചെയ്തത്; മറിച്ച് പലിശ സഹിതം അത് ഭാവിയിലേക്ക് മാറ്റിവെക്കുകയാണ് ചെയ്തത്.

വേഗതയുടെ കെണി (The Velocity Trap)

ഇവിടെ അപകടകരമായ ഒരു ഫീഡ്‌ബാക്ക് ലൂപ്പ് ഉണ്ട്. AI ഫീച്ചറുകൾ ഇരട്ടി വേഗത്തിൽ നിർമ്മിക്കാൻ നിങ്ങളെ സഹായിക്കുന്നു, എന്നാൽ മനുഷ്യന്റെ ശ്രദ്ധ അതേ രീതിയിൽ വർദ്ധിപ്പിക്കാൻ കഴിയില്ല. നിങ്ങൾ പകുതി സമയത്തിനുള്ളിൽ ഫീച്ചറുകൾ പുറത്തിറക്കുന്നുണ്ടെങ്കിൽ, കോഡ് റിവ്യൂവിനായി നിങ്ങൾ ഇരട്ടി സമയം ചെലവഴിക്കുന്നുണ്ടോ? നിങ്ങൾ കൂടുതൽ ടെസ്റ്റുകൾ എഴുതുന്നുണ്ടോ അതോ കുറയ്ക്കുകയാണോ?

പ്രായോഗികമായി പറഞ്ഞാൽ, AI നിർമ്മിച്ച കോഡുകൾ കാണാൻ വളരെ വിശ്വസനീയമായി തോന്നും, അതിനാൽ അവയെ വിശ്വസിക്കുക എന്നത് എളുപ്പമാണ്. അത് ആധുനിക സിന്റാക്സ് ഉപയോഗിക്കുന്നു, കൃത്യമായ ഇടങ്ങളിൽ കമന്റുകൾ നൽകുന്നു, വേരിയബിൾ പേരുകൾ പ്രൊഫഷണലായി തോന്നും. എന്നാൽ ആ തിളക്കത്തിനിടയിൽ സൂക്ഷ്മമായ ബഗുകൾ ഒളിഞ്ഞിരിപ്പുണ്ടാകാം. ഒരു ഹുക്കിലെ ഡിപെൻഡൻസി അarray-യിൽ ഒരു സെറ്റർ വിട്ടുപോയേക്കാം. സാങ്കേതികമായി ശരിയായ എന്നാൽ നിങ്ങൾ കൈകാര്യം ചെയ്യാൻ മറന്നുപോയ ഒരു null സ്റ്റേറ്റ് അനുവദിക്കുന്ന ഒരു TypeScript ടൈപ്പ് ഉണ്ടാകാം. നിങ്ങളുടെ സ്കീമയിലെ സോഫ്റ്റ്-ഡിലീറ്റ് ചെയ്ത വരികൾ കണക്കിലെടുക്കാൻ മറന്നുപോയ ഒരു Supabase ക്വറി ഉണ്ടാകാം. ഡെലിവറി വേഗത ആവശ്യമായതുകൊണ്ട് നിങ്ങൾ ഓരോ വരിയും വായിക്കുന്നതിന് പകരം വേഗത്തിൽ കണ്ണോടിക്കുന്നു. തിങ്കളാഴ്ച ആ വേഗത വളരെ മികച്ചതായി തോന്നും. എന്നാൽ വെള്ളിയാഴ്ച രാത്രി പന്ത്രണ്ട് മണി വരെ നീളുന്ന ഡീബഗ്ഗിംഗ് സെഷനുകൾ ഉണ്ടാകാം.

യഥാർത്ഥ വില

ഇതിന്റെ വില നൽകേണ്ടി വരുന്നത് ഡെവലപ്പർമാരല്ല. അത് അന്തിമ ഉപഭോക്താക്കളാണ് (end users).

Software feels clunkier because complexity is growing faster than teams can steward it. We are building bigger applications with smaller crews, armed with tools that make us feel invincible. When one developer can scaffold an entire dashboard in an afternoon, the organization expects three dashboards by Wednesday. Scale without care produces fragile systems. State balloons. Bundle sizes creep up. Race conditions multiply. The interface might look modern, but it resets itself when a user hits the back button, or it takes four seconds to hydrate because nobody had time to profile the waterfall of AI-generated data fetches.

Work With the Machine, Not For It

None of this means you should throw AI out of your editor. It means you need boundaries.

Use it for what it is good at. Let it write the dull stuff: repetitive TypeScript interfaces, boilerplate Supabase queries, Jest setup