2026 में अपना पहला AI लूप कैसे बनाएं

दुनिया के दो सबसे वरिष्ठ AI इंजीनियरों ने पिछले महीने एक ही बात कही।

पीटर स्टाइनबर्गर, OpenClaw के निर्माता, अब OpenAI में:

"आपको अब कोडिंग एजेंट्स को प्रॉम्प्ट नहीं करना चाहिए। आपको ऐसे लूप्स डिज़ाइन करने चाहिए जो आपके एजेंट्स को प्रॉम्प्ट करें।"

बोरिस चेर्नी, Anthropic में Claude Code के प्रमुख:

"मैं अब Claude को प्रॉम्प्ट नहीं करता। मेरे पास लूप हैं जो Claude को प्रॉम्प्ट करते हैं और तय करते हैं कि क्या करना है। मेरा काम लूप लिखना है।"

ज़्यादातर लोगों ने यह पढ़ा और सोचा: इसका असल में मतलब क्या है?

और इससे भी ज़रूरी: मैं एक कैसे बनाऊँ?

यह लेख आपको बिल्कुल सटीक तरीका बताता है।

कोई सिद्धांत बिना कोड के नहीं। कोई कोड बिना संदर्भ के नहीं। असली कदम। असली कमांड। कॉपी करें और चलाएँ।

Slate एक वास्तविक माइग्रेशन कार्य में GPT-5.6, Claude, और विशिष्ट सबएजेंट्स का ऑर्केस्ट्रेशन कर रहा है। मॉडल ज़्यादा स्मार्ट हो गया है। बड़ा बदलाव यह है कि Slate जैसे टूल्स अब उन मॉडलों को लगातार व्यस्त रख सकते हैं, बजाय मानव प्रॉम्प्ट की प्रतीक्षा करने के।

जिस तरह से ज़्यादातर लोग AI का उपयोग करते हैं वह पहले से ही पुराना हो चुका है

प्रॉम्प्ट लिखें। प्रतीक्षा करें। आउटपुट पढ़ें। इसे मैन्युअल रूप से ठीक करें। दूसरा प्रॉम्प्ट लिखें।

आप लूप हैं।

हर कदम आपके माध्यम से चलता है। AI प्रतीक्षा करता है। आप निर्णय लेते हैं। AI फिर से प्रतीक्षा करता है।

जैसे ही आप रुकते हैं, सब कुछ रुक जाता है।

2026 में सबसे तेज़ी से आगे बढ़ने वाले बिल्डर बेहतर प्रॉम्प्ट नहीं लिख रहे हैं।

वे ऐसी प्रणालियाँ बना रहे हैं जो उनके लिए प्रॉम्प्टिंग करती हैं।

लीवरेज पॉइंट बदल गया है।

प्रॉम्प्ट टाइप करने से → लूप डिज़ाइन करने तक।

GPT-5.6 के साथ क्या बदला?

GPT-5.6 लूप की आवश्यकता को नहीं बदलता है।

यह उनके मूल्य को बढ़ाता है।

मॉडल जितना बेहतर होता जाता है, प्रॉम्प्ट के बीच इसे निष्क्रिय छोड़ना उतना ही महंगा होता जाता है।

टर्मिनल वर्कफ़्लो में, GPT-5.6 इनमें काफ़ी बेहतर है:

→ बड़े कोडबेस को समझना

→ कार्यान्वयन की स्थिरता बनाए रखना

→ बहु-चरणीय योजनाओं का पालन करना

→ असफल प्रयासों से उबरना

→ एक सख्त सत्यापनकर्ता के रूप में कार्य करना

परिणाम "बेहतर प्रॉम्प्टिंग" नहीं है।

यह प्रति कार्य कम मानवीय हस्तक्षेप है।

एक लूप वास्तव में क्या है

सरल परिभाषा:

एक प्रॉम्प्ट एक बार उत्तर देता है और रुक जाता है।

एक लूप तब तक काम करता रहता है जब तक काम वास्तव में पूरा न हो जाए।

जब तक वह कोई उत्तर उत्पन्न नहीं करता।

जब तक वह सत्यापित परिणाम तक नहीं पहुँचता।

हर गंभीर AI एजेंट एक ही अंतर्निहित चक्र चलाता है:

→ खोजें — क्या करने की आवश्यकता है?

→ निष्पादित करें — काम करें

→ सत्यापित करें — क्या यह वास्तव में काम किया?

→ दोहराएँ — पूरा नहीं हुआ? ठीक करें और दोहराएँ

→ रुकें — शर्त पूरी हुई, या हार्ड लिमिट हिट

Claude Code. Cursor. Codex.

अंतर्निहित रूप से, ये सभी यह लूप चलाते हैं।

प्रॉम्प्ट और लूप के बीच का अंतर मॉडल नहीं है।

यह है कि क्या कोई चीज़ काम की जाँच करती है और तब तक जारी रखती है जब तक वह पास न हो जाए।

4-शर्त परीक्षण — कुछ भी बनाने से पहले इसे चलाएँ

अधिकांश लूप यहीं विफल होते हैं।

एक लूप अपनी सेटअप लागत तभी कमाता है जब सभी 4 शर्तें सत्य हों।

एक को छोड़ें और लूप अपनी वापसी से अधिक खर्च करता है।

1. कार्य दोहराया जाता है। कम से कम साप्ताहिक। एक बार का कार्य अभी भी एक अच्छे प्रॉम्प्ट द्वारा बेहतर ढंग से किया जाता है।

2. सत्यापन स्वचालित है। कोई चीज़ आपके बिना कमरे में काम को विफल करनी चाहिए। टेस्ट। लिंटर्स। बिल्ड। टाइप चेक। कोई गेट नहीं = एजेंट अपना खुद का होमवर्क ग्रेड कर रहा है।

3. आपका टोकन बजट बर्बादी को सहन कर सकता है। लूप हर पुनरावृत्ति पर पूरा संदर्भ फिर से पढ़ते हैं। वे पुनः प्रयास करते हैं, खोज करते हैं, टोकन जलाते हैं चाहे रन कुछ भी शिप करे। यह वह लागत है जिसका कोई उल्लेख नहीं करता।

4. "पूर्ण" वस्तुनिष्ठ है। एक परीक्षण जो पास होता है या विफल होता है। एक बिल्ड जो संकलित होता है या नहीं। "जब यह अच्छा दिखता है" नहीं। यदि पूर्ण होने के लिए मानवीय राय की आवश्यकता है, तो इसे मैन्युअल रखें।

सभी 4 पास करें → लूप बनाएँ।

किसी 1 में विफल → इसके बजाय प्रॉम्प्ट का उपयोग करें।

ईमानदार संस्करण: अधिकांश डेवलपर्स को अभी भारी लूप की आवश्यकता नहीं है। हर कोई एक सरल लूप का उपयोग कर सकता है। हम जल्द ही एक बनाएँगे।

Slate इंस्टॉल करें

Slate एक AI कोडिंग एजेंट है जो ठीक इसी के लिए बनाया गया है — आपके टर्मिनल में लंबे, समानांतर, बहु-चरणीय कार्य चलाना।

RandomLabs द्वारा निर्मित। विशेष रूप से स्वार्म ऑर्केस्ट्रेशन के लिए बनाया गया पहला एजेंट।

इसे Claude Code या Cursor से अलग क्या बनाता है:

→ प्रत्येक चरण के लिए स्वचालित रूप से सही मॉडल का चयन करता है। Claude के साथ योजना बनाएँ, दूसरे के साथ खोजें, Codex के साथ निष्पादित करें — Slate निर्णय लेता है।

→ आपके कोडबेस में एक साथ समानांतर सबएजेंट चलाता है

→ लंबे मल्टी-घंटे सत्रों में अपने स्वयं के संदर्भ का प्रबंधन करता है

→ आपके साथ काम करता है — न कि केवल आपके लिए

इसे एक पंक्ति में इंस्टॉल करें:

1npm i -g @randomlabs/slate

अपने प्रोजेक्ट पर जाएँ और इसे शुरू करें:

1cd /path/to/your/project
2slate

यह Slate TUI खोलता है — एक टर्मिनल इंटरफ़ेस जहाँ आप इसे कार्य देते हैं और इसे काम करते हुए देखते हैं।

चरण 1 — अपना कार्यक्षेत्र सेट करें

Slate आपके प्रोजेक्ट पर लूप चलाने से पहले, उसे आपके कोडबेस को समझना होगा।

अपने प्रोजेक्ट रूट में AGENTS.md फ़ाइल बनाएँ। यह वह संदर्भ है जिसे Slate हर सत्र की शुरुआत में पढ़ता है।

1# AGENTS.md
2
3## What this codebase does
4[One paragraph description of the project]
5
6## Architecture
7- src/api/ — Express API routes
8- src/services/ — Business logic
9- src/db/ — Database models (PostgreSQL via Prisma)
10- tests/ — Jest test suite
11
12## Key commands
13- npm test — run the full test suite
14- npm run build — TypeScript compile
15- npm run lint — ESLint check
16- npm run typecheck — tsc --noEmit
17
18## Rules
19- Never modify src/billing/ or src/auth/ without human approval
20- Always run tests before marking any task complete
21- Use the existing error handling pattern in src/utils/errors.ts
22
23## Environment
24- .env.slate contains all env vars Slate needs

Slate स्टार्टअप पर इस फ़ाइल को स्वचालित रूप से पढ़ता है — हर सत्र में इसे पेस्ट करने की आवश्यकता नहीं है।

Slate के अंदर अपनी कार्यक्षेत्र निर्देशिकाएँ जोड़ें:

1/workspace add ./src
2/workspace add ./tests
3/workspace list

या @ उल्लेखों का उपयोग करके इनलाइन विशिष्ट फ़ाइलों को संदर्भित करें:

1कृपया @src/api/routes.ts की समीक्षा करें और सुधार सुझाएँ

चरण 2 — Slate कॉन्फ़िगर करें

अपने प्रोजेक्ट रूट में slate.json बनाएँ ताकि Slate के व्यवहार को नियंत्रित किया जा सके।

1{
2  "$schema": "https://randomlabs.ai/config.json",
3  "permission": {
4    "*": "allow",
5    "bash": "ask"
6  },
7  "models": {
8    "main": { "default": "anthropic/claude-opus-4.6" },
9    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
10    "search": { "default": "anthropic/claude-haiku-4.5" },
11    "reasoning": { "default": "openai/gpt-5.6" }
12  }
13}

यह क्या करता है:

→ "*": "allow" — Slate हर बार पूछे बिना फ़ाइलें पढ़ और लिख सकता है

→ "bash": "ask" — Slate शेल कमांड चलाने से पहले पूछता है (इसे तब तक चालू रखें जब तक आपको इस पर भरोसा न हो)

→ Models config — खोज के लिए सस्ता तेज़ मॉडल, मुख्य तर्क के लिए महंगा मॉडल

CI या स्वचालन रन के लिए जहाँ आप शून्य प्रॉम्प्ट चाहते हैं:

1slate run "Run the test suite and fix any failures" --dangerously-skip-permissions --output-format stream-json

चरण 3 — आपका पहला कार्य (अभी लूप नहीं)

लूप बनाने से पहले, एक एकल मैन्युअल रन विश्वसनीय बनाएँ।

यह सबसे छोड़ा गया कदम है। और इसका कारण है कि अधिकांश लूप उत्पादन में विफल होते हैं।

Slate को एक वास्तविक कार्य दें:

1कृपया मेरे पूरे कोडबेस की आर्किटेक्चर की समीक्षा करें।
2ARCH.md बनाएँ जिसमें शामिल हो:
3- वर्तमान संरचना
4- मॉड्यूलों के बीच निर्भरताएँ
5- सुधार के लिए 3 चीज़ें
6पहले @src/ देखें, फिर @tests/

Slate को काम करते देखें। यह:

1. आपकी फ़ाइलों में खोज करेगा
2. आर्किटेक्चर की समझ बनाएगा
3. ARCH.md का ड्राफ्ट तैयार करेगा
4. रुकने से पहले आपके अनुरोध के विरुद्ध इसकी समीक्षा करेगा

यह पहले से ही एक मिनी-लूप है — यह समाप्त करने से पहले अपने स्वयं के आउटपुट की जाँच करता है।

एक लंबे कार्य के लिए:

1नमस्ते Slate, प्रमाणीकरण प्रवाह के लिए मेरे कोडबेस पर शोध करें,
2फिर OAuth2 समर्थन जोड़ने की योजना बनाएँ।
3सुनिश्चित करें कि आप @src/auth/ और @src/api/routes.ts देखें

Slate एक योजना लौटाता है। आप उस पर पुनरावृत्ति करते हैं:

1नहीं, एक नया auth प्रदाता वर्ग न जोड़ें।
2इसे src/auth/api-key.ts में मौजूदा ApiKeyAuth के समान पैटर्न का पालन करने दें

योजना को स्वीकृत करें। Slate स्वायत्त रूप से निष्पादित करता है।

चरण 4 — एक स्किल बनाएँ (लूप को पुन: प्रयोज्य बनाएँ)

एक स्किल वह तरीका है जिससे आप हर सत्र में अपने प्रोजेक्ट को फिर से समझाना बंद करते हैं।

इसे एक बार लिखें। Slate इसे हर प्रासंगिक रन पर पढ़ता है।

फ़ोल्डर संरचना बनाएँ:

1mkdir -p .slate/skills/ci-triage
2touch .slate/skills/ci-triage/SKILL.md

स्किल लिखें:

1---
2name: "ci-triage"
3description: "Classify CI failures by root cause and draft fixes for the easy ones."
4---
5
6# CI Triage Skill
7
8## What I do
9When a CI run fails, I:
101. Read the test output
112. Classify the failure: env issue / flaky test / real bug / dependency bump / infra
123. Draft fixes for bugs and dependency issues
134. Escalate env and infra issues to humans
14
15## Classification rules
16- env: missing secret, wrong env var → flag for human
17- flake: passes on retry without code change → retry once, then file issue
18- bug: deterministic failure tied to recent commit → draft fix
19- dependency: failure tied to version bump → draft rollback PR
20- infra: timeout, OOM, runner issue → escalate immediately
21
22## Fix patterns
23- Auth test failures → check src/auth/middleware.ts first
24- Database test failures → verify migration ran in CI env
25- E2E failures → check UI selectors against latest snapshot
26
27## Never do
28- Disable failing tests
29- Modify CI config without asking
30- Touch src/billing/ or src/payments/
31
32## State
33Update STATE.md after every run:
34- Files checked
35- Classifications made
36- PRs opened
37- Items escalated

Slate के अंदर उपलब्ध स्किल्स सूचीबद्ध करें:

1/skills

एक को मैन्युअल रूप से सक्रिय करें:

1@ci-triage कृपया आज के विफल परीक्षणों का ट्राइएज करें

या Slate स्वचालित रूप से स्किल्स को सक्रिय करता है जब वह तय करता है कि वे वर्तमान कार्य के लिए प्रासंगिक हैं।

चरण 5 — स्थिति जोड़ें (लूप की मेमोरी)

एजेंट भूल जाता है।

फ़ाइल नहीं भूलती।

अपने प्रोजेक्ट रूट में STATE.md बनाएँ:

1# Loop State — CI Triage
2
3## Last run
42026-06-28 03:30 UTC — 7 failures classified, 3 fixes drafted, 4 escalated
5
6## In progress
7- claude/fix-auth-token-refresh — tests passing locally, awaiting CI
8- claude/fix-flaky-payment-webhook — retry pattern applied, monitoring
9
10## Completed
11- claude/bump-axios-1.7.4 → merged (CI green)
12- claude/lint-fix-pass-june-28 → merged
13
14## Escalated to humans
15- src/billing/refund.ts — tests failing in 3 ways, root cause unclear
16- ci/staging-runner — infra timeouts, not a code issue
17
18## Lessons learned
19- 2026-06-27: PowerShell hits TLS 1.2 issue on this Windows runner. Use bash.
20- 2026-06-26: tests/e2e/checkout requires Stripe webhook secret in env. Skip if missing.

Slate को हर सत्र की शुरुआत में इसका उपयोग करने के लिए कहें, AGENTS.md में जोड़कर:

1## Session start
2Always read STATE.md first. Pick up where the last run stopped.
3Update STATE.md at the end of every run with what was done and what is next.

स्थिति के बिना: हर रन शून्य से शुरू होता है।

स्थिति के साथ: हर रन फिर से शुरू होता है और पिछले पर संचित होता है।

चरण 6 — वास्तविक लूप बनाएँ

अब आपके पास है:

→ कार्यक्षेत्र सेट (AGENTS.md)

→ कॉन्फ़िग सेट (slate.json)

→ एक विश्वसनीय मैन्युअल रन सिद्ध

→ एक स्किल लिखित (ci-triage)

→ स्थिति फ़ाइल बनाई (STATE.md)

इसे एक वास्तविक लूप में लपेटने का समय है।

विकल्प A: क्यू फ़ाइल लूप (सबसे सरल)

loop.md बनाएँ:

1Read STATE.md to understand what was already tried.
2
3Run the CI triage skill across all failing tests in the last build.
4
5For each failure:
6- Classify it using the ci-triage skill rules
7- Draft a fix for bugs and dependency issues
8- Escalate env and infra issues
9
10Run the fixes. Check if tests pass.
11If tests pass → open PR.
12If tests still fail → record in STATE.md and stop.
13
14Update STATE.md with everything done this run.
15
16Hard stop: 8 attempts maximum. On limit, report current state.

इसे चलाएँ:

1slate --queue loop.md

Slate क्यू फ़ाइल पढ़ता है और प्रत्येक ब्लॉक को क्यू किए गए संदेश के रूप में चलाता है।

विकल्प B: हेडलेस/CI लूप (स्वचालित)

GitHub Action या cron जॉब में गैर-इंटरैक्टिव रूप से चलाएँ:

1slate run "$(cat loop.md)" --output-format stream-json --dangerously-skip-permissions

GitHub Actions वर्कफ़्लो में:

1name: CI Triage Loop
2on:
3  workflow_run:
4    workflows: ["CI"]
5    types: [completed]
6
7jobs:
8  triage:
9    if: ${{ github.event.workflow_run.conclusion == 'failure' }}
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Install Slate
15        run: npm i -g @randomlabs/slate
16
17      - name: Run triage loop
18        env:
19          SLATE_API_KEY: ${{ secrets.SLATE_API_KEY }}
20        run: |
21          slate run "$(cat loop.md)" \
22            --output-format stream-json \
23            --dangerously-skip-permissions \
24            --workspace ./src \
25            --workspace ./tests

अब हर CI विफलता स्वचालित रूप से ट्राइएज लूप को ट्रिगर करती है।

एस्केलेशन तक किसी मानव की आवश्यकता नहीं है।

चरण 7 — सब-एजेंट जोड़ें (मेकर-चेकर विभाजन)

किसी भी लूप में सबसे महत्वपूर्ण संरचनात्मक सुधार।

कभी भी उसी एजेंट को अपना खुद का होमवर्क ग्रेड न करने दें।

जिस मॉडल ने फिक्स लिखा है, वह बहुत उदार ग्रेडर है।

Slate में, आप विभिन्न भूमिकाओं के लिए अलग-अलग मॉडल सेट कर सकते हैं:

1{
2  "models": {
3    "main": { "default": "anthropic/claude-opus-4.6" },
4    "subagent": { "default": "anthropic/claude-sonnet-4.6" },
5    "search": { "default": "anthropic/claude-haiku-4.5" }
6  }
7}

फिर अपना कार्य इस तरह लिखें कि Slate स्वाभाविक रूप से इस विभाजन का उपयोग करे:

1कृपया विफल प्रमाणीकरण परीक्षणों को ठीक करें।
2
3चरण 1: एक खोज एजेंट को src/auth/ का पता लगाने दें ताकि वर्तमान कार्यान्वयन को समझ सके।
4चरण 2: एक अलग एजेंट को जो मिला उसके आधार पर फिक्स लागू करने दें।
5चरण 3: एक तीसरे एजेंट को मूल परीक्षण आवश्यकताओं के विरुद्ध फिक्स को सत्यापित करने दें —
6        इस एजेंट को कार्यान्वयन नहीं देखना चाहिए।
7चरण 4: केवल PR खोलें यदि सत्यापनकर्ता स्वीकृत करता है।

Slate स्वचालित रूप से सबएजेंटों का ऑर्केस्ट्रेशन करता है।

खोज एजेंट एक तेज़ सस्ता मॉडल का उपयोग करता है। कार्यान्वयन एजेंट एक मजबूत मॉडल का उपयोग करता है। सत्यापनकर्ता एक सख्त मॉडल का उपयोग करता है जिसकी निर्माता के तर्क तक पहुँच नहीं है।

यह विभाजन ही कारण है कि Slate एक ही कार्य पर 5 समानांतर सबएजेंट चला सकता है — प्रत्येक विशिष्ट, प्रत्येक पृथक।

चरण 8 — स्थिति लूप पैटर्न (लंबे समय तक चलने वाले कार्यों के लिए)

उन कार्यों के लिए जो घंटों या दिनों तक चलते हैं, अपने कार्य प्रॉम्प्ट में इस पैटर्न का उपयोग करें:

1आप एक बहु-सत्र लूप चला रहे हैं।
2
3GOAL: सभी Express रूट्स को नए ApiError पैटर्न में माइग्रेट करें।
4STATE.md में प्रगति ट्रैक करें।
5
6हर सत्र की शुरुआत:
71. STATE.md पढ़ें
82. "Remaining routes" में पहली अपूर्ण वस्तु खोजें
93. केवल वही वस्तु करें
10
11हर सत्र का अंत:
121. STATE.md में पूर्ण वस्तुओं को "Done routes" में ले जाएँ
132. किसी भी ब्लॉकर को "Blockers" में रिकॉर्ड करें
143. "Last run" टाइमस्टैम्प अपडेट करें
154. साफ़-साफ़ रुकें
16
17STATE.md प्रारूप:
18---
19## Done routes
20- [x] /api/users (2026-06-27)
21- [x] /api/auth/login (2026-06-28)
22
23## Remaining routes
24- [ ] /api/payments/checkout
25- [ ] /api/payments/refund
26- [ ] /api/admin/users
27
28## Blockers
29- /api/payments/refund — requires human review (touches billing logic)
30
31## Last run
322026-06-28 14:30 UTC
33---
34
35सख्त नियम:
36- मानव अनुमोदन के बिना src/billing/ को कभी न छुएँ
37- प्रत्येक रूट माइग्रेशन के बाद हमेशा परीक्षण चलाएँ
38- प्रति सत्र एक रूट पूरा करने के बाद रुकें

इसे हर सुबह चलाएँ:

1slate --continue "$(cat loop.md)"

--continue नए सिरे से शुरू करने के बजाय सबसे हाल के सत्र को उठाता है।

हर दिन, एक और रूट। STATE.md सब कुछ ट्रैक करता है।

लूप ठीक वहीं से शुरू होता है जहाँ वह रुका था।

चरण 9 — आपके सबसे अधिक उपयोग किए जाने वाले लूप के लिए कस्टम कमांड

slate.json में कस्टम स्लैश कमांड जोड़ें ताकि आपके लूप हमेशा एक कीस्ट्रोक दूर हों:

1{
2  "command": {
3    "triage": {
4      "description": "Run CI triage loop",
5      "template": "Read STATE.md. Run the ci-triage skill on all failing tests. Update STATE.md when done.",
6      "agent": "build"
7    },
8    "review": {
9      "description": "Review a file for correctness",
10      "template": "Review @$ARGUMENTS for correctness, edge cases, and consistency with surrounding code."
11    },
12    "migrate": {
13      "description": "Migrate one route to ApiError pattern",
14      "template": "Read STATE.md. Migrate the next incomplete route to ApiError pattern. Run tests. Update STATE.md."
15    }
16  }
17}

अब Slate के अंदर:

1/triage
2/review src/api/payments.ts
3/migrate

प्रत्येक आपके पूर्व-लिखित लूप प्रॉम्प्ट को तुरंत चलाता है।

3 पूर्ण लूप जिन्हें आप आज चला सकते हैं

लूप 1: CI विफलता ट्राइएज (जो हमने बनाया)

कब: हर CI विफलता पर क्या: वर्गीकृत करें → आसान को ठीक करें → कठिन को एस्केलेट करें → PR खोलें स्थिति: STATE.md गेट: परीक्षण पास सेटअप का समय: 30 मिनट

1# trigger
2slate run "$(cat loop.md)" --dangerously-skip-permissions --output-format stream-json
3
4# or in GitHub Actions — see Step 6 above

लूप 2: सुबह का ब्रीफ़

कब: हर कार्यदिवस सुबह 7 बजे (cron जॉब) क्या: पिछले 24 घंटों के कमिट, PR, और खुले मुद्दों को स्कैन करें → 5-बुलेट ब्रीफ़ लिखें → Slack पर पोस्ट करें

1# loop.md for morning brief
2cat > morning-brief-loop.md << 'EOF'
3Read the last 24 hours of:
4- git log --since="24 hours ago" --oneline
5- Open PRs in draft or review
6- GitHub Issues opened or updated in the last 24h
7
8Write a morning brief:
9- 3 most important things that happened
10- 2 things that need attention today
11- 1 thing at risk of blocking someone
12
13Keep it under 120 words. Post to the #engineering Slack channel.
14EOF
15
16# run on a schedule with cron
170 7 * * 1-5 slate run "$(cat morning-brief-loop.md)" --dangerously-skip-permissions

लूप 3: डिपेंडेंसी बंप लूप

कब: हर सोमवार क्या: पुराने पैकेजों के लिए स्कैन करें → संगतता का परीक्षण करें → सुरक्षित बंप के लिए PR खोलें

1cat > deps-loop.md << 'EOF'
2Read STATE.md.
3
4Run: npm outdated
5
6For each outdated package:
71. Check if the version bump is major (breaking) or minor/patch (safe)
82. For minor/patch: update the package, run npm test
93. If tests pass: open a PR
104. If tests fail: record in STATE.md as "needs human review"
115. For major bumps: always escalate to humans
12
13Hard rules:
14- Never bump more than 5 packages in a single loop
15- Never bump packages in the "peer dependencies" section
16- Always run the full test suite after each bump, not just related tests
17
18Update STATE.md with what was bumped and what was escalated.
19EOF
20
21# run every Monday
220 9 * * 1 slate run "$(cat deps-loop.md)" --dangerously-skip-permissions

विफलता मोड जो पैसा खर्च करते हैं

कुछ भी शेड्यूल करने से पहले इन्हें जानें।

राल्फ विगम लूप

एजेंट आधे-अधूरे काम पर पूर्ण घोषित करता है।

जल्दी बाहर निकलता है। लूप खर्च करता रहता है। चुपचाप।

फिक्स: एक ताज़ा मॉडल द्वारा जाँच की गई हार्ड स्टॉप शर्त।

1STOP CONDITION: All tests in tests/auth/ pass AND lint returns 0.
2Verify using a separate check run, not the agent's own judgment.
3Hard limit: 8 iterations. On limit: report state and stop.

लक्ष्य भटकाव

लंबे सत्रों पर, शुरुआती बाधाएँ गायब हो जाती हैं।

"src/billing/ को कभी न छुएँ" संदेश 3 से संदेश 47 तक चला जाता है।

फिक्स: एक VISION.md जोड़ें जिसे Slate हर सत्र की शुरुआत में फिर से पढ़ता है।

1# VISION.md — Read at start of every session
2
3## Core goal
4Migrate all Express routes to ApiError pattern.
5
6## Hard constraints (never violate)
7- Never touch src/billing/ without human approval
8- Never disable failing tests
9- Always run full test suite before opening any PR
10
11## Current priority
12Routes in src/api/payments/ — handle with extra care

स्व-पक्षपात

निर्माता अपना खुद का होमवर्क ग्रेड करता है। हमेशा खुद को पास देता है।

फिक्स: सत्यापनकर्ता सबएजेंट जिसकी निर्माता के तर्क तक शून्य पहुँच है।

Slate को स्पष्ट रूप से बताएँ:

1सत्यापनकर्ता एजेंट को कार्यान्वयन एजेंट का काम नहीं देखना चाहिए।
2उसे केवल देखना चाहिए: मूल परीक्षण आवश्यकताएँ और परीक्षण आउटपुट।
3यदि परीक्षण पास होते हैं → स्वीकृत करें। यदि परीक्षण विफल होते हैं → अस्वीकृत करें। अन्यथा कोई राय नहीं।

एजेंटिक आलस्य

लूप आंशिक पूर्णता पर कार्य को "पर्याप्त रूप से पूर्ण" कहता है।

विशेष रूप से अस्पष्ट सफलता मानदंडों पर।

फिक्स: केवल वस्तुनिष्ठ स्टॉप शर्त।

1DONE WHEN: npm test returns exit code 0 AND npm run lint returns exit code 0.
2Not when "tests look good." Not when "most tests pass."
3Exit code 0 on both commands. That is the only done.

Slate-विशिष्ट ट्रिक्स जो मायने रखते हैं

कुछ चीज़ें जो व्यवहार में Slate को अन्य एजेंटों से अलग बनाती हैं।

काम करते समय संदेशों को क्यू करना

Slate एक लंबा कार्य चला रहा है। आपको कुछ महत्वपूर्ण याद आता है।

संदेश को क्यू करने के लिए Tab दबाएँ — यह वर्तमान कार्य समाप्त होने के बाद चलता है, उसे बाधित नहीं करता।

1[Slate is working on migration task...]
2
3आप: वास्तव में, सुनिश्चित करें कि नया पैटर्न उस मामले को भी संभालता है जहाँ userId null है
4[Tab — queued]
5
6[Slate वर्तमान चरण समाप्त करता है, फिर आपका क्यू किया गया संदेश पढ़ता है]

मध्य-रन में स्टीयरिंग

यदि Slate गलत दिशा में जा रहा है, तो आपको इसे रोकने की आवश्यकता नहीं है:

1[Slate is halfway through implementing the fix...]
2
3आप: रुको — इसके लिए नया वर्ग न जोड़ें। src/utils/errors.ts में मौजूदा BaseError का उपयोग करें
4[Enter — steers immediately]
5
6Slate: समझ गया, BaseError का उपयोग करने के लिए दृष्टिकोण बदल रहा हूँ...

/enter-mode-next का उपयोग करके स्टीयर / क्यू / इंटरप्ट मोड के बीच चक्र करें।शेल कमांड सीधे

दूसरे टर्मिनल पर स्विच किए बिना Slate सत्र के अंदर कमांड चलाएँ:

1!npm test          # run tests and send output to Slate
2!git diff HEAD     # check what changed
3!git status        # see current state

Slate आउटपुट पढ़ता है और अपनी अगली कार्रवाई में इसका उपयोग करता है।

टीम सेटअप के लिए सर्वर मोड

Slate को सर्वर के रूप में चलाएँ और कई टर्मिनलों से इससे जुड़ें:

1# Terminal 1 — start server
2slate serve --port 7777
3
4# Terminal 2 — attach TUI
5slate attach http://localhost:7777 --dir /path/to/project

Slate के साथ पेयर-प्रोग्रामिंग या इसे रिमोट मशीन पर चलाने के लिए उपयोगी।

पूर्ण सेटअप चेकलिस्ट

अपना पहला वास्तविक लूप चलाने से पहले:

1□ npm i -g @randomlabs/slate installed
2□ AGENTS.md created with project overview, commands, rules
3□ slate.json created with permissions and model config
4□ One manual run completed and verified reliable
5□ SKILL.md written for your first repeated task
6□ STATE.md created and referenced in AGENTS.md
7□ loop.md written with explicit stop condition
8□ Hard limit on iterations (8 max to start)
9□ Verifier is NOT the same agent as the maker
10□ Human review gate on any irreversible action (PRs, deploys)

कुछ भी शेड्यूल करने से पहले हर बॉक्स चेक करें।

एक को छोड़ें और लूप या तो चुपचाप विफल होता है या आपको कुछ नहीं के लिए बिल करता है।

अधिक लूप प्रेरणा के लिए

एक बार जब आप पैटर्न समझ जाते हैं, तो बाधा "लूप कैसे बनाऊं" से बदलकर "अब मैं कौन सा लूप बनाऊं" हो जाती है।

Forward Future Loop Library signals.forwardfuture.com/loop-library पर वास्तविक चल रहे लूप्स को श्रेणियों में देखने के लिए एक अच्छी जगह है — कंटेंट, इंजीनियरिंग, ऑपरेशंस, रिसर्च।

जब आप एक जगह पर 20 काम कर रहे लूप्स देखते हैं, तो आप एक-बार के प्रॉम्प्ट में सोचना बंद कर देते हैं।

असुविधाजनक सच्चाई

दो बिल्डर एक ही लूप को चला सकते हैं और विपरीत परिणाम पा सकते हैं।

एक इसका उपयोग उस काम को तेजी से करने के लिए करता है जिसे वह पहले से ही गहराई से समझता है।

दूसरा इसका उपयोग काम को बिल्कुल भी समझने से बचने के लिए करता है।

लूप को यह फर्क नहीं पता होता।

आपको पता होता है।

लूप डिज़ाइन प्रॉम्प्ट इंजीनियरिंग से कठिन है — आसान नहीं।

मुद्दा यह नहीं है कि काम आसान हो गया।

लीवरेज पॉइंट शिफ्ट हो गया।

लूप बनाएं।

लेकिन इसे ऐसे बनाएं जैसे कोई इंजीनियर बने रहने का इरादा रखता हो।

सिर्फ वह व्यक्ति नहीं जो 'गो' दबाता है।

और नया GPT-5.6 इस सिद्धांत को नहीं बदलता है। अगर कुछ है, तो यह इसे मजबूत करता है।

अब सीमा यह नहीं है कि कौन सबसे चतुर प्रॉम्प्ट लिखता है।

यह है कि कौन तेजी से सक्षम हो रहे मॉडलों के आसपास सबसे अच्छे सिस्टम डिज़ाइन करता है।

60 सेकंड का सारांश

लूप क्या है:

→ प्रॉम्प्ट = प्रश्न। लूप = नौकरी।

→ खोजें → निष्पादित करें → सत्यापित करें → दोहराएं → रुकें

4-शर्त परीक्षण:

→ कार्य दोहराया जाता है / सत्यापन स्वचालित है / बजट अपशिष्ट को अवशोषित करता है / 'हो गया' वस्तुनिष्ठ है

5 सेटअप चरण:

→ AGENTS.md → slate.json → एक मैनुअल रन → SKILL.md → STATE.md

फिर इसे लपेटें:

→ loop.md क्यू फ़ाइल या CI में हेडलेस स्लेट रन

विफलता के तरीके:

→ राल्फ विगम (जल्दी बाहर निकलता है) / लक्ष्य भटकाव (बाधाओं को भूल जाता है) / स्व-पसंद पूर्वाग्रह (निर्माता = परीक्षक) / एजेंटिक आलस्य (काफी हो गया)

Slate का लाभ:

→ प्रति चरण स्वचालित मॉडल चयन → अलगाव के साथ समानांतर उप-एजेंट → लंबे सत्र प्रबंधन → आपका लूप, आपका डिज़ाइन

अगर यह उपयोगी लगा:

→ इसे हर उस बिल्डर के साथ साझा करने के लिए रिपोस्ट करें जिसे आप जानते हैं

→ इस तरह के और सिस्टम के लिए @sairahul1 को फॉलो करें

→ इसे बुकमार्क करें — अकेला सेटअप चेकलिस्ट ही सेव करने लायक है

ऐसे और दिलचस्प लेखों के लिए theaibuilders.co पर सब्सक्राइब करें

मैं AI, उत्पाद बनाने, और ऐसे सिस्टम के बारे में लिखता हूं जो आपके सोते समय चलते हैं।

उल्लेखित उपकरण:

→ Slate डॉक्स: docs.randomlabs.ai

→ Forward Future Loop Library: signals.forwardfuture.com/loop-library