Claude Code ఇప్పుడు మూడు లూప్-ఇంజనీరింగ్ కమాండ్లను—/loop, /goal మరియు /schedule—అందించింది. ఇవి ఒక కోడింగ్ ఏజెంట్ ప్రతి దశలోనూ మనిషి టైప్ చేయాల్సిన అవసరం లేకుండా, తన స్వంత ప్రాంప్ట్ సైకిల్ను నడిపించుకోవడానికి అనుమతిస్తాయి. ఈ ఫీచర్ డెవలపర్లకు పునరావృతమయ్యే కోడింగ్ పనులను ఆటోమేట్ చేయడానికి, టోకెన్ ఖర్చును నియంత్రణలో ఉంచడానికి మరియు ఇప్పటివరకు AI-సహాయక అభివృద్ధిని నిర్వచించిన "టైప్-ప్రాంప్ట్-వెయిట్-టైప్-ప్రాంప్ట్" (type-prompt-wait-type-prompt) క్రమాన్ని నివారించడానికి ఒక మార్గాన్ని అందిస్తుంది.
ఈ కొత్త కమాండ్లు ఎందుకు ముఖ్యమైనవి
చాలా AI-కోడింగ్ వర్క్ఫ్లోలు ఇప్పటికీ మాన్యువల్ ఇంటరాక్షన్ (manual back-and-forth) పైనే ఆధారపడి ఉన్నాయి: డెవలపర్ ఒక రిక్వెస్ట్ రాస్తారు, మోడల్ కోడ్ను తిరిగి ఇస్తుంది, డెవలపర్ దానిని చదివి, తదుపరి ఏమి అడగాలో నిర్ణయించి, మళ్ళీ అదే ప్రక్రియను పునరావృతం చేస్తారు. ఒకే చిన్న పని—బిల్డ్ రన్ చేయడం, లింట్ వార్నింగ్ను సరిచేయడం, టెస్ట్ ఫెయిల్యూర్ పైన పని చేయడం—కోసం డజన్ల కొద్దీ దశలు అవసరమైనప్పుడు, ఈ పద్ధతి నెమ్మదిగా, ఖరీదైనదిగా మరియు తప్పులకు అవకాశం ఉన్నదిగా మారుతుంది.
మూడు లూప్ మోడ్లు
- /loop – ఇది తేలికైన, స్వయంగా నడిచే సైకిల్. ప్రతి దశలోనూ అదే Claude ఇన్స్టాన్స్ రన్ అవుతుంది మరియు “is the build green?” వంటి సాధారణ కండిషన్ను తనిఖీ చేస్తుంది. వెరిఫికేషన్ దశ చాలా సులభంగా ఉన్నప్పుడు మరియు తప్పుడు “done” సిగ్నల్ వచ్చే అవకాశం తక్కువగా ఉన్నప్పుడు ఇది బాగా పనిచేస్తుంది.
- /goal – ఇది అధిక ఖచ్చితత్వంతో కూడిన సైకిల్. ప్రతి దశలోనూ ఒక సెకండరీ మోడల్ పని పూర్తయిందో లేదో (completion condition) అంచనా వేస్తుంది, దీనివల్ల మరింత లోతైన పరిశీలన సాధ్యమవుతుంది. పని త్వరగా ముగిసిపోవడం వల్ల నష్టం కలిగే అవకాశం ఉన్నప్పుడు—ఉదాహరణకు, సెక్యూరిటీ-క్రిటికల్ సర్వీస్ను డిప్లాయ్ చేసేటప్పుడు—దీనిని ఉపయోగించండి.
- /schedule – ఇది Anthropic ఇన్ఫ్రాస్ట్రక్చర్పై నడిచే క్లౌడ్-హోస్టెడ్ రొటీన్. డెవలపర్ యొక్క లాప్టాప్ ఆపివేసినప్పటికీ లూప్ కొనసాగుతుంది.
ఈ మూడింటికీ ఒకే విధమైన ఆర్కిటెక్చర్ ఉంటుంది: ఒక skill (ఏజెంట్ ఏమి చేయాలో చెప్పే సూచనలు), ఒక verifier (పని నిజంగా పూర్తయిందని నిరూపించే తనిఖీ), guardrails (ఏజెంట్ ఏ టూల్స్ను ఉపయోగించవచ్చో తెలిపే పరిమితులు) మరియు state (మునుపటి చర్యల యొక్క తేలికపాటి మెమరీ). వీటిలో ఏ ఒక్క భాగాన్ని వదిలేసినా, లూప్ అనేది కేవలం టోకెన్ వినియోగాన్ని పెంచే ఒక అనంతమైన ప్రక్రియగా మారిపోతుంది.
సురక్షితమైన, ఖర్చు నియంత్రిత లూప్ను నిర్మించడం
- Define the skill – ఏజెంట్కు ఖచ్చితమైన ఆపరేషన్ను తెలియజేసే స్పష్టమైన, డిటర్మినిస్టిక్ (deterministic) ప్రాంప్ట్ను రాయండి (ఉదాహరణకు, “run
npm testand capture the output”). - Add a verifier – స్కిల్తో పాటు ఏజెంట్ నకిలీ చేయలేని ఒక నిర్దిష్ట పరీక్షను జోడించండి, ఉదాహరణకు టెస్ట్ రన్నర్ యొక్క ఎగ్జిట్ కోడ్ను (exit code) విశ్లేషించడం లేదా జనరేట్ చేయబడిన ఆర్టిఫాక్ట్ యొక్క చెక్సమ్ (checksum) ను తనిఖీ చేయడం.
- Set guardrails – ఏజెంట్ను కేవలం వైట్లిస్ట్ చేయబడిన కమాండ్లు లేదా APIలకు మాత్రమే పరిమితం చేయండి. దీనివల్ల పనికి కేవలం ఫైల్ I/O మాత్రమే అవసరమైనప్పుడు, అది నెట్వర్క్ సాకెట్ను ఓపెన్ చేయకుండా నిరోధించవచ్చు.
- Persist state – ఏజెంట్ ఇప్పటికే ఏమి చేసిందో రికార్డ్ చేసే చిన్న JSON blob లేదా డేటాబేస్ ఎంట్రీని నిల్వ చేయండి. తదుపరి దశలో ఆ స్టేట్ను చదవడం ద్వారా పాత పనులను మళ్ళీ చేయకుండా నివారించవచ్చు.
ప్రతి లూప్కు అవసరమైన మూడు సేఫ్టీ క్యాప్స్ (safety caps)
- Hard stop – గరిష్ట దశల సంఖ్యను లేదా టోకెన్ బడ్జెట్ను నిర్ణయించండి. లూప్ ఆ పరిమితికి చేరుకుంటే, అది ఆగిపోయి “max turns reached” అని రిపోర్ట్ చేస్తుంది.
- Real stop condition – మోడల్ సృష్టించలేని (fabricate చేయలేని) వెరిఫికేషన్ మెట్రిక్ను ఉపయోగించండి, ఉదాహరణకు పాస్ అయిన టెస్ట్ సూట్, ఖాళీగా లేని బిల్డ్ ఆర్టిఫాక్ట్ లేదా తెలిసిన సరైన విలువతో సరిపోలే చెక్సమ్.
- Spend cap – టోకెన్ వినియోగాన్ని రియల్ టైమ్లో పర్యవేక్షించే మానిటరింగ్ లేయర్తో లూప్ను అనుసంధానించండి. ముందుగా నిర్ణయించిన ఖర్చు పరిమితి దాటిన వెంటనే అది అమలును నిలిపివేస్తుంది.
Takeaway
Claude Code యొక్క /loop, /goal మరియు /schedule కమాండ్లు టోకెన్ ఖర్చును పారదర్శకంగా ఉంచుతూనే, పునరావృతమయ్యే కోడింగ్ సైకిల్లను ఆటోమేట్ చేయడానికి డెవలపర్లకు ఒక ఆచరణాత్మక మార్గాన్ని అందిస్తాయి. నమ్మదగిన లూప్కు బలమైన వెరిఫైయర్, కఠినమైన గార్డ్రైల్స్ మరియు రన్టైమ్ & ఖర్చుపై కఠినమైన పరిమితులు ఉండటం కీలకం. మొదట ఆ రక్షణ చర్యలను నిర్మించండి, ఆపై ఏజెంట్ను సాధారణ పనుల కోసం వదిలేయండి—తద్వారా మీరు మానవ మేధస్సు అవసరమయ్యే క్లిష్టమైన సమస్యలపై దృష్టి పెట్టవచ్చు.