Claude Code હવે ત્રણ લૂપ-એન્જિનિયરિંગ કમાન્ડ્સ—/loop, /goal અને /schedule—સાથે આવે છે—જે કોડિંગ એજન્ટને માનવીય હસ્તક્ષેપ વગર તેના પોતાના પ્રોમ્પ્ટ સાયકલને ચલાવવાની મંજૂરી આપે છે. આ ફીચર ડેવલપર્સને પુનરાવર્તિત કોડિંગ કામને ઓટોમેટ કરવા, ટોકન ખર્ચને નિયંત્રણમાં રાખવા અને અત્યાર સુધી AI-સહાયિત ડેવલપમેન્ટમાં જોવા મળતા “type-prompt-wait-type-prompt” ના લયથી બચવા માટેનો માર્ગ પૂરો પાડે છે.

આ નવા કમાન્ડ્સ શા માટે મહત્વના છે

મોટાભાગના AI-કોડિંગ વર્કફ્લો હજુ પણ મેન્યુઅલ આગળ-પાછળની પ્રક્રિયા પર આધારિત છે: ડેવલપર એક વિનંતી લખે છે, મોડેલ કોડ રિટર્ન કરે છે, ડેવલપર તેને વાંચે છે, આગળ શું પૂછવું તે નક્કી કરે છે, અને આ પ્રક્રિયાનું પુનરાવર્તન કરે છે. જ્યારે એક જ નાનું કાર્ય—જેમ કે બિલ્ડ ચલાવવું, લિન્ટ વોર્નિંગ સુધારવું, અથવા ટેસ્ટ ફેલ્યોર પર કામ કરવું—તેમાં ડઝનબંધ સ્ટેપ્સની જરૂર હોય, ત્યારે આ પદ્ધતિ ધીમી, ખર્ચાળ અને ભૂલ-ભરેલી બની જાય છે.

ત્રણ લૂપ મોડ્સ

  • /loop – એક હળવું (lightweight), સ્વ-ઝડપે ચાલતું સાયકલ. સમાન Claude ઇન્સ્ટન્સ દરેક ટર્ન ચલાવે છે અને “is the build green?” જેવી સરળ શરત તપાસે છે. જ્યારે વેરિફિકેશન સ્ટેપ સામાન્ય હોય અને ખોટા “done” સિગ્નલનું જોખમ ઓછું હોય ત્યારે તે શ્રેષ્ઠ રીતે કામ કરે છે.
  • /goal – એક ઉચ્ચ-ચોકસાઈવાળું (high-precision) સાયકલ. દરેક ટર્નમાં એક સેકન્ડરી મોડેલ કામ પૂર્ણ થયાની શરતનું મૂલ્યાંકન કરે છે, જે તપાસનું વધારાનું સ્તર ઉમેરે છે. જ્યારે અકાળે કામ પૂરું થવું મોંઘું પડી શકે—દા.ત., સિક્યુરિટી-ક્રિટિકલ સર્વિસ ડિપ્લોય કરતી વખતે—ત્યારે તેનો ઉપયોગ કરો.
  • /schedule – Anthropic ના ઇન્ફ્રાસ્ટ્રક્ચર પર ચાલતી ક્લાઉડ-હોસ્ટેડ રૂટિન. જો ડેવલપરનું લેપટોપ બંધ પણ હોય, તો પણ લૂપ ચાલુ રહે છે.

આ ત્રણેય સમાન આર્કિટેક્ચર ધરાવે છે: એક skill (એજન્ટને શું કરવું તે જણાવતી સૂચનાઓ), એક verifier (કામ ખરેખર પૂરું થયું છે તે સાબિત કરતી તપાસ), guardrails (એજન્ટ કયા સાધનોનો ઉપયોગ કરી શકે તેની મર્યાદાઓ) અને state (અગાઉની ક્રિયાઓની હળવી મેમરી). આમાંથી કોઈપણ ભાગને છોડી દેવાથી લૂપ એક અનંત સ્વ-સંમતિ બની જાય છે જે માત્ર ટોકનનો વપરાશ વધારે છે.

સુરક્ષિત અને ખર્ચ-નિયંત્રિત લૂપ બનાવવું

  1. Define the skill – એક સ્પષ્ટ, ડિટરમિનિસ્ટિક પ્રોમ્પ્ટ લખો જે એજન્ટને ચોક્કસ ઓપરેશન જણાવે (દા.ત., “run npm test and capture the output”).
  2. Add a verifier – skill ને એવી નક્કર ટેસ્ટ સાથે જોડો જેને એજન્ટ નકલી રીતે કરી ન શકે, જેમ કે એક્ચ્યુઅલ ટેસ્ટ રનરના એક્ઝિટ કોડનું પાર્સિંગ કરવું અથવા જનરેટ થયેલ આર્ટિફેક્ટના ચેકસમ (checksum) ની તપાસ કરવી.
  3. Set guardrails – એજન્ટને કમાન્ડ્સ અથવા APIs ની વ્હાઇટલિસ્ટ સુધી મર્યાદિત કરો. આ તેને નેટવર્ક સોકેટ ખોલતા અટકાવશે જ્યારે કાર્યને માત્ર ફાઇલ I/O ની જરૂર હોય.
  4. Persist state – એક નાનો JSON બ્લોબ અથવા ડેટાબેઝ એન્ટ્રી સ્ટોર કરો જે એજન્ટે શું કર્યું છે તેનો રેકોર્ડ રાખે છે. આગામી ટર્ન તે સ્ટેટ વાંચશે અને કામનું પુનરાવર્તન ટાળશે.

દરેક લૂપ માટે જરૂરી ત્રણ સેફ્ટી કેપ્સ

  • Hard stop – ટર્ન્સની મહત્તમ સંખ્યા અથવા ટોકન બજેટ નક્કી કરો. જો લૂપ મર્યાદા પર પહોંચે, તો તે અટકી જાય છે અને “max turns reached” રિપોર્ટ કરે છે.
  • Real stop condition – એવું વેરિફિકેશન મેટ્રિક વાપરો જેને મોડેલ બનાવી ન શકે, જેમ કે પાસ થયેલ ટેસ્ટ સૂટ, નોન-એમ્પ્ટી બિલ્ડ આર્ટિફેક્ટ, અથવા જાણીતી સાચી કિંમત સાથે મેચ થતું ચેકસમ.
  • Spend cap – લૂપને મોનિટરિંગ લેયર સાથે જોડો જે રીઅલ-ટાઇમમાં ટોકન વપરાશ પર નજર રાખે અને પૂર્વ-નિર્ધારિત ખર્ચની મર્યાદા ઓળંગાય ત્યારે એક્ઝિક્યુશન અટકાવી દે.

સારાંશ

Claude Code ના /loop, /goal અને /schedule કમાન્ડ્સ ડેવલપર્સને ટોકન ખર્ચ પારદર્શક રાખીને પુનરાવર્તિત કોડિંગ સાયકલને ઓટોમેટ કરવાનો વ્યવહારુ માર્ગ આપે છે. વિશ્વાસપાત્ર લૂપની ચાવી એ એક મજબૂત verifier, કડક guardrails અને રનટાઇમ તથા ખર્ચ પરની સખત મર્યાદાઓ છે. પહેલા આ સુરક્ષાના ઉપાયો બનાવો, પછી એજન્ટને સામાન્ય કામ કરવા દો—જેથી તમે તમારો સમય એવા પ્રશ્નો પર વિતાવી શકો જેમાં હજુ પણ માનવીય બુદ્ધિની જરૂર છે.