Claude Code Routines: ਸ਼ਡਿਊਲ ਕੀਤੇ ਕਲਾਊਡ ਏਜੰਟ, ਸਬ-ਰੂਟੀਨ ਅਤੇ ਕੋ-ਰੂਟੀਨ

ਇਹ ਵਿਸਤ੍ਰਿਤ ਗਾਈਡ ਹੈ। ਪੰਜ ਮਿੰਟਾਂ ਦੀ ਸੰਖੇਪ ਜਾਣ-ਪਛਾਣ ਲਈ ਸਾਥੀ ਬਲੌਗ ਪੋਸਟ ਪੜ੍ਹੋ।

1. ਸ਼ਡਿਊਲ ਕੀਤੇ ਏਜੰਟ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦੇ ਹਨ

ਕੁਝ ਸਮਾਂ ਪਹਿਲਾਂ ਤੱਕ, ਕੋਈ AI ਕੋਡਿੰਗ ਏਜੰਟ ਤਾਂ ਹੀ ਕੰਮ ਕਰਦਾ ਸੀ ਜਦੋਂ ਕੋਈ ਉਸ 'ਤੇ ਨਜ਼ਰ ਰੱਖ ਰਿਹਾ ਹੋਵੇ। ਤੁਸੀਂ ਟਰਮੀਨਲ ਖੋਲ੍ਹਦੇ, ਉਸ ਨੂੰ ਟਾਸਕ ਦਿੰਦੇ, ਉਸ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਨੂੰ ਮਨਜ਼ੂਰੀ ਦਿੰਦੇ ਅਤੇ ਨਤੀਜਾ ਪੜ੍ਹਦੇ। ਸੈਸ਼ਨ ਬੰਦ ਕਰਦੇ ਹੀ ਕੰਮ ਰੁਕ ਜਾਂਦਾ ਸੀ। ਇਹ ਮਾਡਲ ਖੋਜੀ ਕੰਮ ਲਈ ਠੀਕ ਹੈ, ਪਰ ਇੰਜੀਨੀਅਰਿੰਗ ਦਾ ਬਹੁਤਾ ਕੰਮ ਨਾ ਤਾਂ ਖੋਜੀ ਹੁੰਦਾ ਹੈ ਅਤੇ ਨਾ ਹੀ ਜ਼ਰੂਰੀ। ਉਹ ਵਾਰ-ਵਾਰ ਦੁਹਰਾਇਆ ਜਾਣ ਵਾਲਾ ਹੁੰਦਾ ਹੈ: ਰਾਤ ਭਰ ਵਿੱਚ ਆਏ ਇਸ਼ੂਆਂ ਦੀ ਛਾਂਟੀ, ਇਹ ਜਾਂਚਣਾ ਕਿ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਹਾਲੇ ਵੀ API ਨਾਲ ਮੇਲ ਖਾਂਦੀ ਹੈ, ਹਰ ਪੁੱਲ ਰਿਕਵੈਸਟ ਨੂੰ ਇੱਕੋ ਚੈੱਕਲਿਸਟ 'ਤੇ ਪਰਖਣਾ, ਰਿਲੀਜ਼ ਵਿੰਡੋ ਬੰਦ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਡਿਪਲੌਇਮੈਂਟ ਦੀ ਪੁਸ਼ਟੀ।

ਜੋ ਟੀਮਾਂ ਚਾਹੁੰਦੀਆਂ ਸਨ ਕਿ ਕੋਈ ਏਜੰਟ ਇਹ ਕੰਮ ਬਿਨਾਂ ਨਿਗਰਾਨੀ ਦੇ ਕਰੇ, ਉਨ੍ਹਾਂ ਨੂੰ ਸਾਰਾ ਢਾਂਚਾ ਖੁਦ ਬਣਾਉਣਾ ਪੈਂਦਾ ਸੀ। ਆਮ ਵਿਕਲਪ ਸਨ GitHub Actions ਵਿੱਚ ਇੱਕ cron ਜੌਬ, ਕਿਸੇ ਅਲਮਾਰੀ ਵਿੱਚ ਚਾਲੂ ਛੱਡੀ ਇੱਕ ਵਾਧੂ ਮਸ਼ੀਨ, ਜਾਂ Trigger.dev ਜਾਂ n8n ਵਰਗਾ ਕੋਈ ਵਰਕਫ਼ਲੋ ਇੰਜਣ ਜਿਸ ਵਿੱਚ ਉੱਪਰੋਂ ਏਜੰਟ ਕਾਲ ਜੋੜ ਦਿੱਤੀ ਗਈ ਹੋਵੇ। ਹਰ ਤਰੀਕਾ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਹਰ ਇੱਕ ਉਸ ਚੀਜ਼ ਦੇ ਦੁਆਲੇ ਇਨਫ੍ਰਾਸਟ੍ਰਕਚਰ, ਕ੍ਰੈਡੈਂਸ਼ੀਅਲ, ਲਾਗਤ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਜੋੜ ਦਿੰਦਾ ਹੈ ਜੋ ਅਸਲ ਵਿੱਚ ਬੱਸ ਇੱਕ ਹਦਾਇਤ ਹੈ: "ਇਹ ਹਰ ਰਾਤ ਕਰੋ ਅਤੇ ਦੱਸੋ ਕਿ ਕੀ ਮਿਲਿਆ।"

Routines ਇਹ ਸਾਰਾ ਢਾਂਚਾ ਹਟਾ ਦਿੰਦੇ ਹਨ। ਸ਼ਡਿਊਲ, ਕੰਪਿਊਟ, ਰਿਪੋਜ਼ਿਟਰੀ ਚੈੱਕਆਉਟ ਅਤੇ ਆਡਿਟ ਟ੍ਰੇਲ — ਸਭ ਕੁਝ Claude Code ਦੇ ਅੰਦਰ ਹੀ ਰਹਿੰਦਾ ਹੈ।

2. ਰੂਟੀਨ ਕੀ ਹੈ

Anthropic ਰੂਟੀਨ ਨੂੰ ਇੱਕ ਸੇਵ ਕੀਤੇ Claude Code ਕੌਂਫਿਗਰੇਸ਼ਨ ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਦੇ ਪੰਜ ਹਿੱਸੇ ਹੁੰਦੇ ਹਨ:

• ਪ੍ਰੌਂਪਟ। ਉਹ ਹਦਾਇਤ ਜਿਸ ਨੂੰ Claude ਹਰ ਰਨ 'ਤੇ ਪੂਰਾ ਕਰਦਾ ਹੈ। ਕਿਉਂਕਿ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇਣ ਲਈ ਕੋਈ ਮੌਜੂਦ ਨਹੀਂ ਹੁੰਦਾ, ਇਸ ਲਈ ਇਹ ਸਵੈ-ਨਿਰਭਰ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਸਪਸ਼ਟ ਦੱਸਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ "ਮੁਕੰਮਲ" ਹੋਣਾ ਕਿਹੋ ਜਿਹਾ ਦਿਸਦਾ ਹੈ। ਮਾਡਲ ਵੀ ਤੁਸੀਂ ਇੱਥੇ ਹੀ ਚੁਣਦੇ ਹੋ, ਅਤੇ ਉਹੀ ਮਾਡਲ ਹਰ ਰਨ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।
• ਰਿਪੋਜ਼ਿਟਰੀਆਂ। ਇੱਕ ਜਾਂ ਵੱਧ GitHub ਰਿਪੋਜ਼ਿਟਰੀਆਂ। ਹਰ ਰਨ ਦੀ ਸ਼ੁਰੂਆਤ ਵਿੱਚ ਹਰ ਰਿਪੋਜ਼ਿਟਰੀ ਨਵੇਂ ਸਿਰਿਓਂ ਕਲੋਨ ਹੁੰਦੀ ਹੈ, ਉਸ ਦੀ ਡਿਫ਼ੌਲਟ ਬ੍ਰਾਂਚ ਤੋਂ, ਜਦੋਂ ਤੱਕ ਪ੍ਰੌਂਪਟ ਕੁਝ ਹੋਰ ਨਾ ਕਹੇ।
• ਕਲਾਊਡ ਐਨਵਾਇਰਨਮੈਂਟ। ਇਹ ਨੈੱਟਵਰਕ ਐਕਸੈੱਸ, ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲਾਂ ਅਤੇ ਡਿਪੈਂਡੈਂਸੀਆਂ ਇੰਸਟਾਲ ਕਰਨ ਵਾਲੀ ਇੱਕ ਵਿਕਲਪਿਕ ਸੈੱਟਅੱਪ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕੰਟਰੋਲ ਕਰਦਾ ਹੈ। ਸੈੱਟਅੱਪ ਦਾ ਨਤੀਜਾ ਕੈਸ਼ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਉਹ ਹਰ ਵਾਰ ਦੁਬਾਰਾ ਨਹੀਂ ਚੱਲਦਾ।
• ਕਨੈਕਟਰ। ਤੁਹਾਡੇ claude.ai ਖਾਤੇ 'ਤੇ ਮੌਜੂਦ MCP ਇੰਟੀਗ੍ਰੇਸ਼ਨ, ਜਿਵੇਂ Slack, Linear ਜਾਂ Google Drive, ਜਿਨ੍ਹਾਂ ਤੋਂ ਰੂਟੀਨ ਪੜ੍ਹ ਅਤੇ ਲਿਖ ਸਕਦਾ ਹੈ।
• ਟ੍ਰਿਗਰ। ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਜਾਂ ਵੱਧ: ਸ਼ਡਿਊਲ, API ਅਤੇ GitHub ਇਵੈਂਟ। ਇੱਕੋ ਰੂਟੀਨ ਤਿੰਨਾਂ ਨੂੰ ਜੋੜ ਸਕਦਾ ਹੈ।

ਹਰ ਰਨ ਇੱਕ ਪੂਰਾ Claude Code ਕਲਾਊਡ ਸੈਸ਼ਨ ਹੁੰਦਾ ਹੈ। ਇਹ ਸ਼ੈੱਲ ਕਮਾਂਡਾਂ ਚਲਾ ਸਕਦਾ ਹੈ, ਕਲੋਨ ਕੀਤੀ ਰਿਪੋਜ਼ਿਟਰੀ ਵਿੱਚ ਕਮਿਟ ਕੀਤੀਆਂ ਸਕਿੱਲਾਂ ਵਰਤ ਸਕਦਾ ਹੈ ਅਤੇ ਸ਼ਾਮਲ ਕੀਤੇ ਕਨੈਕਟਰਾਂ ਦੇ ਹਰ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ। ਕੋਈ ਪਰਮਿਸ਼ਨ-ਮੋਡ ਚੋਣਕਾਰ ਨਹੀਂ ਹੈ ਅਤੇ ਕੁਝ ਵੀ ਮਨਜ਼ੂਰੀ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ। ਇਹੀ ਖੁਦਮੁਖਤਿਆਰੀ ਇਸ ਦਾ ਮਕਸਦ ਹੈ, ਅਤੇ ਇਸੇ ਕਰਕੇ ਦਾਇਰਾ ਤੈਅ ਕਰਨਾ ਅਹਿਮ ਹੈ (ਵੇਖੋ ਭਾਗ 8)।

3. ਤਿੰਨ ਕਿਸਮਾਂ ਦੇ ਟ੍ਰਿਗਰ

3.1 ਸ਼ਡਿਊਲ

ਸਭ ਤੋਂ ਸਰਲ ਟ੍ਰਿਗਰ ਰੂਟੀਨ ਨੂੰ ਇੱਕ ਪਹਿਲਾਂ ਤੋਂ ਤੈਅ ਅੰਤਰਾਲ 'ਤੇ (ਹਰ ਘੰਟੇ, ਰੋਜ਼ਾਨਾ, ਕੰਮਕਾਜੀ ਦਿਨਾਂ 'ਤੇ ਜਾਂ ਹਫ਼ਤਾਵਾਰੀ) ਜਾਂ ਭਵਿੱਖ ਦੇ ਕਿਸੇ ਇੱਕ ਤੈਅ ਸਮੇਂ 'ਤੇ ਚਲਾਉਂਦਾ ਹੈ। ਕੁਝ ਗੱਲਾਂ ਜਾਣਨ ਯੋਗ ਹਨ:

• ਸਥਾਨਕ ਸਮਾਂ। ਤੁਸੀਂ ਸਮਾਂ ਆਪਣੇ ਟਾਈਮ ਜ਼ੋਨ ਵਿੱਚ ਦਰਜ ਕਰਦੇ ਹੋ ਅਤੇ Claude Code ਉਸ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਇਸ ਲਈ 09:00 ਵਾਲਾ ਰਨ ਤੁਹਾਡੀ ਕੰਧ-ਘੜੀ ਦੇ 09:00 'ਤੇ ਹੀ ਚੱਲਦਾ ਹੈ, ਕਲਾਊਡ ਹਾਰਡਵੇਅਰ ਭਾਵੇਂ ਕਿਤੇ ਵੀ ਹੋਵੇ। ਸ਼ੁਰੂਆਤੀ ਕੁਝ ਥਰਡ-ਪਾਰਟੀ ਗਾਈਡਾਂ ਵਿੱਚ ਕਿਹਾ ਗਿਆ ਸੀ ਕਿ ਸ਼ਡਿਊਲ ਸਿਰਫ਼ UTC ਵਿੱਚ ਹੁੰਦੇ ਹਨ। Anthropic ਦੀ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਇਸ ਤੋਂ ਵੱਖਰੀ ਗੱਲ ਕਹਿੰਦੀ ਹੈ।
• ਠੀਕ ਘੰਟੇ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਬਚੋ। ਠੀਕ ਘੰਟੇ 'ਤੇ ਸ਼ਡਿਊਲ ਕੀਤੇ ਰਨ ਕਈ ਮਿੰਟ ਦੇਰੀ ਨਾਲ ਸ਼ੁਰੂ ਹੋ ਸਕਦੇ ਹਨ। 09:00 ਦੀ ਬਜਾਏ 09:07 ਚੁਣਨ ਨਾਲ ਸਮਾਂ ਵਧੇਰੇ ਅਨੁਮਾਨਯੋਗ ਰਹਿੰਦਾ ਹੈ।
• ਕਸਟਮ cron। ਜਿਨ੍ਹਾਂ ਅੰਤਰਾਲਾਂ ਨੂੰ ਪ੍ਰੀਸੈੱਟ ਕਵਰ ਨਹੀਂ ਕਰਦੇ, ਜਿਵੇਂ ਹਰ ਦੋ ਘੰਟੇ ਜਾਂ ਮਹੀਨੇ ਦੀ ਪਹਿਲੀ ਤਾਰੀਖ਼, ਉਨ੍ਹਾਂ ਲਈ ਸਭ ਤੋਂ ਨੇੜਲਾ ਪ੍ਰੀਸੈੱਟ ਚੁਣੋ ਅਤੇ ਫਿਰ CLI ਵਿੱਚ /schedule update ਚਲਾ ਕੇ cron ਐਕਸਪ੍ਰੈਸ਼ਨ ਸੈੱਟ ਕਰੋ। ਘੱਟੋ-ਘੱਟ ਅੰਤਰਾਲ ਇੱਕ ਘੰਟਾ ਹੈ; ਇਸ ਤੋਂ ਵੱਧ ਵਾਰ ਚੱਲਣ ਵਾਲੀ ਕੋਈ ਵੀ ਸੈਟਿੰਗ ਰੱਦ ਕਰ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।
• ਇੱਕ-ਵਾਰੀ ਰਨ। ਸਮੇਂ ਨੂੰ ਆਮ ਭਾਸ਼ਾ ਵਿੱਚ ਦੱਸੋ, ਮਿਸਾਲ ਵਜੋਂ /schedule in 2 weeks, open a cleanup PR that removes the feature flag। ਸੇਵ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ Claude ਸਹੀ ਟਾਈਮਸਟੈਂਪ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ। ਚੱਲਣ ਤੋਂ ਬਾਅਦ ਰੂਟੀਨ ਆਪਣੇ-ਆਪ ਨੂੰ ਬੰਦ ਕਰ ਲੈਂਦਾ ਹੈ ਅਤੇ ਉਸ 'ਤੇ Ran ਦਾ ਨਿਸ਼ਾਨ ਲੱਗ ਜਾਂਦਾ ਹੈ। ਇੱਕ-ਵਾਰੀ ਰਨ ਰੋਜ਼ਾਨਾ ਰਨ ਸੀਮਾ ਵਿੱਚ ਨਹੀਂ ਗਿਣੇ ਜਾਂਦੇ।

3.2 API

API ਟ੍ਰਿਗਰ ਰੂਟੀਨ ਨੂੰ ਉਸ ਦਾ ਆਪਣਾ HTTPS ਐਂਡਪੌਇੰਟ ਦਿੰਦਾ ਹੈ। ਕੋਈ ਵੀ ਸਿਸਟਮ ਜੋ ਪ੍ਰਮਾਣਿਤ POST ਰਿਕਵੈਸਟ ਭੇਜ ਸਕਦਾ ਹੈ, ਇੱਕ ਰਨ ਸ਼ੁਰੂ ਕਰ ਸਕਦਾ ਹੈ: ਕੋਈ ਅਲਰਟਿੰਗ ਟੂਲ, ਡਿਪਲੌਇਮੈਂਟ ਪਾਈਪਲਾਈਨ ਜਾਂ ਅੰਦਰੂਨੀ ਐਡਮਿਨ ਪੇਜ। ਟੋਕਨ ਵੈੱਬ UI ਵਿੱਚ ਬਣਦਾ ਹੈ, ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ, ਸਿਰਫ਼ ਉਸੇ ਰੂਟੀਨ ਤੱਕ ਸੀਮਿਤ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਕਦੇ ਵੀ ਦੁਬਾਰਾ ਬਣਾਇਆ ਜਾਂ ਰੱਦ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

curl -X POST https://api.anthropic.com/v1/claude_code/routines/<ROUTINE_TRIGGER_ID>/fire \
  -H "Authorization: Bearer <ROUTINE_TOKEN>" \
  -H "anthropic-beta: experimental-cc-routine-2026-04-01" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{"text": "Error rate on checkout-api above 5% for 10 minutes."}'

ਰਿਸਪੌਂਸ ਵਿੱਚ ਇੱਕ ਸੈਸ਼ਨ ID ਅਤੇ ਸੈਸ਼ਨ URL ਹੁੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਖੋਲ੍ਹ ਕੇ ਤੁਸੀਂ ਰਨ ਨੂੰ ਲਾਈਵ ਵੇਖ ਸਕਦੇ ਹੋ। ਵਿਕਲਪਿਕ text ਫ਼ੀਲਡ ਰਨ-ਵਿਸ਼ੇਸ਼ ਸੰਦਰਭ ਲੈ ਕੇ ਜਾਂਦਾ ਹੈ। ਸੁਰੱਖਿਆ ਪ੍ਰਤੀ ਸੁਚੇਤ ਟੀਮਾਂ ਨੂੰ ਧਿਆਨ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ Claude Code ਇਸ ਟੈਕਸਟ ਨੂੰ ਇੱਕ <routine-fire-payload> ਬਲਾਕ ਵਿੱਚ ਲਪੇਟਦਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਅਵਿਸ਼ਵਾਸਯੋਗ ਡਾਟਾ ਵਜੋਂ ਲੇਬਲ ਕਰਦਾ ਹੈ। Claude ਇਸ ਦੇ ਅੰਦਰਲੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਤਦ ਤੱਕ ਨਹੀਂ ਕਰੇਗਾ ਜਦ ਤੱਕ ਰੂਟੀਨ ਦਾ ਆਪਣਾ ਸੇਵ ਕੀਤਾ ਪ੍ਰੌਂਪਟ ਉਸ ਨੂੰ ਪੇਲੋਡ ਵਰਤਣ ਲਈ ਨਾ ਕਹੇ। ਜੇ ਤੁਹਾਡਾ ਰੂਟੀਨ ਕਿਸੇ ਅਲਰਟ ਦੇ ਵੇਰਵੇ 'ਤੇ ਕਾਰਵਾਈ ਲਈ ਬਣਿਆ ਹੈ, ਤਾਂ ਪ੍ਰੌਂਪਟ ਵਿੱਚ ਇਹ ਸਪਸ਼ਟ ਲਿਖਿਆ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਮਿਸਾਲ ਵਜੋਂ: "Investigate the alert described in the routine-fire-payload block." ਇਸ ਡਿਜ਼ਾਈਨ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਲੀਕ ਹੋਏ ਟੋਕਨ ਨਾਲ ਕੋਈ ਰਨ ਤਾਂ ਸ਼ੁਰੂ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਰੂਟੀਨ ਦੀਆਂ ਹਦਾਇਤਾਂ ਦੁਬਾਰਾ ਨਹੀਂ ਲਿਖ ਸਕਦਾ।

ਐਂਡਪੌਇੰਟ ਇੱਕ ਤਾਰੀਖ਼-ਯੁਕਤ ਬੀਟਾ ਹੈਡਰ ਦੇ ਪਿੱਛੇ ਹੈ। Anthropic ਮੁਤਾਬਕ ਬ੍ਰੇਕਿੰਗ ਬਦਲਾਅ ਨਵੇਂ ਹੈਡਰ ਸੰਸਕਰਣਾਂ ਹੇਠ ਆਉਣਗੇ, ਅਤੇ ਪਿਛਲੇ ਦੋ ਸੰਸਕਰਣ ਕੰਮ ਕਰਦੇ ਰਹਿਣਗੇ ਤਾਂ ਜੋ ਕਾਲ ਕਰਨ ਵਾਲਿਆਂ ਨੂੰ ਮਾਈਗ੍ਰੇਟ ਕਰਨ ਦਾ ਸਮਾਂ ਮਿਲ ਸਕੇ।

3.3 GitHub ਇਵੈਂਟ

GitHub ਟ੍ਰਿਗਰ ਕਿਸੇ ਕਨੈਕਟ ਕੀਤੀ ਰਿਪੋਜ਼ਿਟਰੀ 'ਤੇ ਮੇਲ ਖਾਂਦਾ ਇਵੈਂਟ ਹੋਣ 'ਤੇ ਹਰ ਵਾਰ ਇੱਕ ਨਵਾਂ ਸੈਸ਼ਨ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ। ਇਸ ਲਈ ਉਸ ਰਿਪੋਜ਼ਿਟਰੀ 'ਤੇ Claude GitHub App ਇੰਸਟਾਲ ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ। ਦੋ ਇਵੈਂਟ ਸ਼੍ਰੇਣੀਆਂ ਸਮਰਥਿਤ ਹਨ:

• ਪੁੱਲ ਰਿਕਵੈਸਟ: ਖੋਲ੍ਹੀ ਗਈ, ਬੰਦ ਕੀਤੀ ਗਈ, ਅਸਾਈਨ ਕੀਤੀ ਗਈ, ਲੇਬਲ ਲਾਇਆ ਗਿਆ, ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕੀਤੀ ਗਈ ਅਤੇ ਹੋਰ ਅੱਪਡੇਟ।
• ਰਿਲੀਜ਼: ਬਣਾਈ ਗਈ, ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੀ ਗਈ, ਸੋਧੀ ਗਈ ਜਾਂ ਮਿਟਾਈ ਗਈ।

ਫ਼ਿਲਟਰ ਤੈਅ ਕਰਦੇ ਹਨ ਕਿ ਕਿਹੜੇ ਇਵੈਂਟ ਗਿਣੇ ਜਾਣ। ਤੁਸੀਂ ਲੇਖਕ, ਸਿਰਲੇਖ, ਬਾਡੀ, ਬੇਸ ਬ੍ਰਾਂਚ, ਹੈੱਡ ਬ੍ਰਾਂਚ, ਲੇਬਲਾਂ, ਡਰਾਫ਼ਟ ਸਥਿਤੀ ਅਤੇ ਮਰਜ ਸਥਿਤੀ 'ਤੇ ਫ਼ਿਲਟਰ ਕਰ ਸਕਦੇ ਹੋ, ਇਨ੍ਹਾਂ ਓਪਰੇਟਰਾਂ ਨਾਲ: equals, contains, starts with, is one of, is not one of ਅਤੇ matches regex। ਸਾਰੀਆਂ ਸ਼ਰਤਾਂ ਪੂਰੀਆਂ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਇੱਕ ਆਮ ਭੁੱਲ: matches regex ਪੂਰੇ ਫ਼ੀਲਡ ਨੂੰ ਜਾਂਚਦਾ ਹੈ, ਇਸ ਲਈ "hotfix" ਵਾਲੇ ਕਿਸੇ ਵੀ ਸਿਰਲੇਖ ਨੂੰ ਫੜਨ ਲਈ ਤੁਹਾਨੂੰ .*hotfix.* ਚਾਹੀਦਾ ਹੈ, ਨਾ ਕਿ hotfix।

ਹਰ ਇਵੈਂਟ ਆਪਣਾ ਸੁਤੰਤਰ ਸੈਸ਼ਨ ਬਣਾਉਂਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕੋ ਪੁੱਲ ਰਿਕਵੈਸਟ 'ਤੇ ਦੋ ਪੁਸ਼ ਦਾ ਮਤਲਬ ਦੋ ਰਨ। ਪ੍ਰੀਵਿਊ ਦੌਰਾਨ GitHub ਇਵੈਂਟਾਂ 'ਤੇ ਪ੍ਰਤੀ ਰੂਟੀਨ ਅਤੇ ਪ੍ਰਤੀ ਖਾਤਾ ਘੰਟੇਵਾਰ ਸੀਮਾਵਾਂ ਵੀ ਲਾਗੂ ਹਨ। ਸੀਮਾ ਤੋਂ ਉੱਪਰ ਦੇ ਇਵੈਂਟ ਵਿੰਡੋ ਰੀਸੈੱਟ ਹੋਣ ਤੱਕ ਛੱਡ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ।

4. ਰੂਟੀਨ ਬਣਾਉਣਾ, ਕਦਮ-ਦਰ-ਕਦਮ

ਤੁਸੀਂ ਤਿੰਨ ਥਾਵਾਂ ਤੋਂ ਰੂਟੀਨ ਬਣਾ ਸਕਦੇ ਹੋ: ਵੈੱਬ 'ਤੇ claude.ai/code/routines, Claude Desktop ਐਪ ਦੇ Code ਟੈਬ ਦਾ Routines ਸੈਕਸ਼ਨ, ਜਾਂ CLI। ਤਿੰਨੇ ਇੱਕੋ ਖਾਤੇ ਵਿੱਚ ਲਿਖਦੇ ਹਨ, ਇਸ ਲਈ ਇੱਕ ਥਾਂ ਬਣਾਇਆ ਰੂਟੀਨ ਬਾਕੀ ਥਾਵਾਂ 'ਤੇ ਤੁਰੰਤ ਦਿਸਦਾ ਹੈ।

4.1 ਵੈੱਬ 'ਤੇ

1. claude.ai/code/routines ਖੋਲ੍ਹੋ ਅਤੇ New routine ਚੁਣੋ।
2. ਇਸ ਨੂੰ ਨਾਮ ਦਿਓ ਅਤੇ ਪ੍ਰੌਂਪਟ ਲਿਖੋ। ਮਾਡਲ ਚੁਣੋ।
3. ਉਹ ਰਿਪੋਜ਼ਿਟਰੀਆਂ ਜੋੜੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ Claude ਨੇ ਕੰਮ ਕਰਨਾ ਹੈ।
4. ਇੱਕ ਕਲਾਊਡ ਐਨਵਾਇਰਨਮੈਂਟ ਚੁਣੋ। Default ਐਨਵਾਇਰਨਮੈਂਟ ਵਿੱਚ Trusted ਨੈੱਟਵਰਕ ਐਕਸੈੱਸ ਹੁੰਦਾ ਹੈ, ਜੋ ਆਮ ਪੈਕੇਜ ਰਜਿਸਟਰੀਆਂ, ਕਲਾਊਡ ਪ੍ਰੋਵਾਈਡਰ API ਅਤੇ ਡਿਵੈਲਪਮੈਂਟ ਡੋਮੇਨਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਜੇ ਰੂਟੀਨ ਨੇ ਤੁਹਾਡੀਆਂ ਆਪਣੀਆਂ ਸੇਵਾਵਾਂ ਤੱਕ ਪਹੁੰਚਣਾ ਹੈ, ਤਾਂ ਪਹਿਲਾਂ ਐਨਵਾਇਰਨਮੈਂਟ ਦੇ ਮਨਜ਼ੂਰਸ਼ੁਦਾ ਡੋਮੇਨ ਅਡਜਸਟ ਕਰੋ।
5. ਇੱਕ ਜਾਂ ਵੱਧ ਟ੍ਰਿਗਰ ਚੁਣੋ। API ਟ੍ਰਿਗਰ ਲਈ ਪਹਿਲਾਂ ਰੂਟੀਨ ਸੇਵ ਕਰੋ; URL ਅਤੇ ਟੋਕਨ ਉਸ ਤੋਂ ਬਾਅਦ ਬਣਦੇ ਹਨ।
6. ਕਨੈਕਟਰਾਂ ਦੀ ਸਮੀਖਿਆ ਕਰੋ। ਤੁਹਾਡੇ ਸਾਰੇ ਜੁੜੇ ਹੋਏ ਕਨੈਕਟਰ ਡਿਫ਼ੌਲਟ ਤੌਰ 'ਤੇ ਸ਼ਾਮਲ ਹੁੰਦੇ ਹਨ, ਅਤੇ Claude ਬਿਨਾਂ ਪੁੱਛੇ ਉਨ੍ਹਾਂ ਦੇ ਹਰ ਟੂਲ ਨੂੰ ਵਰਤ ਸਕਦਾ ਹੈ, ਲਿਖਣ ਵਾਲੀਆਂ ਕਾਰਵਾਈਆਂ ਸਮੇਤ। ਜੋ ਕੁਝ ਵੀ ਟਾਸਕ ਲਈ ਲੋੜੀਂਦਾ ਨਾ ਹੋਵੇ, ਉਸ ਨੂੰ ਹਟਾ ਦਿਓ।
7. Create ਚੁਣੋ, ਫਿਰ ਸ਼ਡਿਊਲ 'ਤੇ ਨਿਰਭਰ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ ਟੈਸਟ ਲਈ Run now ਚੁਣੋ।

4.2 CLI ਤੋਂ

ਕਿਸੇ ਵੀ ਲੋਕਲ Claude Code ਸੈਸ਼ਨ ਵਿੱਚ, /schedule (ਉਪਨਾਮ /routines) ਗੱਲਬਾਤ ਰਾਹੀਂ ਇੱਕ ਸ਼ਡਿਊਲਡ ਰੂਟੀਨ ਬਣਾਉਂਦਾ ਹੈ। Claude ਅੰਤਰਾਲ, ਰਿਪੋਜ਼ਿਟਰੀਆਂ ਅਤੇ ਪ੍ਰੌਂਪਟ ਬਾਰੇ ਪੁੱਛਦਾ ਹੈ, ਫਿਰ ਉਸ ਨੂੰ ਤੁਹਾਡੇ ਖਾਤੇ ਵਿੱਚ ਸੇਵ ਕਰ ਦਿੰਦਾ ਹੈ।

/schedule daily PR review at 9am
/schedule tomorrow at 9am, summarise yesterday's merged PRs
/schedule list
/schedule update
/schedule run
/schedule why did my nightly review do nothing this morning?

ਆਖ਼ਰੀ ਮਿਸਾਲ ਖ਼ਾਸ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੈ। Claude ਰੂਟੀਨ ਦੇ ਹਾਲੀਆ ਰਨਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ, ਸਬੰਧਤ ਲੌਗ ਪੜ੍ਹਦਾ ਹੈ ਅਤੇ ਦੱਸਦਾ ਹੈ ਕਿ ਕੀ ਹੋਇਆ, ਟੂਲ ਗਲਤੀਆਂ ਅਤੇ ਇਜਾਜ਼ਤ ਇਨਕਾਰਾਂ ਸਮੇਤ। ਹਾਲੀਆ CLI ਸੰਸਕਰਣ GitHub App ਇੰਸਟਾਲ ਹੋਣ ਤੋਂ ਬਾਅਦ ਗੱਲਬਾਤ ਰਾਹੀਂ GitHub ਟ੍ਰਿਗਰ ਵੀ ਜੋੜ ਸਕਦੇ ਹਨ। ਹਾਲਾਂਕਿ, API ਟੋਕਨ ਸਿਰਫ਼ ਵੈੱਬ 'ਤੇ ਹੀ ਬਣਾਏ ਜਾਂ ਰੱਦ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ।

ਜੇ /schedule ਪਛਾਣਿਆ ਨਹੀਂ ਜਾਂਦਾ, ਤਾਂ ਕਾਰਨ ਲਗਭਗ ਹਮੇਸ਼ਾ ਪ੍ਰਮਾਣੀਕਰਨ ਹੁੰਦਾ ਹੈ। Routines ਲਈ claude.ai ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਲੌਗਇਨ ਚਾਹੀਦਾ ਹੈ। Console API key, ANTHROPIC_API_KEY ਐਨਵਾਇਰਨਮੈਂਟ ਵੇਰੀਏਬਲ, ਜਾਂ Amazon Bedrock ਵਰਗੇ ਕਲਾਊਡ-ਪ੍ਰੋਵਾਈਡਰ ਲੌਗਇਨ ਨਾਲ ਇਹ ਕਮਾਂਡ ਲੁਕ ਜਾਂਦੀ ਹੈ। Team ਅਤੇ Enterprise ਪਲਾਨਾਂ 'ਤੇ ਕੋਈ Owner ਪੂਰੀ ਸੰਸਥਾ ਲਈ ਰੂਟੀਨ ਬੰਦ ਵੀ ਕਰ ਸਕਦਾ ਹੈ।

5. ਅਜਿਹੇ ਪ੍ਰੌਂਪਟ ਲਿਖਣਾ ਜੋ ਬਿਨਾਂ ਨਿਗਰਾਨੀ ਵਾਲੇ ਰਨਾਂ ਵਿੱਚ ਟਿਕੇ ਰਹਿਣ

ਰੂਟੀਨ ਦਾ ਪ੍ਰੌਂਪਟ ਕਿਸੇ ਚੈਟ ਸੁਨੇਹੇ ਦੀ ਬਜਾਏ ਇੱਕ ਰਨਬੁੱਕ ਦੇ ਵਧੇਰੇ ਨੇੜੇ ਹੈ। ਅਸਪਸ਼ਟਤਾ ਦੂਰ ਕਰਨ ਲਈ ਕੋਈ ਮੌਜੂਦ ਨਹੀਂ ਹੁੰਦਾ, ਇਸ ਲਈ ਅਸਪਸ਼ਟ ਹਦਾਇਤਾਂ ਅਸਪਸ਼ਟ ਨਤੀਜੇ ਦਿੰਦੀਆਂ ਹਨ, ਜਾਂ ਇਸ ਤੋਂ ਵੀ ਬੁਰਾ, ਭਰੋਸੇ ਨਾਲ ਕੀਤੀਆਂ ਅਜਿਹੀਆਂ ਕਾਰਵਾਈਆਂ ਜੋ ਤੁਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਸੀ। ਤੁਲਨਾ ਕਰੋ:

ਇੱਕ ਚੰਗਾ ਰੂਟੀਨ ਪ੍ਰੌਂਪਟ ਦੱਸਦਾ ਹੈ:

• ਦਾਇਰਾ: ਕਿਹੜੀਆਂ ਰਿਪੋਜ਼ਿਟਰੀਆਂ, ਕਿਹੜੀ ਸਮਾਂ-ਮਿਆਦ ਅਤੇ ਕਿਹੜੀਆਂ ਆਈਟਮਾਂ।
• ਮਨਜ਼ੂਰ ਕਾਰਵਾਈਆਂ: Claude ਕੀ ਬਦਲ ਸਕਦਾ ਹੈ ਅਤੇ, ਓਨਾ ਹੀ ਅਹਿਮ, ਕਿਸ ਨੂੰ ਛੂਹਣਾ ਨਹੀਂ।
• ਆਉਟਪੁੱਟ: ਸਹੀ ਮੰਜ਼ਿਲ ਅਤੇ ਫ਼ਾਰਮੈਟ, ਜਿਵੇਂ ਡਰਾਫ਼ਟ PR, Slack ਚੈਨਲ ਜਾਂ ਟ੍ਰੈਕਰ ਟਿੱਪਣੀ।
• ਰੁਕਣ ਦੀਆਂ ਸ਼ਰਤਾਂ: ਕਰਨ ਲਈ ਕੁਝ ਨਾ ਹੋਵੇ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ, ਅਤੇ ਕਦੋਂ ਹਾਰ ਮੰਨਣੀ ਹੈ।
• ਪੇਲੋਡ ਦਾ ਪ੍ਰਬੰਧਨ: API ਟ੍ਰਿਗਰਾਂ ਲਈ, fire ਟੈਕਸਟ ਵਰਤਣਾ ਹੈ ਜਾਂ ਨਹੀਂ ਅਤੇ ਕਿਵੇਂ।

ਉਮੀਦ ਰੱਖੋ ਕਿ ਨਵੇਂ ਰੂਟੀਨ ਨੂੰ ਪਹਿਲੇ ਹਫ਼ਤੇ ਵਿੱਚ ਦੋ-ਤਿੰਨ ਵਾਰ ਸੁਧਾਰਨਾ ਪਵੇਗਾ। ਸਿਰਫ਼ ਸਟੇਟਸ ਬੈਜ ਨਹੀਂ, ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਪੜ੍ਹੋ। Anthropic ਸਪਸ਼ਟ ਕਹਿੰਦਾ ਹੈ ਕਿ ਹਰੇ ਸਟੇਟਸ ਦਾ ਮਤਲਬ ਸਿਰਫ਼ ਇਹ ਹੈ ਕਿ ਸੈਸ਼ਨ ਬਿਨਾਂ ਕਿਸੇ ਇਨਫ੍ਰਾਸਟ੍ਰਕਚਰ ਗਲਤੀ ਦੇ ਸ਼ੁਰੂ ਹੋਇਆ ਅਤੇ ਖ਼ਤਮ ਹੋਇਆ। ਇਸ ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਕਿ ਟਾਸਕ ਸਫ਼ਲ ਰਿਹਾ।

6. ਸਬ-ਰੂਟੀਨ (sub-routines): ਇੱਕੋ ਰਨ ਦੇ ਅੰਦਰ ਕੰਮ ਨੂੰ ਢਾਂਚਾਬੱਧ ਕਰਨਾ

Anthropic "ਸਬ-ਰੂਟੀਨ" ਨਾਮ ਦੀ ਕੋਈ ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ ਦਿੰਦਾ। Workstation ਵਿੱਚ ਅਸੀਂ ਇਹ ਸ਼ਬਦ ਇੱਕ ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ ਲਈ ਵਰਤਦੇ ਹਾਂ ਜੋ ਲੰਬੇ, ਬਿਨਾਂ ਨਿਗਰਾਨੀ ਵਾਲੇ ਰਨਾਂ ਨੂੰ ਕਿਤੇ ਵੱਧ ਭਰੋਸੇਯੋਗ ਬਣਾਉਂਦਾ ਹੈ: ਰੂਟੀਨ ਦਾ ਪ੍ਰੌਂਪਟ ਇੱਕ ਔਰਕੈਸਟ੍ਰੇਟਰ ਵਾਂਗ ਕੰਮ ਕਰਦਾ ਹੈ, ਅਤੇ ਹਰ ਸਪਸ਼ਟ ਪਰਿਭਾਸ਼ਿਤ ਕਦਮ ਨੂੰ ਕਿਸੇ ਸਬਏਜੰਟ ਜਾਂ ਰਿਪੋਜ਼ਿਟਰੀ ਵਿੱਚ ਕਮਿਟ ਕੀਤੀ ਕਿਸੇ ਸਕਿੱਲ ਨੂੰ ਸੌਂਪ ਦਿੰਦਾ ਹੈ।

ਇਹ Claude Code ਦੇ ਦੋ ਬੁਨਿਆਦੀ ਹਿੱਸਿਆਂ ਕਰਕੇ ਕੰਮ ਕਰਦਾ ਹੈ ਜੋ ਤੁਹਾਡੀ ਰਿਪੋਜ਼ਿਟਰੀ ਦੇ ਨਾਲ ਚੱਲਦੇ ਹਨ:

• ਸਬਏਜੰਟ .claude/agents/ ਵਿੱਚ YAML ਫ਼੍ਰੰਟ ਮੈਟਰ ਵਾਲੀਆਂ Markdown ਫ਼ਾਈਲਾਂ ਹਨ। ਹਰ ਇੱਕ ਦਾ ਆਪਣਾ ਸਿਸਟਮ ਪ੍ਰੌਂਪਟ, ਟੂਲ ਇਜਾਜ਼ਤ-ਸੂਚੀ ਅਤੇ ਵਿਕਲਪਿਕ ਮਾਡਲ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਉਹ ਆਪਣੀ ਵੱਖਰੀ ਕਾਂਟੈਕਸਟ ਵਿੰਡੋ ਵਿੱਚ ਚੱਲਦਾ ਹੈ। ਕਾਲ ਕਰਨ ਵਾਲੇ ਕੋਲ ਸਿਰਫ਼ ਇੱਕ ਸਾਰ ਵਾਪਸ ਆਉਂਦਾ ਹੈ। ਸਬਏਜੰਟ ਸਮਾਨਾਂਤਰ ਚੱਲ ਸਕਦੇ ਹਨ, ਅਤੇ ਡਿਫ਼ੌਲਟ ਤੌਰ 'ਤੇ ਆਪ ਵੀ ਤਿੰਨ ਪੱਧਰਾਂ ਦੀ ਡੂੰਘਾਈ ਤੱਕ ਕੰਮ ਸੌਂਪ ਸਕਦੇ ਹਨ।
• ਸਕਿੱਲਾਂ .claude/skills/ ਵਿੱਚ ਮੁੜ-ਵਰਤੋਂਯੋਗ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਪੈਕੇਜ ਕਰਦੀਆਂ ਹਨ, ਜਿਵੇਂ ਤੁਹਾਡੀ ਰਿਲੀਜ਼-ਨੋਟ ਸ਼ੈਲੀ ਜਾਂ ਸੁਰੱਖਿਆ ਸਮੀਖਿਆ ਚੈੱਕਲਿਸਟ, ਜਿਨ੍ਹਾਂ ਨੂੰ Claude ਲੋੜ ਪੈਣ 'ਤੇ ਲੋਡ ਕਰਦਾ ਹੈ। ਰੂਟੀਨ ਕਲੋਨ ਕੀਤੀ ਰਿਪੋਜ਼ਿਟਰੀ ਵਿੱਚ ਕਮਿਟ ਕੀਤੀਆਂ ਸਕਿੱਲਾਂ ਵਰਤਦੇ ਹਨ।

ਇਸ ਤਰ੍ਹਾਂ ਬਣਿਆ ਇੱਕ ਰਾਤ ਵਾਲਾ ਮੇਨਟੇਨੈਂਸ ਰੂਟੀਨ ਕੁਝ ਇਸ ਤਰ੍ਹਾਂ ਦਿਸ ਸਕਦਾ ਹੈ:

# Routine prompt (orchestrator)
1. Use the issue-triager subagent to label and assign issues opened since the last run.
2. Pick the single highest-priority bug labelled "good-first-fix".
3. Use the bug-fixer subagent to implement a fix on a claude/ branch.
4. Use the test-runner subagent to run the test suite; if it fails twice, stop and report.
5. Open ONE draft PR, using the release-notes skill for the description.
6. Post a three-line summary to #eng-nightly.

# .claude/agents/issue-triager.md
---
name: issue-triager
description: Labels and assigns new issues. Never edits code.
tools: Read, Grep, Glob
model: haiku
---
You triage GitHub issues. Apply area labels from CODEOWNERS and
assign the owning team. Return a table of issue, label and owner.

ਲਾਭ ਵਿਹਾਰਕ ਹਨ। ਹਰ ਸਹਾਇਕ ਸਿਰਫ਼ ਉਹੀ ਵੇਖਦਾ ਹੈ ਜਿਸ ਦੀ ਉਸ ਨੂੰ ਲੋੜ ਹੈ, ਇਸ ਲਈ ਲੰਬੇ ਰਨ ਦੌਰਾਨ ਔਰਕੈਸਟ੍ਰੇਟਰ ਦਾ ਕਾਂਟੈਕਸਟ ਛੋਟਾ ਅਤੇ ਕੇਂਦ੍ਰਿਤ ਰਹਿੰਦਾ ਹੈ। ਹਰ ਕਦਮ ਲਈ ਟੂਲ ਇਜਾਜ਼ਤਾਂ ਸੀਮਿਤ ਹੁੰਦੀਆਂ ਹਨ: ਉੱਪਰ ਵਾਲਾ ਟ੍ਰਾਇਏਜਰ ਫ਼ਾਈਲਾਂ ਸੋਧ ਹੀ ਨਹੀਂ ਸਕਦਾ। ਮਸ਼ੀਨੀ ਕਦਮਾਂ ਨੂੰ ਸਸਤੇ ਮਾਡਲ ਸੰਭਾਲ ਸਕਦੇ ਹਨ। ਅਤੇ ਕਿਉਂਕਿ ਸਬਏਜੰਟ ਅਤੇ ਸਕਿੱਲਾਂ ਵਰਜ਼ਨ ਕੰਟਰੋਲ ਵਿੱਚ ਰਹਿੰਦੀਆਂ ਹਨ, ਰੂਟੀਨ ਦੇ ਵਿਹਾਰ ਵਿੱਚ ਹੋਣ ਵਾਲੇ ਬਦਲਾਅ ਕਿਸੇ ਵੀ ਹੋਰ ਬਦਲਾਅ ਵਾਂਗ ਕੋਡ ਰਿਵਿਊ ਵਿੱਚੋਂ ਲੰਘਦੇ ਹਨ।

7. ਕੋ-ਰੂਟੀਨ (co-routines): ਆਪਸ ਵਿੱਚ ਸਹਿਯੋਗ ਕਰਨ ਵਾਲੇ ਰੂਟੀਨ

ਇੱਥੇ ਵੀ, "ਕੋ-ਰੂਟੀਨ" ਸਾਡਾ ਸ਼ਬਦ ਹੈ, Anthropic ਦੀ ਕੋਈ ਵਿਸ਼ੇਸ਼ਤਾ ਨਹੀਂ। ਅਸੀਂ ਇਸ ਨੂੰ ਅਜਿਹੇ ਕਈ ਸੁਤੰਤਰ ਰੂਟੀਨਾਂ ਲਈ ਵਰਤਦੇ ਹਾਂ ਜੋ ਇੱਕ-ਦੂਜੇ ਨੂੰ ਕੰਮ ਸੌਂਪਦੇ ਹਨ, ਬਿਲਕੁਲ ਉਵੇਂ ਜਿਵੇਂ ਪ੍ਰੋਡਕਸ਼ਨ ਲਾਈਨ ਵਿੱਚ ਇੱਕ ਪੁਰਜ਼ਾ ਇੱਕ ਸਟੇਸ਼ਨ ਤੋਂ ਅਗਲੇ ਸਟੇਸ਼ਨ ਤੱਕ ਜਾਂਦਾ ਹੈ। ਰੂਟੀਨ ਇੱਕ-ਦੂਜੇ ਨੂੰ ਸਿੱਧਾ ਕਾਲ ਨਹੀਂ ਕਰ ਸਕਦੇ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਕੋਈ ਸਾਂਝੀ ਮੈਮਰੀ ਨਹੀਂ ਹੁੰਦੀ। ਇਸ ਦੀ ਬਜਾਏ, ਇੱਕ ਰੂਟੀਨ ਇੱਕ ਟਿਕਾਊ ਆਰਟੀਫ਼ੈਕਟ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ 'ਤੇ ਦੂਜੇ ਰੂਟੀਨ ਦਾ ਟ੍ਰਿਗਰ ਨਜ਼ਰ ਰੱਖਦਾ ਹੈ।

ਇੱਕ ਆਮ ਲੜੀ:

1. ਰੂਟੀਨ A (ਸ਼ਡਿਊਲ) ਕੰਮਕਾਜੀ ਦਿਨਾਂ ਦੀਆਂ ਰਾਤਾਂ ਨੂੰ ਬੈਕਲੌਗ ਦੀ ਛਾਂਟੀ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ claude/fix-… ਬ੍ਰਾਂਚ ਤੋਂ ਡਰਾਫ਼ਟ PR ਖੋਲ੍ਹਦਾ ਹੈ।
2. ਰੂਟੀਨ B (GitHub, pull_request.opened) ਉਨ੍ਹਾਂ ਹੈੱਡ ਬ੍ਰਾਂਚਾਂ ਤੱਕ ਫ਼ਿਲਟਰ ਕੀਤਾ ਗਿਆ ਹੈ ਜੋ claude/ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੀਆਂ ਹਨ। ਇਹ ਟੀਮ ਦੀ ਰਿਵਿਊ ਚੈੱਕਲਿਸਟ ਲਾਗੂ ਕਰਦਾ ਹੈ ਅਤੇ PR 'ਤੇ ਲੇਬਲ ਲਾਉਂਦਾ ਹੈ।
3. ਇੱਕ ਮਨੁੱਖ ਸਮੀਖਿਆ ਕਰਕੇ ਮਰਜ ਕਰਦਾ ਹੈ। ਇਹੀ ਮਨਜ਼ੂਰੀ ਦਾ ਗੇਟ ਹੈ।
4. ਰੂਟੀਨ C (GitHub, pull_request.closed, merged = true) ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ ਜਾਂ ਬਦਲਾਅ ਨੂੰ ਕਿਸੇ ਸਹਿਯੋਗੀ SDK ਵਿੱਚ ਪੋਰਟ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਫ਼ੌਲੋ-ਅੱਪ PR ਖੋਲ੍ਹਦਾ ਹੈ।
5. ਰੂਟੀਨ D (API) ਨੂੰ ਰਿਲੀਜ਼ ਤੋਂ ਬਾਅਦ ਡਿਪਲੌਇਮੈਂਟ ਪਾਈਪਲਾਈਨ ਕਾਲ ਕਰਦੀ ਹੈ। ਇਹ ਸਮੋਕ ਚੈੱਕ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ go ਜਾਂ no-go ਪੋਸਟ ਕਰਦਾ ਹੈ। no-go ਹੋਣ 'ਤੇ ਇਹ ਇੱਕ ਟ੍ਰੈਕਰ ਇਸ਼ੂ ਦਰਜ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਰੂਟੀਨ A ਅਗਲੀ ਰਾਤ ਚੁੱਕ ਲੈਂਦਾ ਹੈ।

ਕੰਮ ਸੌਂਪਣ ਦੇ ਚੈਨਲ, ਸਭ ਤੋਂ ਵੱਧ ਤੋਂ ਸਭ ਤੋਂ ਘੱਟ ਢਾਂਚਾਬੱਧ ਕ੍ਰਮ ਵਿੱਚ:

• GitHub ਇਵੈਂਟ: ਮੂਲ, ਫ਼ਿਲਟਰ ਕਰਨ ਯੋਗ ਅਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਆਡਿਟ ਕਰਨ ਯੋਗ।
• ਲੇਬਲ ਅਤੇ ਬ੍ਰਾਂਚ ਨਾਮਕਰਨ ਪਰੰਪਰਾਵਾਂ: ਬਿਨਾਂ ਕੋਈ ਗਲੂ ਕੋਡ ਲਿਖੇ ਕੰਮ ਨੂੰ ਰੂਟ ਕਰੋ।
• API ਕਾਲਾਂ: CI, ਮਾਨੀਟਰਿੰਗ ਜਾਂ ਅੰਦਰੂਨੀ ਟੂਲਾਂ ਤੋਂ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਪੇਲੋਡ ਨੂੰ ਅਵਿਸ਼ਵਾਸਯੋਗ ਸੰਦਰਭ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
• ਸਾਂਝਾ ਟ੍ਰੈਕਰ ਜਾਂ ਆਰਟੀਫ਼ੈਕਟ: ਕੋਈ Linear ਇਸ਼ੂ ਜਾਂ ਸਟੇਟਸ ਪੇਜ ਜਿਸ ਨੂੰ ਅਗਲਾ ਸ਼ਡਿਊਲਡ ਰਨ ਪੜ੍ਹਦਾ ਹੈ।

ਕੋ-ਰੂਟੀਨ ਧਿਆਨ ਨਾਲ ਡਿਜ਼ਾਈਨ ਕਰੋ। ਫ਼ਿਲਟਰ ਵਰਤੋ ਤਾਂ ਜੋ ਕੋਈ ਰੂਟੀਨ ਕਦੇ ਆਪਣੀ ਹੀ ਆਉਟਪੁੱਟ 'ਤੇ ਨਾ ਚੱਲੇ, ਮਿਸਾਲ ਵਜੋਂ ਉਸ ਵੱਲੋਂ ਬਣਾਏ ਲੇਖਕਾਂ ਜਾਂ ਬ੍ਰਾਂਚਾਂ ਨੂੰ ਬਾਹਰ ਰੱਖ ਕੇ। ਕੋਡ ਲਿਖਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਰੂਟੀਨ ਅਤੇ ਉਸ ਨੂੰ ਸ਼ਿੱਪ ਕਰਨ ਵਾਲੇ ਕਿਸੇ ਵੀ ਰੂਟੀਨ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਮਨੁੱਖੀ ਮਰਜ ਰੱਖੋ। ਯਾਦ ਰੱਖੋ ਕਿ ਹਰ ਪੜਾਅ ਉਸੇ ਖਾਤਾ-ਪੱਧਰੀ ਰੋਜ਼ਾਨਾ ਰਨ ਸੀਮਾ ਅਤੇ GitHub ਇਵੈਂਟ ਸੀਮਾਵਾਂ ਵਿੱਚੋਂ ਖ਼ਰਚ ਹੁੰਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਕਈ ਰੂਟੀਨਾਂ ਵਿੱਚ ਬ੍ਰਾਂਚਿੰਗ ਲੌਜਿਕ, ਰੀਟ੍ਰਾਈ ਅਤੇ ਫ਼ੈਨ-ਆਊਟ ਬਣਾਉਣ ਲੱਗ ਪਓ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਪੈਟਰਨ ਤੋਂ ਅੱਗੇ ਲੰਘ ਚੁੱਕੇ ਹੋ, ਅਤੇ ਇੱਕ ਸਮਰਪਿਤ ਵਰਕਫ਼ਲੋ ਇੰਜਣ ਬਿਹਤਰ ਟੂਲ ਹੈ।

8. ਸੁਰੱਖਿਆ ਅਤੇ ਗਵਰਨੈਂਸ

• ਰੂਟੀਨ ਤੁਹਾਡੇ ਵਜੋਂ ਕੰਮ ਕਰਦੇ ਹਨ। ਰੂਟੀਨ ਕਿਸੇ ਨਿੱਜੀ claude.ai ਖਾਤੇ ਦੇ ਹੁੰਦੇ ਹਨ ਅਤੇ ਟੀਮ ਦੇ ਸਾਥੀਆਂ ਨਾਲ ਸਾਂਝੇ ਨਹੀਂ ਹੁੰਦੇ। ਕਮਿਟ ਅਤੇ ਪੁੱਲ ਰਿਕਵੈਸਟਾਂ ਤੁਹਾਡੀ GitHub ਪਛਾਣ ਨਾਲ ਜਾਂਦੀਆਂ ਹਨ, ਅਤੇ ਕਨੈਕਟਰ ਕਾਰਵਾਈਆਂ ਤੁਹਾਡੇ ਲਿੰਕ ਕੀਤੇ ਖਾਤੇ ਵਰਤਦੀਆਂ ਹਨ। ਰੂਟੀਨ ਨੂੰ ਅਜਿਹਾ ਪਰਸਨਲ ਐਕਸੈੱਸ ਟੋਕਨ ਸਮਝੋ ਜਿਸ ਨਾਲ ਇੱਕ ਦਿਮਾਗ਼ ਜੁੜਿਆ ਹੋਵੇ।
• ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ। Claude ਡਿਫ਼ੌਲਟ ਤੌਰ 'ਤੇ claude/ ਅਗੇਤਰ ਵਾਲੀਆਂ ਬ੍ਰਾਂਚਾਂ 'ਤੇ ਪੁਸ਼ ਕਰਦਾ ਹੈ। ਇਹ ਸੁਰੱਖਿਅਤ ਬ੍ਰਾਂਚਾਂ 'ਤੇ, ਕਿਸੇ ਹੋਰ ਦੀ ਖੁੱਲ੍ਹੀ PR ਵਾਲੀਆਂ ਬ੍ਰਾਂਚਾਂ 'ਤੇ, ਅਤੇ ਦੂਜਿਆਂ ਦੇ ਕਮਿਟਾਂ ਵਾਲੀਆਂ ਬ੍ਰਾਂਚਾਂ 'ਤੇ ਪੁਸ਼ ਕਰਨ ਤੋਂ ਇਨਕਾਰ ਕਰ ਦਿੰਦਾ ਹੈ।
• ਘੱਟੋ-ਘੱਟ ਅਧਿਕਾਰ। ਬੇਲੋੜੇ ਕਨੈਕਟਰ ਹਟਾ ਦਿਓ। ਜਦੋਂ ਤੱਕ ਕਿਸੇ ਖ਼ਾਸ ਡੋਮੇਨ ਦੀ ਲੋੜ ਨਾ ਹੋਵੇ, ਨੈੱਟਵਰਕ ਐਕਸੈੱਸ Trusted 'ਤੇ ਹੀ ਰੱਖੋ; ਬਲੌਕ ਕੀਤੀਆਂ ਰਿਕਵੈਸਟਾਂ 403 ਅਤੇ x-deny-reason: host_not_allowed ਨਾਲ ਫ਼ੇਲ੍ਹ ਹੁੰਦੀਆਂ ਹਨ। Pro ਅਤੇ Max ਪਲਾਨਾਂ 'ਤੇ API keys ਨੂੰ ਸਾਧਾਰਨ ਵੇਰੀਏਬਲਾਂ ਦੀ ਬਜਾਏ ਐਨਵਾਇਰਨਮੈਂਟ API credentials ਵਜੋਂ ਸੇਵ ਕਰੋ, ਕਿਉਂਕਿ ਸਾਧਾਰਨ ਵੇਰੀਏਬਲ ਐਨਵਾਇਰਨਮੈਂਟ ਵਰਤਣ ਵਾਲੇ ਹਰ ਵਿਅਕਤੀ ਨੂੰ ਦਿਸਦੇ ਹਨ।
• ਅਵਿਸ਼ਵਾਸਯੋਗ ਇਨਪੁੱਟ। API ਪੇਲੋਡ ਅਤੇ Run now ਟੈਕਸਟ ਅਵਿਸ਼ਵਾਸਯੋਗ ਲੇਬਲ ਨਾਲ ਆਉਂਦੇ ਹਨ। ਰਨ ਦੌਰਾਨ ਲਿਆਂਦੀ ਸਮੱਗਰੀ, ਜਿਵੇਂ ਇਸ਼ੂ ਬਾਡੀ ਅਤੇ ਵੈੱਬ ਪੇਜ, 'ਤੇ ਆਮ ਪ੍ਰੌਂਪਟ-ਇੰਜੈਕਸ਼ਨ ਸੁਰੱਖਿਆ ਲਾਗੂ ਰਹਿੰਦੀ ਹੈ। ਅਜਿਹੇ ਪ੍ਰੌਂਪਟ ਲਿਖੋ ਜੋ Claude ਨੂੰ ਦੱਸਣ ਕਿ ਕਿਸ 'ਤੇ ਭਰੋਸਾ ਕਰਨਾ ਹੈ।
• ਕਨੈਕਸ਼ਨ ਦੀ ਸਿਹਤ। ਜੇ GitHub ਕਨੈਕਸ਼ਨ ਦੀ ਮਿਆਦ ਖ਼ਤਮ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ 72 ਘੰਟਿਆਂ ਤੱਕ ਰਨ ਛੱਡ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ ਅਤੇ ਫਿਰ ਰੂਟੀਨ ਆਪਣੇ-ਆਪ ਨੂੰ ਉਦੋਂ ਤੱਕ ਬੰਦ ਕਰ ਲੈਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਦੁਬਾਰਾ ਕਨੈਕਟ ਨਾ ਕਰੋ।
• ਸੰਸਥਾਗਤ ਕੰਟਰੋਲ। Team ਅਤੇ Enterprise ਦੇ Owner ਐਡਮਿਨ ਸੈਟਿੰਗਾਂ ਤੋਂ ਸਾਰੇ ਮੈਂਬਰਾਂ ਲਈ ਰੂਟੀਨ ਬੰਦ ਕਰ ਸਕਦੇ ਹਨ।

9. ਪਲਾਨ, ਵਰਤੋਂ ਅਤੇ ਸੀਮਾਵਾਂ

ਰੂਟੀਨ ਇੰਟਰਐਕਟਿਵ ਸੈਸ਼ਨਾਂ ਵਾਂਗ ਹੀ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਵਰਤੋਂ ਖ਼ਰਚ ਕਰਦੇ ਹਨ। ਰੋਜ਼ਾਨਾ ਸੀਮਾ ਉਸ ਤੋਂ ਇਲਾਵਾ ਲਾਗੂ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਡਾ ਮੌਜੂਦਾ ਕੋਟਾ claude.ai/code/routines 'ਤੇ ਦਿਸਦਾ ਹੈ ਅਤੇ ਪ੍ਰੀਵਿਊ ਦੌਰਾਨ ਬਦਲ ਸਕਦਾ ਹੈ। ਵਰਤੋਂ ਕ੍ਰੈਡਿਟ ਚਾਲੂ ਹੋਣ 'ਤੇ ਸੀਮਾ ਤੋਂ ਵੱਧ ਰਨ ਮੀਟਰਡ ਓਵਰੇਜ ਵਜੋਂ ਜਾਰੀ ਰਹਿੰਦੇ ਹਨ; ਉਨ੍ਹਾਂ ਤੋਂ ਬਿਨਾਂ ਵਾਧੂ ਰਨ ਵਿੰਡੋ ਰੀਸੈੱਟ ਹੋਣ ਤੱਕ ਰੱਦ ਕਰ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ-ਵਾਰੀ ਸ਼ਡਿਊਲਡ ਰਨ ਸੀਮਾ ਵਿੱਚ ਨਹੀਂ ਗਿਣੇ ਜਾਂਦੇ। ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਰੁਕੀ ਹੋਣ ਦੌਰਾਨ ਉਸ ਦੇ ਰੂਟੀਨ ਵੀ ਰੁਕੇ ਰਹਿੰਦੇ ਹਨ।

10. ਰੂਟੀਨਾਂ ਦੀ ਹੋਰ ਸ਼ਡਿਊਲਿੰਗ ਵਿਕਲਪਾਂ ਨਾਲ ਤੁਲਨਾ

10.1 Claude Code ਦੇ ਅੰਦਰ

/loop ਟਾਸਕ ਸੈਸ਼ਨ ਤੱਕ ਸੀਮਿਤ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸੱਤ ਦਿਨਾਂ ਬਾਅਦ ਖ਼ਤਮ ਹੋ ਜਾਂਦੇ ਹਨ। ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਕਿਸੇ ਬਿਲਡ ਜਾਂ ਪੁੱਲ ਰਿਕਵੈਸਟ 'ਤੇ ਨਜ਼ਰ ਰੱਖਣ ਲਈ ਇਹ ਆਦਰਸ਼ ਹਨ, ਪਰ ਇਹ ਰੂਟੀਨ ਦਾ ਬਦਲ ਨਹੀਂ ਹਨ।

10.2 Claude Code ਤੋਂ ਬਾਹਰ

• GitHub Actions ਸਸਤਾ ਹੈ, ਕੋਡ ਦੇ ਨਾਲ ਹੀ ਰਹਿੰਦਾ ਹੈ ਅਤੇ ਰਨਰ 'ਤੇ ਪੂਰਾ ਕੰਟਰੋਲ ਦਿੰਦਾ ਹੈ। ਇਸ ਦੀ ਕੀਮਤ ਹੈ YAML, ਸੀਕ੍ਰੇਟਸ ਪ੍ਰਬੰਧਨ ਅਤੇ ਰਨਰ ਦਾ ਰੱਖ-ਰਖਾਅ। ਨਿਰਧਾਰਕ ਬਿਲਡ ਕਦਮਾਂ ਲਈ Actions ਚੁਣੋ, ਅਤੇ ਵਿਵੇਕ ਦੀ ਲੋੜ ਵਾਲੇ ਕੰਮ ਲਈ ਰੂਟੀਨ।
• ਵਰਕਫ਼ਲੋ ਇੰਜਣ, ਜਿਵੇਂ Trigger.dev, ਰੀਟ੍ਰਾਈ, ਫ਼ੈਨ-ਆਊਟ ਅਤੇ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੇ ਔਰਕੈਸਟ੍ਰੇਸ਼ਨ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ, ਪਰ ਔਰਕੈਸਟ੍ਰੇਸ਼ਨ ਤੁਹਾਨੂੰ ਕੋਡ ਵਿੱਚ ਲਿਖਣਾ ਪੈਂਦਾ ਹੈ। ਇਨ੍ਹਾਂ ਨੂੰ ਉਦੋਂ ਵਰਤੋ ਜਦੋਂ ਵਰਕਫ਼ਲੋ ਹੀ ਉਤਪਾਦ ਹੋਵੇ।
• ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਪਲੈਟਫ਼ਾਰਮ, ਜਿਵੇਂ n8n ਅਤੇ Zapier, SaaS ਟੂਲਾਂ ਵਿਚਕਾਰ ਡਾਟਾ ਲਿਜਾਣ ਵਿੱਚ ਮਾਹਰ ਹਨ। ਰੂਟੀਨ ਕੋਡ, ਲੌਗਾਂ ਅਤੇ ਦਸਤਾਵੇਜ਼ਾਂ 'ਤੇ ਤਰਕ ਕਰਨ ਵਿੱਚ ਮਾਹਰ ਹਨ। ਦੋਵੇਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ: ਕੋਈ n8n ਫ਼ਲੋ ਕਿਸੇ ਰੂਟੀਨ ਦੇ API ਐਂਡਪੌਇੰਟ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ।

11. ਵਰਤੋਂ ਦੇ ਮਾਮਲੇ ਜੋ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੇ ਹਨ

• ਬੈਕਲੌਗ ਦੀ ਸੰਭਾਲ: ਰਾਤ ਨੂੰ ਲੇਬਲਿੰਗ, ਮਾਲਕੀ ਤੈਅ ਕਰਨਾ ਅਤੇ ਸਵੇਰ ਦਾ ਸਾਰ।
• ਅਲਰਟ ਟ੍ਰਾਇਏਜ: ਮਾਨੀਟਰਿੰਗ API ਟ੍ਰਿਗਰ ਨੂੰ ਕਾਲ ਕਰਦੀ ਹੈ, ਅਤੇ Claude ਸਟੈਕ ਟ੍ਰੇਸ ਨੂੰ ਹਾਲੀਆ ਕਮਿਟਾਂ ਨਾਲ ਜੋੜ ਕੇ ਇੱਕ ਡਰਾਫ਼ਟ ਫ਼ਿਕਸ ਖੋਲ੍ਹਦਾ ਹੈ।
• ਅਨੁਕੂਲਿਤ ਕੋਡ ਰਿਵਿਊ: ਹਰ ready-for-review PR 'ਤੇ ਤੁਹਾਡੀ ਆਪਣੀ ਚੈੱਕਲਿਸਟ।
• ਡਿਪਲੌਇ ਪੁਸ਼ਟੀਕਰਨ: ਹਰ ਰਿਲੀਜ਼ ਤੋਂ ਬਾਅਦ ਸਮੋਕ ਚੈੱਕ ਅਤੇ ਲੌਗ ਸਕੈਨ, ਅੰਤ ਵਿੱਚ go ਜਾਂ no-go।
• ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ ਦਾ ਭਟਕਾਅ: ਮਰਜ ਹੋਈਆਂ PR ਦਾ ਹਫ਼ਤਾਵਾਰੀ ਸਕੈਨ ਅਤੇ ਉਨ੍ਹਾਂ ਡੌਕਸ ਲਈ ਅੱਪਡੇਟ PR ਜੋ ਬਦਲੇ ਹੋਏ API ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹਨ।
• ਲਾਇਬ੍ਰੇਰੀ ਪੋਰਟਿੰਗ: ਇੱਕ SDK ਵਿੱਚ ਮਰਜ ਹੋਏ ਬਦਲਾਵਾਂ ਨੂੰ ਕਿਸੇ ਹੋਰ ਭਾਸ਼ਾ ਦੇ ਸਹਿਯੋਗੀ SDK ਵਿੱਚ ਦੁਹਰਾਉਣਾ।
• ਡਿਪੈਂਡੈਂਸੀ ਦੀ ਸਾਫ਼-ਸਫ਼ਾਈ: ਪੁਰਾਣੇ ਪੈਕੇਜਾਂ ਦੀ ਹਫ਼ਤਾਵਾਰੀ ਸਮੀਖਿਆ ਅਤੇ ਇੱਕ ਇਕੱਲੀ, ਟੈਸਟ ਕੀਤੀ ਅੱਪਗ੍ਰੇਡ PR।

ਰੂਟੀਨ ਇੱਕ ਘੰਟੇ ਤੋਂ ਘੱਟ ਅੰਤਰਾਲ ਵਾਲੇ ਕੰਮ, ਰਨ ਦੇ ਵਿਚਕਾਰ ਮਨੁੱਖੀ ਫ਼ੈਸਲੇ ਦੀ ਲੋੜ ਵਾਲੇ ਟਾਸਕਾਂ, ਅਤੇ ਰੀਟ੍ਰਾਈ ਵਾਲੇ ਗੁੰਝਲਦਾਰ ਬਹੁ-ਸ਼ਾਖਾ ਵਰਕਫ਼ਲੋਆਂ ਲਈ ਘੱਟ ਢੁਕਵੇਂ ਹਨ।

12. ਭਾਈਚਾਰੇ ਨੇ ਇਸ ਨੂੰ ਕਿਵੇਂ ਲਿਆ

ਪ੍ਰਤੀਕਿਰਿਆ ਮਿਲੀ-ਜੁਲੀ ਰਹੀ ਹੈ ਪਰ ਜ਼ਿਆਦਾਤਰ ਸਕਾਰਾਤਮਕ। InfoQ ਨੇ ਅਜਿਹੇ ਇੰਜੀਨੀਅਰਾਂ ਦਾ ਹਵਾਲਾ ਦਿੱਤਾ ਜੋ webhooks ਰਾਹੀਂ AI ਨੂੰ ਸਿੱਧਾ ਔਬਜ਼ਰਵੇਬਿਲਿਟੀ ਡੈਸ਼ਬੋਰਡਾਂ ਅਤੇ CI ਵਰਕਫ਼ਲੋਆਂ ਨਾਲ ਜੋੜਨ ਬਾਰੇ ਉਤਸ਼ਾਹਿਤ ਸਨ। ਹੋਰ ਲੋਕ ਸ਼ੱਕੀ ਸਨ। ਉਨ੍ਹਾਂ ਨੇ Claude ਦੀਆਂ ਉਨ੍ਹਾਂ ਪਹਿਲੀਆਂ ਸ਼ਡਿਊਲਿੰਗ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵੱਲ ਇਸ਼ਾਰਾ ਕੀਤਾ ਜੋ ਸਿਰਫ਼ ਵਰਤੋਂਕਾਰ ਦੀ ਆਪਣੀ ਮਸ਼ੀਨ 'ਤੇ ਚੱਲਦੀਆਂ ਸਨ, ਅਤੇ ਦਲੀਲ ਦਿੱਤੀ ਕਿ ਨਵੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਤੋਂ ਪਹਿਲਾਂ ਭਰੋਸੇਯੋਗਤਾ, ਅੱਪਟਾਈਮ ਅਤੇ ਕੋਟਾ ਸੀਮਾਵਾਂ ਵੱਲ ਧਿਆਨ ਦਿੱਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਸਾਡਾ ਤਜਰਬਾ ਇਹ ਹੈ ਕਿ ਰੂਟੀਨ ਸੁਰੱਖਿਆ ਪੱਖੋਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਡਿਜ਼ਾਈਨ ਕੀਤੇ ਗਏ ਹਨ, ਖ਼ਾਸ ਕਰਕੇ ਅਵਿਸ਼ਵਾਸਯੋਗ ਪੇਲੋਡ ਦੇ ਪ੍ਰਬੰਧਨ ਅਤੇ ਬ੍ਰਾਂਚ ਸੁਰੱਖਿਆ ਵਿੱਚ। ਮੁੱਖ ਸੰਚਾਲਨ ਜੋਖਮ ਹਨ ਲੋੜ ਤੋਂ ਵੱਧ ਵਿਆਪਕ ਕਨੈਕਟਰ ਅਤੇ ਕਾਫ਼ੀ ਵਿਸ਼ੇਸ਼ ਨਾ ਹੋਣ ਵਾਲੇ ਪ੍ਰੌਂਪਟ।

13. Workstation ਇਸ ਨੂੰ ਕਿਵੇਂ ਵਰਤਦਾ ਹੈ

Workstation ਵਿੱਚ ਅਸੀਂ DevOps, ਵਿੱਤੀ ਸੰਚਾਲਨ ਅਤੇ ਗਾਹਕ ਵਰਕਫ਼ਲੋਆਂ ਵਿੱਚ ਕਲਾਇੰਟਾਂ ਲਈ ਏਜੈਂਟਿਕ ਆਟੋਮੇਸ਼ਨ ਚਲਾਉਂਦੇ ਹਾਂ। ਰੂਟੀਨ ਸਾਡੀ ਪਹੁੰਚ ਵਿੱਚ ਚੰਗੀ ਤਰ੍ਹਾਂ ਫ਼ਿੱਟ ਹੁੰਦੇ ਹਨ: ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਲਈ ਨਿਰਧਾਰਕ ਇਨਫ੍ਰਾਸਟ੍ਰਕਚਰ, ਵਿਵੇਕ ਲਈ AI, ਅਤੇ ਪ੍ਰੋਡਕਸ਼ਨ ਤੱਕ ਕੁਝ ਵੀ ਪਹੁੰਚਣ ਤੋਂ ਪਹਿਲਾਂ ਮਨੁੱਖੀ ਮਨਜ਼ੂਰੀ ਦਾ ਗੇਟ। ਜੇ ਤੁਸੀਂ ਰੂਟੀਨ ਲੜੀਆਂ, ਸਬਏਜੰਟ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜਾਂ ਉਨ੍ਹਾਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੀ ਗਵਰਨੈਂਸ ਡਿਜ਼ਾਈਨ ਕਰਨ ਵਿੱਚ ਮਦਦ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸਾਡੀ ਟੀਮ ਨਾਲ ਗੱਲ ਕਰੋ।

14. ਮੁੱਖ ਨਤੀਜੇ

• ਰੂਟੀਨ ਇੱਕ ਸੇਵ ਕੀਤਾ ਪ੍ਰੌਂਪਟ, ਰਿਪੋਜ਼ਿਟਰੀਆਂ, ਐਨਵਾਇਰਨਮੈਂਟ, ਕਨੈਕਟਰ ਅਤੇ ਟ੍ਰਿਗਰ ਹੈ, ਜੋ ਕਲਾਊਡ ਵਿੱਚ ਖੁਦਮੁਖਤਿਆਰ ਤੌਰ 'ਤੇ ਚੱਲਦਾ ਹੈ।
• ਟ੍ਰਿਗਰ ਇੱਕ ਸ਼ਡਿਊਲ (ਘੱਟੋ-ਘੱਟ ਇੱਕ ਘੰਟਾ, ਸਥਾਨਕ ਸਮਾਂ), ਇੱਕ API ਕਾਲ (bearer ਟੋਕਨ, ਅਵਿਸ਼ਵਾਸਯੋਗ ਪੇਲੋਡ) ਜਾਂ ਇੱਕ GitHub ਪੁੱਲ ਰਿਕਵੈਸਟ ਜਾਂ ਰਿਲੀਜ਼ ਇਵੈਂਟ ਹੋ ਸਕਦਾ ਹੈ।
• Pro, Max, Team ਅਤੇ Enterprise 'ਤੇ ਉਪਲਬਧ, ਆਮ ਵਰਤੋਂ ਤੋਂ ਇਲਾਵਾ ਰੋਜ਼ਾਨਾ ਰਨ ਸੀਮਾਵਾਂ ਨਾਲ। ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਹਾਲੇ ਵੀ ਰਿਸਰਚ ਪ੍ਰੀਵਿਊ ਵਿੱਚ ਹੈ।
• ਇੱਕ ਲੰਬੇ ਰਨ ਨੂੰ ਕੇਂਦ੍ਰਿਤ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਅਧਿਕਾਰਾਂ ਵਾਲਾ ਰੱਖਣ ਲਈ ਸਬ-ਰੂਟੀਨ (ਸਬਏਜੰਟ ਅਤੇ ਸਕਿੱਲਾਂ) ਵਰਤੋ।
• ਬਹੁ-ਪੜਾਵੀ ਪਾਈਪਲਾਈਨਾਂ ਲਈ ਕੋ-ਰੂਟੀਨ (PR, ਲੇਬਲਾਂ ਅਤੇ API ਕਾਲਾਂ ਰਾਹੀਂ ਕੰਮ ਸੌਂਪਣ ਵਾਲੇ ਰੂਟੀਨ) ਵਰਤੋ, ਵਿਚਕਾਰ ਇੱਕ ਮਨੁੱਖੀ ਮਰਜ ਗੇਟ ਨਾਲ।
• ਕਨੈਕਟਰਾਂ ਅਤੇ ਨੈੱਟਵਰਕ ਐਕਸੈੱਸ ਦਾ ਦਾਇਰਾ ਸਖ਼ਤੀ ਨਾਲ ਸੀਮਿਤ ਰੱਖੋ, ਪ੍ਰੌਂਪਟ ਰਨਬੁੱਕ ਵਾਂਗ ਲਿਖੋ, ਅਤੇ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਪੜ੍ਹੋ।

ਸਰੋਤ ਅਤੇ ਹੋਰ ਪੜ੍ਹਨ ਲਈ

• Anthropic: Introducing routines in Claude Code (14 ਅਪ੍ਰੈਲ 2026)
• Claude Code Docs: Automate work with routines
• Claude Code Docs: Run prompts on a schedule (/loop)
• Claude Code Docs: Subagents
• Claude Platform Docs: Trigger a routine through the API
• InfoQ: Anthropic Introduces Routines for Claude Code Automation
• MindStudio: Claude Code Routines: How to Run Scheduled AI Agents Without a Server
• Medium 'ਤੇ Tahir: What is Claude Code Routines?

Routines ਰਿਸਰਚ ਪ੍ਰੀਵਿਊ ਵਿੱਚ ਹਨ। ਵਿਹਾਰ, ਸੀਮਾਵਾਂ ਅਤੇ API ਬਦਲ ਸਕਦੇ ਹਨ। ਇਸ ਗਾਈਡ ਦੇ ਤੱਥ 25 ਸਤੰਬਰ 2026 ਤੱਕ Anthropic ਦੀ ਪ੍ਰਕਾਸ਼ਿਤ ਡੌਕਯੂਮੈਂਟੇਸ਼ਨ 'ਤੇ ਆਧਾਰਿਤ ਹਨ।