ChatGPT, GitHub Copilot, Cursor અને તેના સમાન અન્ય સાધનો હવે તમે પ્રોમ્પ્ટ લખવાનું પૂરું કરો તે પહેલાં જ React component બનાવી શકે છે. Next.js route ને Supabase સાથે જોડવું છે? સેકન્ડોમાં થઈ જશે. તે ગૂંચવાયેલ TypeScript utility ને refactor કરવું છે? અહીં type guards સાથે ત્રણ વિકલ્પો છે. આધુનિક web stacks માં કામ કરનાર કોઈપણ વ્યક્તિ માટે, આ અનુભવ લગભગ જાદુઈ જેવો હોઈ શકે છે.
હું આ સાધનોનો દરરોજ ઉપયોગ કરું છું. મારું stack Next.js, TypeScript અને Supabase છે, અને AI મારા editor માં જ હાજર હોય છે, જે custom hooks બનાવવા, database queries જનરેટ કરવા અથવા ગૂંચવણભરી conditional logic ને સાફ કરવા માટે તૈયાર હોય છે. નાના પાયે, તે ખૂબ જ ઝડપી junior developer ની જેમ કામ કરે છે. તેને syntax બરાબર આવડે છે. તેને એવા API surface areas યાદ રહે છે જેના માટે મારે Google કરવું પડે છે. તે boilerplate લખતા થાકતું નથી.
પરંતુ સોફ્ટવેર સતત બગડતું રહે છે. એપ્સ ધીમી લાગે છે. કસ્ટમર ડેશબોર્ડ્સ લેગ થાય છે. Edge cases ફોર્મ્સને ક્રેશ કરી દે છે. જો AI એ કોડિંગને આટલું સરળ બનાવી દીધું હોય, તો સોફ્ટવેરનો ઉપયોગ થોડા વર્ષો પહેલા કરતા હવે કેમ વધુ ખરાબ લાગે છે?
જવાબ એ છે કે syntax જનરેટ કરવું અને સોફ્ટવેર બનાવવું એ બંને એક જ કામ નથી.
Syntax એ Architecture નથી
AI tokens ને ખૂબ જ સારી રીતે હેન્ડલ કરે છે. તેને Supabase real-time channel ને સાંભળતું useEffect hook લખવા માટે કહો, અને તમને એવું કંઈક મળશે જે compile થઈ શકે. તે untyped JavaScript ફાઇલને strict TypeScript માં રૂપાંતરિત કરી શકે છે, અથવા તમે કોફી પીતા પહેલા Zod validation સાથેનું form component તૈયાર કરી શકે છે.
જે તે કરી શકતું નથી તે છે તમારા ચોક્કસ application ના આકાર (contours) ને સમજવો. સારા સોફ્ટવેર માટે વિચારપૂર્વકનું state management, race conditions નું સાવચેતીપૂર્વક સંચાલન અને ડેટા ક્યાં રહે છે અને ક્યાં માત્ર ડિસ્પ્લે થાય છે તેનો સ્પષ્ટ નકશો જરૂરી છે. AI માત્ર તાત્કાલિક ફાઇલ જુએ છે, આખી સિસ્ટમ નહીં. તે તમારા codebase ને લોડ-બેરિંગ દિવાલો ધરાવતા જીવંત માળખાને બદલે એક સપાટ ટેક્સ્ટ કોરિડોરની જેમ લે છે.
તેને એવા આર્કિટેક્ટ તરીકે વિચારો જે ક્યારેય ખરેખર ઘરમાં રહ્યા નથી. તેઓ સુંદર floor plans દોરી શકે છે. તેમને ખબર છે કે બેડરૂમમાં કેટલા બારીઓ હોવી જોઈએ. પરંતુ તેમને ખબર નથી હોતી કે ફેબ્રુઆરીમાં પાઈપો ક્યાં લીક થવાની શક્યતા છે, અથવા ઉનાળાની ગરમીમાં કયો હોલવે અસહ્ય બની જાય છે. તે અનુભવજન્ય જ્ઞાન જ ઇમારતને ટકી રહેવામાં મદદ કરે છે. કોડ પણ આ જ રીતે કામ કરે છે.
બે ઘર્ષણના બિંદુઓ (Friction Points)
જ્યારે હું AI ને કડક guardrails વગર કોડના મોટા ભાગ લખવા દઉં છું, ત્યારે હું વારંવાર એ જ બે સમસ્યાઓ ઉભી થતી જોઉં છું.
પ્રથમ, તે તમે પહેલેથી જ સ્થાપિત કરેલા design patterns ને અવગણે છે. કદાચ તમારી ટીમ બધી data fetching ને custom hooks ના સમર્પિત લેયર (dedicated layer) માં અલગ કરે છે. કદાચ તમારી પાસે Supabase RLS policies કેવી રીતે frontend helpers સાથે મેપ થાય છે તેના માટે કડક નિયમો છે. AI ને તેની પરવા નથી. જો તે તાત્કાલિક પ્રોમ્પ્ટનો ઉકેલ લાવે છે, તો તે બટનના onClick માં સીધું જ raw supabase.from().select() મૂકી દેશે. કોડ ચાલે છે. તે સ્વચ્છ પણ દેખાય છે. પરંતુ તે તમારા codebase માં એક 'outlier' છે, અને દરેક outlier એ ભવિષ્યમાં refactoring નો ટેક્સ છે. છ મહિના પછી, કોઈએ તે સોય શોધવી પડશે, તે શા માટે અસ્તિત્વમાં છે તે સમજવું પડશે, અને તેને ધીમેથી પાટા પર લાવવી પડશે.
બીજું, જ્યારે સાદગીથી કામ ચાલી શકે તેમ હોય ત્યારે તે જટિલતા તરફ વળે છે. આ સાધનને એવા રિપોઝીટરીઝ પર તાલીમ આપવામાં આવી છે જે એટલી મોટી છે કે તેમને abstract factories, જટિલ reducer patterns અને multi-layered higher-order components ની જરૂર પડે છે. જ્યારે તમે તેને એક સાદું contact form બનાવવા માટે કહો છો, ત્યારે તે તમને એક state machine, એક context provider અને ત્રણ ફાઇલોમાં ફેલાયેલું custom hook abstraction આપી શકે છે. આ ઉકેલ ટેકનિકલ રીતે ખોટો નથી. તે ફક્ત ભારે છે. દરેક બિનજરૂરી લેયર 'cognitive debt' વધારે છે. તમે કામ ટાળ્યું નથી; તમે તેને વ્યાજ સાથે મોકૂફ રાખ્યું છે.
વેલોસિટી ટ્રેપ (The Velocity Trap)
અહીં એક જોખમી feedback loop છે. AI તમને બમણી ઝડપે ફીચર્સ બનાવવાની મંજૂરી આપે છે, પરંતુ માનવ ધ્યાન તે જ રીતે વધતું નથી. જો તમે અડધા સમયમાં શિપ કરી રહ્યા છો, તો શું તમે કોડ રિવ્યુ પર બમણો સમય વિતાવી રહ્યા છો? શું તમે વધુ ટેસ્ટ લખી રહ્યા છો, કે ઓછા?
વ્યવહારમાં, જનરેટ કરેલા કોડ પર વિશ્વાસ કરવો અત્યંત સરળ છે કારણ કે તે અધિકૃત લાગે છે. તે આધુનિક syntax નો ઉપયોગ કરે છે. કોમેન્ટ્સ બરાબર જગ્યાએ મૂકવામાં આવે છે. વેરિયેબલના નામ પ્રોફેશનલ લાગે છે. તે ચમક (polish) માં સૂક્ષ્મ બગ્સ છુપાયેલા હોય છે. કોઈ hook માં dependency array જે setter ને છોડી દે છે. એક TypeScript type જે ટેકનિકલ રીતે સાચો છે પરંતુ તમે હેન્ડલ કરવાનું ભૂલી ગયા હો તેવા null state ને મંજૂરી આપે છે. એક Supabase query જે તમારા ચોક્કસ schema માં soft-deleted rows ને ધ્યાનમાં લેવાનું ભૂલી જાય છે. તમે દરેક લાઇન વાંચવાને બદલે ઉપરછલ્લી નજર નાખો છો, કારણ કે ડિલિવરીની ગતિ તેની માંગ કરે છે. સોમવારે ઝડપ સરસ લાગે છે. શુક્રવારે ડિબગિંગ સેશન મધ્યરાત્રિ સુધી ચાલે છે.
વાસ્તવિક કિંમત (The Real Cost)
આ માટે જે લોકો ચૂકવણી કરે છે તે ડેવલપર્સ નથી. તેઓ અંતિમ વપરાશકર્તાઓ (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