Claude Code ಈಗ ಮೂರು loop-engineering ಕಮಾಂಡ್‌ಗಳನ್ನು—/loop, /goal ಮತ್ತು /schedule—ನೀಡುತ್ತಿದೆ—ಇವುಗಳು ಒಬ್ಬ ಕೋಡಿಂಗ್ ಏಜೆಂಟ್ ಮನುಷ್ಯ ಪ್ರತಿ ಹಂತವನ್ನು ಟೈಪ್ ಮಾಡದೆಯೇ ತನ್ನದೇ ಆದ ಪ್ರಾಂಪ್ಟ್ ಸೈಕಲ್ ಅನ್ನು ನಡೆಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ. ಈ ಫೀಚರ್ ಅಭಿವೃದ್ಧಿಪಡಿಸುವವರಿಗೆ ಪುನರಾವರ್ತಿತ ಕೋಡಿಂಗ್ ಕೆಲಸಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು, ಟೋಕನ್ ಬಳಕೆಯನ್ನು ನಿಯಂತ್ರಣದಲ್ಲಿಡಲು ಮತ್ತು ಇದುವರೆಗೆ AI-ಸಹಾಯದ ಅಭಿವೃದ್ಧಿಯಲ್ಲಿ ಕಂಡುಬರುತ್ತಿದ್ದ “type-prompt-wait-type-prompt” ಲಯವನ್ನು ತಪ್ಪಿಸಲು ಒಂದು ಮಾರ್ಗವನ್ನು ಭರವಸೆ ನೀಡುತ್ತದೆ.

ಈ ಹೊಸ ಕಮಾಂಡ್‌ಗಳು ಏಕೆ ಮುಖ್ಯ

ಹೆಚ್ಚಿನ AI-ಕೋಡಿಂಗ್ ವರ್ಕ್‌ಫ್ಲೋಗಳು ಇಂದಿಗೂ ಮ್ಯಾನುಯಲ್ ಸಂವಹನದ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ: ಒಬ್ಬ ಡೆವಲಪರ್ ವಿನಂತಿಯನ್ನು ಬರೆಯುತ್ತಾರೆ, ಮಾಡೆಲ್ ಕೋಡ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಡೆವಲಪರ್ ಅದನ್ನು ಓದುತ್ತಾರೆ, ಮುಂದೆ ಏನು ಕೇಳಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತಾರೆ ಮತ್ತು ಇದನ್ನು ಪುನರಾವರ್ತಿಸುತ್ತಾರೆ. ಒಂದೇ ಸಣ್ಣ ಕೆಲಸವನ್ನು ಮಾಡಲು—ಉದಾಹರಣೆಗೆ, ಬಿಲ್ಡ್ ಮಾಡುವುದು, ಲಿಂಟ್ ವಾರ್ನಿಂಗ್ ಸರಿಪಡಿಸುವುದು ಅಥವಾ ಟೆಸ್ಟ್ ಫೈಲ್ಯೂರ್ ಅನ್ನು ಸರಿಪಡಿಸುವುದು—ದಶಕಲೆಲಷ್ಟು ಹಂತಗಳು ಬೇಕಾದಾಗ, ಈ ಮಾದರಿಯು ನಿಧಾನವಾಗಿ, ದುಬಾರಿಯಾಗಿ ಮತ್ತು ತಪ್ಪುಗಳಿಗೆ ಒಳಗಾಗುವ ಸಾಧ್ಯತೆ ಇರುತ್ತದೆ.

ಮೂರು ಲೂಪ್ ಮೋಡ್‌ಗಳು

  • /loop – ಒಂದು ಲಘು (lightweight), ಸ್ವಯಂ-ವೇಗದ ಸೈಕಲ್. ಒಂದೇ Claude ಇನ್‌ಸ್ಟೆನ್ಸ್ ಪ್ರತಿ ಹಂತವನ್ನು ನಡೆಸುತ್ತದೆ ಮತ್ತು “is the build green?” ಎಂಬಂತಹ ಸರಳ ಕಂಡೀಶನ್ ಅನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಪರಿಶೀಲನಾ ಹಂತವು ಅತ್ಯಂತ ಸರಳವಾಗಿದ್ದಾಗ ಮತ್ತು ತಪ್ಪು “done” ಸಿಗ್ನಲ್ ಬರುವ ಅಪಾಯ ಕಡಿಮೆ ಇದ್ದಾಗ ಇದು ಅತ್ಯುತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
  • /goal – ಒಂದು ಹೆಚ್ಚಿನ ನಿಖರತೆಯ (high-precision) ಸೈಕಲ್. ಪ್ರತಿ ಹಂತದಲ್ಲಿ ಒಂದು ಸೆಕೆಂಡರಿ ಮಾಡೆಲ್ ಕೆಲಸದ ಪೂರ್ಣಗೊಂಡ ಸ್ಥಿತಿಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುತ್ತದೆ, ಇದು ಹೆಚ್ಚಿನ ನಿಗಾ ವಹಿಸುತ್ತದೆ. ಅಕಾಲಿಕ ಮುಕ್ತಾಯವು ದುಬಾರಿಯಾಗುವ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದನ್ನು ಬಳಸಿ—ಉದಾಹರಣೆಗೆ, ಸೆಕ್ಯೂರಿಟಿ-ಕ್ರಿಟಿಕಲ್ ಸೇವೆಯನ್ನು ನಿಯೋಜಿಸುವಾಗ (deploying).
  • /schedule – Anthropic ನ ಇನ್‌ಫ್ರಾಸ್ಟ್ರಕ್ಚರ್‌ನಲ್ಲಿರುವ ಕ್ಲೌಡ್-ಹೋಸ್ಟೆಡ್ ರೂಟೀನ್. ಡೆವಲಪರ್‌ನ ಲ್ಯಾಪ್‌ಟಾಪ್ ಆಫ್ ಆಗಿದ್ದರೂ ಲೂಪ್ ಮುಂದುವರಿಯುತ್ತದೆ.

ಈ ಮೂರೂ ಸಮಾನವಾದ ಆರ್ಕಿಟೆಕ್ಚರ್ ಅನ್ನು ಹೊಂದಿವೆ: ಒಂದು skill (ಏಜೆಂಟ್ ಏನು ಮಾಡಬೇಕೆಂದು ತಿಳಿಸುವ ಸೂಚನೆಗಳು), ಒಂದು verifier (ಕೆಲಸವು ನಿಜವಾಗಿಯೂ ಮುಗಿದಿದೆ ಎಂದು ಸಾಬೀತುಪಡಿಸುವ ಪರಿಶೀಲನೆ), guardrails (ಏಜೆಂಟ್ ಯಾವ ಟೂಲ್‌ಗಳನ್ನು ಬಳಸಬಹುದು ಎಂಬ ಮಿತಿಗಳು) ಮತ್ತು state (ಹಿಂದಿನ ಕ್ರಮಗಳ ಲಘು ನೆನಪು). ಇವುಗಳಲ್ಲಿ ಯಾವುದನ್ನಾದರೂ ಬಿಟ್ಟರೆ, ಲೂಪ್ ಎಂಬುದು ಕೇವಲ ಟೋಕನ್ ಬಳಕೆಯನ್ನು ಹೆಚ್ಚಿಸುವ ಅಂತ್ಯವಿಲ್ಲದ ಸ್ವಯಂ-ಸಮ್ಮತಿಯಾಗಿ ಬದಲಾಗುತ್ತದೆ.

ಸುರಕ್ಷಿತ ಮತ್ತು ವೆಚ್ಚ-ನಿಯಂತ್ರಿತ ಲೂಪ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು

  1. Define the skill – ಏಜೆಂಟ್‌ಗೆ ನಿಖರವಾದ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ತಿಳಿಸುವ ಸ್ಪಷ್ಟವಾದ, ಡಿಟರ್ಮಿನಿಸ್ಟಿಕ್ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಬರೆಯಿರಿ (ಉದಾಹರಣೆಗೆ, “run npm test and capture the output”).
  2. Add a verifier – skill ಅನ್ನು ಏಜೆಂಟ್ ನಕಲಿ ಮಾಡಲಾಗದ ಒಂದು ನಿರ್ದಿಷ್ಟ ಪರೀಕ್ಷೆಯೊಂದಿಗೆ ಜೋಡಿಸಿ, ಉದಾಹರಣೆಗೆ ಅಸಲಿ ಟೆಸ್ಟ್ ರನ್ನರ್‌ನ ಎಕ್ಸಿಟ್ ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು ಅಥವಾ ಜನರೇಟ್ ಮಾಡಿದ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್‌ನ ಚೆಕ್‌ಸಮ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವುದು.
  3. Set guardrails – ಏಜೆಂಟ್ ಅನ್ನು ಕಮಾಂಡ್‌ಗಳು ಅಥವಾ API ಗಳ ವೈಟ್‌ಲಿಸ್ಟ್‌ಗೆ ಸೀಮಿತಗೊಳಿಸಿ. ಇದು ಕೆಲಸಕ್ಕೆ ಕೇವಲ ಫೈಲ್ I/O ಅಗತ್ಯವಿದ್ದಾಗ ನೆಟ್‌ವರ್ಕ್ ಸಾಕೆಟ್ ಅನ್ನು ತೆರೆಯುವುದನ್ನು ತಡೆಯುತ್ತದೆ.
  4. Persist state – ಏಜೆಂಟ್ ಈಗಾಗಲೇ ಏನು ಮಾಡಿದೆ ಎಂಬುದನ್ನು ದಾಖಲಿಸುವ ಸಣ್ಣ JSON blob ಅಥವಾ ಡೇಟಾಬೇಸ್ ಎಂಟ್ರಿಯನ್ನು ಸಂಗ್ರಹಿಸಿ. ಮುಂದಿನ ಹಂತವು ಆ ಸ್ಟೇಟ್ ಅನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಕೆಲಸವನ್ನು ಪುನರಾವರ್ತಿಸುವುದನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.

ಪ್ರತಿಯೊಂದು ಲೂಪ್‌ಗೆ ಅಗತ್ಯವಿರುವ ಮೂರು ಸುರಕ್ಷತಾ ಮಿತಿಗಳು

  • Hard stop – ಗರಿಷ್ಠ ಸಂಖ್ಯೆಯ ಹಂತಗಳು ಅಥವಾ ಕಟ್ಟುನಿಟ್ಟಾದ ಟೋಕನ್ ಬಜೆಟ್ ಅನ್ನು ವಿಧಿಸಿ. ಲೂಪ್ ಮಿತಿಯನ್ನು ತಲುಪಿದರೆ, ಅದು ಸ್ಥಗಿತಗೊಂಡು “max turns reached” ಎಂದು ವರದಿ ಮಾಡುತ್ತದೆ.
  • Real stop condition – ಮಾಡೆಲ್ ಸೃಷ್ಟಿಸಲು ಸಾಧ್ಯವಾಗದ ಪರಿಶೀಲನಾ ಮೆಟ್ರಿಕ್ ಅನ್ನು ಬಳಸಿ, ಉದಾಹರಣೆಗೆ ಪಾಸಾದ ಟೆಸ್ಟ್ ಸೂಟ್, ಖಾಲಿ ಇಲ್ಲದ ಬಿಲ್ಡ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟ್ ಅಥವಾ ತಿಳಿದಿರುವ ಸರಿಯಾದ ಮೌಲ್ಯಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುವ ಚೆಕ್‌ಸಮ್.
  • Spend cap – ಟೋಕನ್ ಬಳಕೆಯನ್ನು ನೈಜ ಸಮಯದಲ್ಲಿ ಗಮನಿಸುವ ಮತ್ತು ಮೊದಲೇ ನಿರ್ಧರಿಸಿದ ವೆಚ್ಚದ ಮಿತಿ ಮೀರಿದ ತಕ್ಷಣ ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ನಿಲ್ಲಿಸುವ ಮಾನಿಟರಿಂಗ್ ಲೇಯರ್ ಅನ್ನು ಲೂಪ್‌ಗೆ ಜೋಡಿಸಿ.

ಸಾರಾಂಶ

Claude Code ನ /loop, /goal ಮತ್ತು /schedule ಕಮಾಂಡ್‌ಗಳು ಟೋಕನ್ ಬಳಕೆಯನ್ನು ಪಾರದರ್ಶಕವಾಗಿಡುತ್ತಲೇ ಪುನರಾವರ್ತಿತ ಕೋಡಿಂಗ್ ಸೈಕಲ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಒಂದು ಪ್ರಾಯೋಗಿಕ ಮಾರ್ಗವನ್ನು ನೀಡುತ್ತವೆ. ನಂಬಿಕಾರ್ಹ ಲೂಪ್‌ನ ಕೀಲಿ ಅಂಶವೆಂದರೆ ಗಟ್ಟಿಯಾದ verifier, ಕಟ್ಟುನಿಟ್ಟಾದ guardrails ಮತ್ತು ರನ್‌ಟೈಮ್ ಹಾಗೂ ವೆಚ್ಚದ ಮೇಲೆ ಕಟ್ಟುನಿಟ್ಟಾದ ಮಿತಿಗಳು. ಮೊದಲು ಆ ಸುರಕ್ಷತಾ ಕ್ರಮಗಳನ್ನು ನಿರ್ಮಿಸಿ, ನಂತರ ಏಜೆಂಟ್‌ಗೆ ಸಾಮಾನ್ಯ ಕೆಲಸಗಳನ್ನು ಮಾಡಲು ಬಿಡಿ—ಹೀಗೆ ನೀವು ಮನುಷ್ಯನ ಬುದ್ಧಿಶಕ್ತಿ ಅಗತ್ಯವಿರುವ ಸಮಸ್ಯೆಗಳ ಮೇಲೆ ಗಮನ ಹರಿಸಬಹುದು.