AI को "बस सब संभाल लो" कहना हादसे को न्योता है। काम सौंपने का "ढाँचा" कैसे बनाएँ

“इस रिपॉज़िटरी को ज़रा ठीक-ठाक करके सजा दो।”

ऐसा कहने के अगली सुबह, AI ने “ठीक-ठाक” करते हुए 40 फ़ाइलें बदल डाली थीं। चलने वाला कोड भी था, सही-सलामत। लेकिन जिन सेटिंग फ़ाइलों को छूना भी ख़तरनाक था, उन्हें भी उसने झाड़-पोंछकर “सजा” दिया था।

ऐसा कलेजा मुँह को आ जाने वाला अनुभव आपको कभी हुआ है?

जो AI इतना समझदार माना जाता है, वह आँख मूँदकर हादसे कैसे कर बैठता है? वजह बहुत सीधी है: “समझदार होना” और “सुरक्षित ढंग से काम कर पाना” बिल्कुल अलग चीज़ें हैं। परीक्षा में पूरे नंबर लाने वाला, पर पहली ही नौकरी के दिन कैश काउंटर तोड़ देने वाला नया लड़का। बात ठीक वैसी ही है। दिक्कत काबिलियत की नहीं, ढाँचे की है।

उस ढाँचे को आजकल हार्नेस (harness) कहते हैं। आज इसी को, भारी-भरकम तकनीकी शब्दों से जितना हो सके बचते हुए, समझाता हूँ।

हार्नेस आख़िर है क्या?

हार्नेस एक छोटा-सा प्रोग्राम है, जिसे AI के “बाहर” रखा जाता है।

समझना हो तो सोचिए—बिल्डिंग बनाते मज़दूर की कमर में बँधा सुरक्षा बेल्ट, या बच्चे की साइकिल में लगे सहायक पहिए। इंसान की काबिलियत तो वही रहती है, बस वह गिरता नहीं—यही इंतज़ाम है। AI के लिहाज़ से इसके काम कुछ ऐसे हैं:

• क्या-क्या पढ़ने देना है, यह तय करना (सब कुछ नहीं दिखाना)
• क्या बनवाना है, यह तय करना (मंज़िल साफ़ रखना)
• कहाँ तक अपने मन से करने देना है और कहाँ इंसान से पूछवाना है, यह तय करना
• जो बन गया वह टूटा तो नहीं, इसकी मशीनी जाँच करना

“अच्छा प्रॉम्प्ट लिखना” इस पूरे खेल का बस एक छोटा हिस्सा है। सिर्फ़ प्रॉम्प्ट चमकाते रहने से हादसे कम नहीं होते—यह तो सहायक पहियों के बिना एकपहिया साइकिल चलाने की प्रैक्टिस करने जैसा है।

अभी इस पर इतना शोर क्यों मचा है?

कुछ ही समय पहले तक AI से हम बस इतना माँगते थे—“यह लिख दो”, “यह कोड बना दो”। जो निकलकर आता, उसे इंसान पढ़कर फ़ैसला कर लेता। बस।

लेकिन अब हम AI को काम ही सौंपने लगे हैं। फ़ाइल पढ़ना, पुराने लेखों से न टकराने वाला नया विषय चुनना, बदलाव जाँचना, किसी बाहरी सेवा पर रजिस्टर करना, फ़ेल होने पर वजह बताना—यहाँ तक आते-आते बीच में हर बार इंसान नहीं रहता। इसीलिए “अपने आप करके हादसा कर बैठने” का ख़तरा एकदम से बढ़ गया।

Claude Code की वाहवाही भी इसलिए नहीं कि उसका मॉडल बहुत समझदार है, बल्कि इसलिए कि उसका यह ढाँचा बढ़िया बना है। फ़ाइल पढ़ने का औज़ार, खोजने का औज़ार, ख़तरनाक काम रोकने का इंतज़ाम, प्रोजेक्ट के नियम याद रखवाने का इंतज़ाम। यही “बेरंग-सा आसपास” मज़बूत है। चल रहा है कोई जादुई प्रॉम्प्ट नहीं, बल्कि वही बेरंग-सा आसपास।

पहले चलाकर देखें: 30 लाइन का सबसे छोटा हार्नेस

समझाने से अच्छा है चला लेना। AI को सिर्फ़ “पढ़ना-लिखना” करने दें, और तय फ़ोल्डर के बाहर हाथ बिल्कुल न लगाने दें—ऐसा सबसे छोटा ढाँचा बनाते हैं। Node.js और Anthropic की API key हो तो यह चल जाएगा।

पहले तैयारी।

mkdir harness-demo && cd harness-demo
npm init -y
npm install @anthropic-ai/sdk
mkdir sandbox
echo "# नोट" > sandbox/note.md

अब “अनुमति की सूची” लिखते हैं। यही हार्नेस का दिल है। ऐलान यह है कि sandbox के बाहर छूने नहीं देना।

{
  "workspace": "./sandbox",
  "maxSteps": 6
}

और अब असली चीज़ (harness.mjs)। याद बस एक जगह रखनी है। safePath ही वह दरबान है जो “फ़ोल्डर के बाहर निकलने की कोशिश पर रोक देता है”। बस इतना भर होने से, शुरुआत वाला “40 फ़ाइल हादसा” होता ही नहीं।

import Anthropic from "@anthropic-ai/sdk";
import { readFile, writeFile } from "node:fs/promises";
import path from "node:path";

const client = new Anthropic();
const policy = JSON.parse(await readFile(new URL("./policy.json", import.meta.url), "utf8"));
const root = path.resolve(policy.workspace);

// दरबान: काम के फ़ोल्डर से बाहर निकलने की कोशिश हो, तो वहीं रोक दो
function safePath(p) {
  const resolved = path.resolve(root, p);
  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
    throw new Error(`${p} काम के फ़ोल्डर के बाहर है। सिर्फ़ sandbox के अंदर ही छू सकते हैं।`);
  }
  return resolved;
}

const tools = [
  { name: "read_file", description: "sandbox के अंदर का टेक्स्ट पढ़ना",
    input_schema: { type: "object", properties: { path: { type: "string" } }, required: ["path"] } },
  { name: "write_file", description: "sandbox के अंदर टेक्स्ट लिखना",
    input_schema: { type: "object", properties: { path: { type: "string" }, content: { type: "string" } }, required: ["path", "content"] } },
];

async function useTool(name, input) {
  if (name === "read_file") return await readFile(safePath(input.path), "utf8");
  if (name === "write_file") { await writeFile(safePath(input.path), input.content, "utf8"); return "लिख दिया, ठीक है"; }
  throw new Error(`अनजाना औज़ार: ${name}`);
}

const messages = [{ role: "user", content: process.argv.slice(2).join(" ") || "note.md पढ़कर उसका सार summary.md में लिख दो।" }];

for (let step = 0; step < policy.maxSteps; step++) {
  const res = await client.messages.create({
    model: process.env.ANTHROPIC_MODEL || "claude-sonnet-4-6",
    max_tokens: 1024,
    tools,
    system: "तुम एक सावधान फ़ाइल-सहायक हो। ज़रूरत पड़ने पर ही औज़ार इस्तेमाल करो, और काम sandbox के अंदर ही करो।",
    messages,
  });
  messages.push({ role: "assistant", content: res.content });

  const calls = res.content.filter((b) => b.type === "tool_use");
  if (calls.length === 0) { console.log(res.content.find((b) => b.type === "text")?.text ?? ""); break; }

  const results = [];
  for (const c of calls) {
    try { results.push({ type: "tool_result", tool_use_id: c.id, content: String(await useTool(c.name, c.input)).slice(0, 4000) }); }
    catch (e) { results.push({ type: "tool_result", tool_use_id: c.id, is_error: true, content: e.message }); }
  }
  messages.push({ role: "user", content: results });
}

चलाना बस इतना।

node harness.mjs

बस चंद दर्जन लाइनें हैं, पर इनमें ही “AI का असली दिमाग”, “जो औज़ार दिए हैं”, “अनुमति का दायरा”, “दोबारा कोशिश की हद”, और “टूटने पर रुक जाने का इंतज़ाम”—सब अलग-अलग बँट चुके हैं। यही हार्नेस का ढाँचा है। आगे इसी में खोज, टेस्ट चलाना, मंज़ूरी का इंतज़ार और सूचना जोड़ते जाइए, तो यह धीरे-धीरे Claude Code जैसी शक्ल ले लेता है।

ऐसी जगहों पर यह काम का है (तीन उदाहरण)

1. लेख या दस्तावेज़ की ‘थोक जाँच’ “ब्लॉग लिख दो” कहकर छोड़ दें, तो AI बेधड़क पतले-फीके लेख या “लगभग एक जैसे विषय” थोक में बना डालता है। तो हार्नेस को सिलसिला थमा दीजिए—“पुराने शीर्षक पढ़ो → न टकराने वाला नज़रिया चुनो → लेख लिखो → शब्दों की गिनती और लिंक की मशीनी जाँच करो”। फिर अच्छा-बुरा सोचकर इंसान के सिर खपाने से पहले ही दरबान पतले लेख को बाहर कर देता है। मेरे यहाँ तो इससे महीने में कई ड्राफ्ट छपने से पहले ही रुक जाते हैं। रुक गए, इसका शुक्र—बस यही भाव रहता है।

2. पूछताछ की छँटाई “जो पूछताछ आई है उसे पढ़ो, और सिर्फ़ वे बताओ जो सौदे में बदल सकती हैं।” पढ़ना अपने आप हो, चलेगा। लेकिन ग्राहक सूची में दर्ज करना इंसान के बटन दबाने तक रोके रखो। यह हार्नेस से ज़बरदस्ती करवाते हैं। पढ़ना अपने आप, लिखना सिर्फ़ ड्राफ्ट (dry-run), और आख़िरी दर्ज इंसान। ग़लत छँटाई हुए ग्राहक को असली डेटाबेस में अपने आप ठूँस देने का हादसा, इससे ख़त्म हो जाता है।

3. डिप्लॉय से पहले एक गहरी साँस पब्लिश का बटन दबाने से पहले—बिल्ड पास होता है या नहीं, environment variables पूरे हैं या नहीं, बदलाव वैसा ही है जैसा सोचा था या नहीं, वापस लौटने का तरीका है या नहीं—यह सब ज़रूर जँचवाइए। AI फ़ेल हुई लॉग की “आख़िरी लाइन” भर देखकर ग़लत जगह पकड़कर सुधार बैठता है, इसलिए “कहाँ देखना है” पहले ही तय कर देना ही असली तरकीब है। लॉग पूरी मत थमाइए, सिर्फ़ काम की चंद दर्जन लाइनें। इतने भर से बेतुके सुधार बहुत घट जाते हैं।

Claude Code से ‘चुराने’ लायक तीन डिज़ाइन

ख़ुद हार्नेस बनाते वक़्त, शून्य से सोचने की ज़रूरत नहीं। Claude Code नमूनों का ख़ज़ाना है। सब कुछ नकल करने की ज़रूरत नहीं, बस ये तीन चीज़ें जल्दी अपना लें तो एकदम स्थिरता आ जाती है।

पहली—नियमों को परतों में बाँटना। हर बार न बदलने वाले वादे सेटिंग फ़ाइल में, सिर्फ़ इस बार के निर्देश उसी वक़्त की नोट में, और देर तक काम आने वाली पसंद किसी और जगह। सब कुछ हर बार प्रॉम्प्ट में लिखेंगे तो वह लंबा होकर सटीकता खो देता है।

दूसरी—पक्के, तय किस्म के काम कमांड के हवाले करना। फ़ॉर्मेटिंग, जाँच, टेस्ट—AI से माँगने के बजाय npm test जैसी कमांड से चलाना तेज़ भी है और पक्का भी। AI के पास सिर्फ़ “सोचने” का काम छोड़िए।

तीसरी—भारी खोजबीन किसी और के सिर डालना। लंबी लॉग और ढेरों फ़ाइलें मुख्य बातचीत में उँडेल देंगे, तो असली फ़ैसला धुँधला पड़ जाता है। शुरुआती जाँच किसी अलग प्रोसेस से करवाइए और सिर्फ़ नतीजा लीजिए। इतने भर से फ़ैसले की धार वापस आ जाती है।

मेरी अपनी तीन ग़लतियाँ

सच बता दूँ। मेरा पहला हार्नेस हादसों से भरा था।

पहली—औज़ार ज़रूरत से ज़्यादा थमा देना। “काम के होंगे” सोचकर तीस-एक औज़ार रख दिए, तो AI “कौन-सा इस्तेमाल करूँ?” में उलझकर बार-बार अजीब चुनाव करने लगा। अब शुरुआत में 5–10 तक ही सीमित रखता हूँ।

दूसरी—एरर मैसेज का बेरुख़ा होना। सिर्फ़ Error: failed लौटाता था, तो AI कुछ ठीक कर ही नहीं पाता था। जब README.md नहीं मिली। sandbox में सिर्फ़ note.md है की तरह वजह और अगला क़दम तक लिखकर लौटाने लगा, तो वह अचानक ख़ुद ही हल निकालने लगा।

तीसरी—जाँच का भरोसा सिर्फ़ इंसान की नज़र पर रखना। “आख़िर में मैं देख ही लूँगा”—यह बात व्यस्त दिन ज़रूर धोखा देती है। शब्दों की गिनती, टूटे लिंक, टाइप एरर जैसे मशीन से पकड़े जा सकने वाले दरबान बिठाने के बाद से, आधी रात की जाँच काफ़ी घट गई।

शुरू करना है, तो यहाँ से

एकदम से “पूरा-अपने-आप वाला होशियार एजेंट” मत बनाइए। जिसमें ग़लती हो जाए तो लौटाया जा सके, ऐसा एक छोटा काम चुनिए। ड्राफ्ट लेख की जाँच, PR की पहली समीक्षा, पूछताछ की छँटाई, स्टेजिंग पर पब्लिश से पहले की जाँच। बस इतना ही ठीक रहता है।

सिलसिला हमेशा एक जैसा रहता है। ① पढ़ने का दायरा तंग रखकर तय करें → ② मंज़िल (नतीजा) साफ़ रखें → ③ जाँच जितना हो सके कमांड से करवाएँ → ④ ख़तरनाक काम (हटाना, असली DB, पैसे, force push) शुरू में सब “इंसान से पूछो” पर रखें। जो काम सुरक्षित निकले, सिर्फ़ उन्हीं को बाद में अपने-आप वाले दर्जे पर चढ़ाएँ। बस इस सिलसिले को निभाने से हादसे हैरतअंगेज़ ढंग से घट जाते हैं।

अनुमति कैसे तय करें, यह Claude Code अनुमति सेटिंग गाइड में है, और टीम में इस्तेमाल की बुनियाद CLAUDE.md बेहतरीन तरीके में समेटी है। लंबा काम बाँटना हो तो सब-एजेंट इस्तेमाल के पैटर्न भी देख लीजिए। आधिकारिक सोच के लिए Claude Agent SDK की डॉक्युमेंटेशन ही पहला स्रोत है।

असल में आज़माकर जो मिला

शुरुआत के “40 फ़ाइल हादसे” के बाद से, मैंने “AI पर भरोसा करूँ या नहीं” वाली उलझन छोड़ दी। उसकी जगह अब मैं यह देखता हूँ—किस दरबान पर रुका। सबसे छोटे हार्नेस में सिर्फ़ एक safePath जोड़ देने से, फ़ोल्डर के बाहर के हादसे शून्य हो गए। शब्दों की गिनती और लिंक की अपने-आप वाली जाँच जोड़ी, तो पतले लेख छपने से पहले ही रुकने लगे। होशियार AI ढूँढने के बजाय, गिरकर भी चोट न लगने वाला ढाँचा पहले बना लेना—देखने में घुमावदार रास्ता लगता है, पर असल में यही सबसे तेज़ है, यही अब मेरा तजुर्बा कहता है।

निचोड़

हार्नेस इंजीनियरिंग प्रॉम्प्ट सजाने की कला नहीं है। यह यह डिज़ाइन करने की कला है कि AI को क्या दिखाना है, क्या करवाना है, कहाँ रोकना है, और कैसे जाँचना है। पहले ऊपर वाली 30 लाइनें चलाइए, और अपने काम में एक “दरबान” जोड़ने से शुरुआत कीजिए। AI के काम का स्तर मॉडल की होशियारी से नहीं, उसके बाहर के ढाँचे से तय होता है।

ज़्यादा व्यवस्थित ढंग से अपने काम में AI को सुरक्षित तरीके से जोड़ना चाहते हैं तो शिक्षण सामग्री और टेम्पलेट की सूची देखिए, और पूरी टीम के लिए अनुमति, समीक्षा और जाँच तक सब ठीक करना हो तो प्रशिक्षण और परामर्श पर झाँकिए।