Claude Code இப்போது மூன்று loop-engineering கட்டளைகளை—/loop, /goal மற்றும் /schedule—அறிமுகப்படுத்துகிறது. இவை ஒரு கோடிங் ஏஜென்ட் (coding agent), மனிதன் ஒவ்வொரு முறையும் தட்டச்சு செய்யாமலேயே தனது சொந்த பிராம்ட் சுழற்சியை (prompt cycle) இயக்கும்படி அனுமதிக்கின்றன. இந்த அம்சம் டெவலப்பர்களுக்குத் திரும்பத் திரும்பச் செய்யும் கோடிங் வேலைகளைத் தானியக்கமாக்கவும், டோக்கன் செலவைக் (token spend) கட்டுக்குள் வைக்கவும், மற்றும் இதுவரை AI-உதவி பெற்ற மேம்பாட்டில் நிலவி வந்த “type-prompt-wait-type-prompt” என்ற சுழற்சியைத் தவிர்க்கவும் வழிவகை செய்கிறது.

புதிய கட்டளைகள் ஏன் முக்கியம்

பெரும்பாலான AI-coding பணிப்பாய்வுகள் (workflows) இன்னும் ஒரு கைமுறைத் தொடர்பையே (manual back-and-forth) நம்பியுள்ளன: ஒரு டெவலப்பர் ஒரு கோரிக்கையை எழுதுகிறார், மாடல் குறியீட்டைத் (code) திருப்பித் தருகிறது, டெவலப்பர் அதை வாசித்து, அடுத்து என்ன கேட்க வேண்டும் என்று முடிவு செய்து, மீண்டும் அதைச் செய்கிறார். ஒரு சிறிய பணி—ஒரு build-ஐ இயக்குவது, lint warning-ஐ சரிசெய்வது அல்லது ஒரு test failure-ஐச் சரிசெய்வது—பலமுறை செய்ய வேண்டியிருக்கும் போது, இந்த முறை மெதுவாகவும், செலவு மிகுந்ததாகவும் மற்றும் பிழைகளுக்கு இடமளிப்பதாகவும் அமைகிறது.

மூன்று லூப் முறைகள் (loop modes)

  • /loop – ஒரு லேசான (lightweight), சுய-வேகச் சுழற்சி. ஒரே Claude instance ஒவ்வொரு முறையும் இயங்கி, “is the build green?” போன்ற ஒரு எளிய நிபந்தனையைச் சரிபார்க்கும். சரிபார்ப்புப் படி (verification step) மிக எளிதாகவும், தவறான “done” சிக்னல் கிடைப்பதற்கான வாய்ப்பு குறைவாகவும் இருக்கும்போது இது சிறப்பாகச் செயல்படும்.
  • /goal – ஒரு உயர்-துல்லியச் சுழற்சி (high-precision cycle). ஒவ்வொரு முறையும் ஒரு இரண்டாம் நிலை மாடல் (secondary model) பணி முடிவடைந்ததற்கான நிபந்தனையை மதிப்பீடு செய்து, கூடுதல் துல்லியத்தை வழங்குகிறது. ஒரு பணி முன்கூட்டியே முடிவடைவது அதிக இழப்பை ஏற்படுத்தும் சூழலில் இதைப் பயன்படுத்தவும்—உதாரணமாக, பாதுகாப்பு சார்ந்த ஒரு சேவையை (security-critical service) வரிசைப்படுத்தும் போது (deploying).
  • /schedule – Anthropic-ன் உள்கட்டமைப்பில் (infrastructure) இயங்கும் ஒரு கிளவுட்-ஹோஸ்டட் (cloud-hosted) நடைமுறை. டெவலப்பரின் லேப்டாப் அணைக்கப்பட்டாலும் இந்த லூப் தொடர்ந்து இயங்கும்.

இவை மூன்றும் ஒரு பொதுவான கட்டமைப்பைப் பகிர்ந்து கொள்கின்றன: ஒரு skill (ஏஜென்ட் என்ன செய்ய வேண்டும் என்று சொல்லும் அறிவுறுத்தல்கள்), ஒரு verifier (வேலை உண்மையிலேயே முடிந்துவிட்டதா என்பதை நிரூபிக்கும் சரிபார்ப்பு), guardrails (ஏஜென்ட் எந்தக் கருவிகளைப் பயன்படுத்தலாம் என்பதற்கான வரம்புகள்) மற்றும் state (முந்தைய செயல்பாடுகளின் லேசான நினைவகம்). இவற்றில் ஏதேனும் ஒன்றைச் செய்தாலும், அந்த லூப் முடிவில்லாத ஒரு சுழற்சியாக மாறி டோக்கன் பயன்பாட்டை மட்டும் அதிகரிக்கும்.

பாதுகாப்பான மற்றும் செலவு-கட்டுப்பாட்டுடன் கூடிய லூப்பை உருவாக்குதல்

  1. Define the skill – ஏஜென்ட் செய்ய வேண்டிய துல்லியமான செயல்பாட்டைத் telling ஒரு தெளிவான, தீர்மானிக்கப்பட்ட (deterministic) பிராம்ட்டை எழுதவும் (உதாரணமாக, “run npm test and capture the output”).
  2. Add a verifier – ஏஜென்ட்டால் போலியாகச் செய்ய முடியாத ஒரு உறுதியான சோதனையுடன் skill-ஐ இணைக்கவும்; உதாரணமாக, உண்மையான test runner-ன் exit code-ஐப் பகுப்பாய்வு செய்வது அல்லது உருவாக்கப்பட்ட artifact-ன் checksum-ஐச் சரிபார்ப்பது.
  3. Set guardrails – ஏஜென்ட்டை ஒரு குறிப்பிட்ட கட்டளைகள் அல்லது APIs (whitelist) மூலம் கட்டுப்படுத்தவும். இது ஒரு பணிக்கு file I/O மட்டுமே தேவைப்படும்போது, தேவையற்ற முறையில் network socket-ஐத் திறப்பதைத் தடுக்கும்.
  4. Persist state – ஏஜென்ட் ஏற்கனவே செய்தவற்றைப் பதிவு செய்யும் ஒரு சிறிய JSON blob அல்லது தரவுத்தளப் பதிவைச் (database entry) சேமிக்கவும். அடுத்த சுழற்சியில் அந்த state-ஐப் படித்து, மீண்டும் அதே வேலையைச் செய்வதைத் தவிர்க்கலாம்.

ஒவ்வொரு லூப்பிற்கும் தேவையான மூன்று பாதுகாப்பு வரம்புகள் (safety caps)

  • Hard stop – அதிகபட்ச சுழற்சிகளின் எண்ணிக்கை அல்லது ஒரு குறிப்பிட்ட டோக்கன் வரம்பை (token budget) நிர்ணயிக்கவும். லூப் அந்த வரம்பை எட்டினால், அது நின்றுபோய் “max turns reached” என்று அறிக்கையிடும்.
  • Real stop condition – மாடலால் போலியாக உருவாக்க முடியாத ஒரு சரிபார்ப்பு அளவீட்டைப் (verification metric) பயன்படுத்தவும்; உதாரணமாக, வெற்றிகரமான test suite, காலியாக இல்லாத build artifact, அல்லது சரியான மதிப்பிற்குப் பொருந்தும் checksum.
  • Spend cap – டோக்கன் பயன்பாட்டைக் கண்காணிக்கும் ஒரு கண்காணிப்பு அடுக்கோடு (monitoring layer) லூப்பை இணைக்கவும். இது நிகழ்நேரத்தில் (real time) டோக்கன் நுகர்வைக் கண்காணித்து, நிர்ணயிக்கப்பட்ட வரம்பைத் தாண்டினால் செயல்பாட்டை நிறுத்திவிடும்.

சுருக்கம்

Claude Code-ன் /loop, /goal மற்றும் /schedule கட்டளைகள், டோக்கன் செலவை வெளிப்படையாக வைத்திருக்கும் அதே வேளையில், திரும்பத் திரும்பச் செய்யும் கோடிங் சுழற்சிகளைத் தானியக்கமாக்க டெவலப்பர்களுக்கு ஒரு நடைமுறை வழியை வழங்குகின்றன. நம்பகமான லூப்பிற்குத் தேவையான முக்கிய அம்சங்கள் முறையான verifier, கடுமையான guardrails மற்றும் இயங்கும் நேரம் மற்றும் செலவு ஆகியவற்றின் மீதான கடுமையான வரம்புகள் ஆகும். முதலில் அந்தப் பாதுகாப்பு நடவடிக்கைகளை உருவாக்கிவிட்டு, பிறகு ஏஜென்ட்டை சாதாரண வேலைகளைச் செய்ய விடுங்கள்—அதன் மூலம் மனித மூளை தேவைப்படும் சிக்கலான பிரச்சனைகளில் நீங்கள் உங்கள் நேரத்தைச் செலவிட முடியும்.