Claude Code ਹੁਣ ਤਿੰਨ ਲੂਪ-ਇੰਜੀਨੀਅਰਿੰਗ ਕਮਾਂਡਾਂ—/loop, /goal ਅਤੇ /schedule—ਪੇਸ਼ ਕਰ ਰਿਹਾ ਹੈ ਜੋ ਇੱਕ ਕੋਡਿੰਗ ਏਜੰਟ ਨੂੰ ਇਨਸਾਨ ਦੁਆਰਾ ਹਰ ਕਦਮ ਟਾਈਪ ਕੀਤੇ ਬਿਨਾਂ ਆਪਣੇ ਪ੍ਰੋਂਪਟ ਚੱਕਰ (prompt cycle) ਨੂੰ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ। ਇਹ ਫੀਚਰ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਵਾਰ-ਵਾਰ ਹੋਣ ਵਾਲੇ ਕੋਡਿੰਗ ਕੰਮਾਂ ਨੂੰ ਆਟੋਮੇਟ ਕਰਨ, ਟੋਕਨ ਖਰਚੇ ਨੂੰ ਕੰਟਰੋਲ ਵਿੱਚ ਰੱਖਣ ਅਤੇ ਉਸ "ਟਾਈਪ-ਪ੍ਰੋਂਪਟ-ਵੇਟ-ਟਾਈਪ-ਪ੍ਰੋਂਪਟ" ਰਿਦਮ ਤੋਂ ਬਚਣ ਦਾ ਤਰੀਕਾ ਦਿੰਦਾ ਹੈ ਜਿਸ ਨੇ ਹੁਣ ਤੱਕ AI-ਸਹਾਇਤਾ ਪ੍ਰਾਪਤ ਵਿਕਾਸ (development) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਹੈ।
ਨਵੀਆਂ ਕਮਾਂਡਾਂ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹਨ
ਜ਼ਿਆਦਾਤਰ AI-ਕੋਡਿੰਗ ਵਰਕਫਲੋ ਅਜੇ ਵੀ ਮੈਨੂਅਲ ਆਉਣ-ਜਾਣ (back-and-forth) 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ: ਇੱਕ ਡਿਵੈਲਪਰ ਇੱਕ ਬੇਨਤੀ ਲਿਖਦਾ ਹੈ, ਮਾਡਲ ਕੋਡ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਡਿਵੈਲਪਰ ਉਸਨੂੰ ਪੜ੍ਹਦਾ ਹੈ, ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਅੱਗੇ ਕੀ ਪੁੱਛਣਾ ਹੈ, ਅਤੇ ਇਸੇ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ। ਇਹ ਪੈਟਰਨ ਉਦੋਂ ਹੌਲੀ, ਮਹਿੰਗਾ ਅਤੇ ਗਲਤੀਆਂ ਵਾਲਾ ਹੋ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕੋ ਛੋਟਾ ਕੰਮ—ਜਿਵੇਂ ਕਿ ਬਿਲਡ ਚਲਾਉਣਾ, ਲਿੰਟ ਵਾਰਨਿੰਗ (lint warning) ਨੂੰ ਠੀਕ ਕਰਨਾ, ਜਾਂ ਟੈਸਟ ਫੇਲ ਹੋਣ 'ਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ—ਕਈ ਦਰਜਨ ਵਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਤਿੰਨ ਲੂਪ ਮੋਡ
- /loop – ਇੱਕ ਹਲਕਾ, ਆਪਣੇ ਆਪ ਚੱਲਣ ਵਾਲਾ ਚੱਕਰ। ਉਹੀ Claude ਇੰਸਟੈਂਸ ਹਰ ਵਾਰ ਚੱਲਦਾ ਹੈ ਅਤੇ ਇੱਕ ਸਧਾਰਨ ਸ਼ਰਤ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ "ਕੀ ਬਿਲਡ ਗ੍ਰੀਨ ਹੈ?" ਇਹ ਉਦੋਂ ਸਭ ਤੋਂ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ ਜਦੋਂ ਵੈਰੀਫਿਕੇਸ਼ਨ ਸਟੈਪ ਬਹੁਤ ਸੌਖਾ ਹੋਵੇ ਅਤੇ ਗਲਤ "done" ਸਿਗਨਲ ਦਾ ਜੋਖਮ ਘੱਟ ਹੋਵੇ।
- /goal – ਇੱਕ ਉੱਚ-ਸ਼ੁੱਧਤਾ ਵਾਲਾ ਚੱਕਰ। ਹਰ ਵਾਰ ਇੱਕ ਸੈਕੰਡਰੀ ਮਾਡਲ ਕੰਪਲੀਸ਼ਨ ਕੰਡੀਸ਼ਨ (completion condition) ਦਾ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ, ਜੋ ਜਾਂਚ ਦੀ ਇੱਕ ਵਾਧੂ ਪਰਤ ਜੋੜਦਾ ਹੈ। ਇਸਦੀ ਵਰਤੋਂ ਉਦੋਂ ਕਰੋ ਜਦੋਂ ਸਮੇਂ ਤੋਂ ਪਹਿਲਾਂ ਕੰਮ ਖਤਮ ਹੋਣਾ ਮਹਿੰਗਾ ਹੋ ਸਕਦਾ ਹੈ—ਜਿਵੇਂ ਕਿ ਕਿਸੇ ਸੁਰੱਖਿਆ-ਅਹਿਮ (security-critical) ਸਰਵਿਸ ਨੂੰ ਡਿਪਲੋਏ ਕਰਨਾ।
- /schedule – ਇੱਕ ਕਲਾਉਡ-ਹੋਸਟਡ ਰੁਟੀਨ ਜੋ Anthropic ਦੇ ਇਨਫਰਾਸਟ੍ਰਕਚਰ 'ਤੇ ਚੱਲਦੀ ਹੈ। ਜੇਕਰ ਡਿਵੈਲਪਰ ਦਾ ਲੈਪਟਾਪ ਬੰਦ ਵੀ ਹੋ ਜਾਵੇ, ਤਾਂ ਵੀ ਲੂਪ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ।
ਤਿੰਨੋਂ ਦੀ ਆਰਕੀਟੈਕਚਰ ਸਾਂਝੀ ਹੈ: ਇੱਕ skill (ਉਹ ਹਦਾਇਤਾਂ ਜੋ ਏਜੰਟ ਨੂੰ ਦੱਸਦੀਆਂ ਹਨ ਕਿ ਕੀ ਕਰਨਾ ਹੈ), ਇੱਕ verifier (ਉਹ ਚੈੱਕ ਜੋ ਸਾਬਤ ਕਰਦਾ ਹੈ ਕਿ ਕੰਮ ਸੱਚਮੁੱਚ ਖਤਮ ਹੋ ਗਿਆ ਹੈ), guardrails (ਉਹ ਸੀਮਾਵਾਂ ਕਿੰਨੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਏਜੰਟ ਕਰ ਸਕਦਾ ਹੈ) ਅਤੇ state (ਪਿਛਲੀਆਂ ਕਾਰਵਾਈਆਂ ਦੀ ਇੱਕ ਹਲਕੀ ਯਾਦਦਾਸ਼ਤ)। ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਵੀ ਹਿੱਸੇ ਨੂੰ ਛੱਡਣ ਨਾਲ ਲੂਪ ਇੱਕ ਅੰਤਹੀਣ ਸਵੈ-ਸਹਿਮਤੀ ਬਣ ਜਾਂਦਾ ਹੈ ਜੋ ਸਿਰਫ ਟੋਕਨ ਦੀ ਵਰਤੋਂ ਵਧਾਉਂਦਾ ਹੈ।
ਇੱਕ ਸੁਰੱਖਿਅਤ, ਲਾਗਤ-ਨਿਯੰਤਰਿਤ ਲੂਪ ਬਣਾਉਣਾ
- ਸਕਿੱਲ (skill) ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ – ਇੱਕ ਸਪਸ਼ਟ, ਨਿਰਧਾਰਤ ਪ੍ਰੋਂਪਟ ਲਿਖੋ ਜੋ ਏਜੰਟ ਨੂੰ ਸਹੀ ਕਾਰਵਾਈ ਦੱਸੇ (ਉਦਾਹਰਨ ਲਈ, "
npm testਚਲਾਓ ਅਤੇ ਆਉਟਪੁੱਟ ਕੈਪਚਰ ਕਰੋ")। - ਵੈਰੀਫਾਇਰ (verifier) ਜੋੜੋ – ਸਕਿੱਲ ਨੂੰ ਇੱਕ ਅਜਿਹੇ ਯਕੀਨੀ ਟੈਸਟ ਨਾਲ ਜੋੜੋ ਜਿਸ ਨੂੰ ਏਜੰਟ ਫਰਜ਼ਾਇਤ ਨਾ ਕਰ ਸਕੇ, ਜਿਵੇਂ ਕਿ ਅਸਲ ਟੈਸਟ ਰਨਰ ਦੇ ਐਗਜ਼ਿਟ ਕੋਡ (exit code) ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਜਾਂ ਬਣਾਈ ਗਈ ਆਰਟੀਫੈਕਟ (artifact) ਦੇ ਚੈਕਸਮ (checksum) ਦੀ ਜਾਂਚ ਕਰਨਾ।
- ਗਾਰਡਰੇਲਜ਼ (guardrails) ਸੈੱਟ ਕਰੋ – ਏਜੰਟ ਨੂੰ ਕਮਾਂਡਾਂ ਜਾਂ APIs ਦੀ ਇੱਕ ਵਾਈਟਲਿਸਟ ਤੱਕ ਸੀਮਤ ਰੱਖੋ। ਇਹ ਉਸਨੂੰ ਉਦੋਂ ਨੈੱਟਵਰਕ ਸਾਕਟ ਖੋਲ੍ਹਣ ਤੋਂ ਰੋਕਦਾ ਹੈ ਜਦੋਂ ਕੰਮ ਨੂੰ ਸਿਰਫ ਫਾਈਲ I/O ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
- ਸਟੇਟ (state) ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖੋ – ਇੱਕ ਛੋਟਾ JSON ਬਲੌਬ ਜਾਂ ਡੇਟਾਬੇਸ ਐਂਟਰੀ ਸਟੋਰ ਕਰੋ ਜੋ ਇਹ ਰਿਕਾਰਡ ਕਰੇ ਕਿ ਏਜੰਟ ਪਹਿਲਾਂ ਹੀ ਕੀ ਕਰ ਚੁੱਕਾ ਹੈ। ਅਗਲਾ ਚੱਕਰ ਉਸ ਸਟੇਟ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਕੰਮ ਨੂੰ ਦੁਹਰਾਉਣ ਤੋਂ ਬਚਦਾ ਹੈ।
ਹਰ ਲੂਪ ਲਈ ਲੋੜੀਂਦੇ ਤਿੰਨ ਸੁਰੱਖਿਆ ਕੈਪ (safety caps)
- ਹਾਰਡ ਸਟੌਪ (Hard stop) – ਵਾਰਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਜਾਂ ਇੱਕ ਸਖ਼ਤ ਟੋਕਨ ਬਜਟ ਲਗਾਓ। ਜੇਕਰ ਲੂਪ ਸੀਮਾ ਤੱਕ ਪਹੁੰਚ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਰੁਕ ਜਾਂਦਾ ਹੈ ਅਤੇ "max turns reached" ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ।
- ਅਸਲੀ ਸਟੌਪ ਕੰਡੀਸ਼ਨ (Real stop condition) – ਇੱਕ ਅਜਿਹੀ ਵੈਰੀਫਿਕੇਸ਼ਨ ਮੈਟ੍ਰਿਕ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਸ ਨੂੰ ਮਾਡਲ ਬਣਾ ਨਾ ਸਕੇ, ਜਿਵੇਂ ਕਿ ਇੱਕ ਪਾਸ ਹੋਇਆ ਟੈਸਟ ਸੂਟ, ਇੱਕ ਨਾਨ-ਐਮਪਟੀ ਬਿਲਡ ਆਰਟੀਫੈਕਟ, ਜਾਂ ਇੱਕ ਚੈਕਸਮ ਜੋ ਜਾਣੇ-ਪਛਾਣੇ ਸਹੀ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੋਵੇ।
- ਖਰਚੇ ਦੀ ਸੀਮਾ (Spend cap) – ਲੂਪ ਨੂੰ ਇੱਕ ਮਾਨੀਟਰਿੰਗ ਲੇਅਰ ਨਾਲ ਜੋੜੋ ਜੋ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਟੋਕਨ ਦੀ ਖਪਤ 'ਤੇ ਨਜ਼ਰ ਰੱਖਦੀ ਹੈ ਅਤੇ ਇੱਕ ਪਹਿਲਾਂ ਤੋਂ ਨਿਰਧਾਰਤ ਖਰਚੇ ਦੀ ਸੀਮਾ ਪਾਰ ਹੋਣ 'ਤੇ ਕਾਰਜਵਿਧੀਆਂ ਨੂੰ ਰੋਕ ਦਿੰਦੀ ਹੈ।
ਸਿੱਟਾ
Claude Code ਦੀਆਂ /loop, /goal ਅਤੇ /schedule ਕਮਾਂਡਾਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਟੋਕਨ ਖਰਚੇ ਨੂੰ ਪਾਰਦਰਸ਼ੀ ਰੱਖਦੇ ਹੋਏ ਵਾਰ-ਵਾਰ ਹੋਣ ਵਾਲੇ ਕੋਡਿੰਗ ਚੱਕਰਾਂ ਨੂੰ ਆਟੋਮੇਟ ਕਰਨ ਦਾ ਇੱਕ ਵਿਹਾਰਕ ਤਰੀਕਾ ਦਿੰਦੀਆਂ ਹਨ। ਇੱਕ ਭਰੋਸੇਯੋਗ ਲੂਪ ਦੀ ਕੁੰਜੀ ਇੱਕ ਮਜ਼ਬੂਤ ਵੈਰੀਫਾਇਰ, ਸਖ਼ਤ ਗਾਰਡਰੇਲਜ਼ ਅਤੇ ਰਨ-ਟਾਈਮ ਅਤੇ ਲਾਗਤ 'ਤੇ ਸਖ਼ਤ ਸੀਮਾਵਾਂ ਹਨ। ਪਹਿਲਾਂ ਉਹਨਾਂ ਸੁਰੱਖਿਆ ਉਪਾਵਾਂ ਨੂੰ ਬਣਾਓ, ਫਿਰ ਏਜੰਟ ਨੂੰ ਰੋਜ਼ਾਨਾ ਦੇ ਆਮ ਕੰਮ ਕਰਨ ਦਿਓ—ਤਾਂ ਜੋ ਤੁਸੀਂ ਆਪਣਾ ਸਮਾਂ ਉਹਨਾਂ ਸਮੱਸਿਆਵਾਂ 'ਤੇ ਲਗਾ ਸਕੋ ਜਿਨ੍ਹਾਂ ਲਈ ਅਜੇ ਵੀ ਮਨੁੱਖੀ ਦਿਮਾਗ ਦੀ ਲੋੜ ਹੈ।