अपने AI एजेंट्स से कैसे बात करें: Claude, Codex, Gemini, Grok Build

ईमानदारी से सोचें: आपकी आखिरी feature पर कितना वक्त कोड लिखने में गया, और कितना agent को समझाने में कि आप चाहते क्या हैं? अगर आप Claude Code, Codex, Gemini CLI या Grok Build के साथ काम करते हैं, तो जवाब पलट चुका है। अब आप बहुत कम टाइप करते हैं। आप describe करते हैं, correct करते हैं, approve करते हैं।

यही इस काम का असली बदलाव है। बाधा अब टाइपिंग स्पीड या framework की जानकारी नहीं है। बाधा है आपके और आपके agents के बीच communication की quality।

कोड अब bottleneck नहीं, communication है

बीस साल तक एक अच्छा developer वो था जो साफ कोड तेजी से ship करे। अब agent कोड ship करता है। आपको अलग बनाता है वो ये: पहली बार में सही नतीजा निकालने की क्षमता, कम से कम cost पर।

कल                                   आज
┌────────────────┐                   ┌────────────────┐
│ Write the code │  ~80% of time     │ Describe the   │  ~80% of time
│                │                   │ intent         │
└───────┬────────┘                   └───────┬────────┘
        │                                    │
┌───────▼────────┐                   ┌───────▼────────┐
│ Describe the   │  ~20% of time     │ Agent writes   │  ~20% of time
│ intent         │                   │ the code       │
└────────────────┘                   └────────────────┘

Bottleneck: typing                   Bottleneck: communication

अब अच्छे developer की पहचान ये नहीं कि वो सबसे ज्यादा lines लिखे। वो ship करता है:

• तेज: expected result आने से पहले कम round trips।
• सटीक: agent वही करता है जो मांगा था, कोई मनमानी interpretation नहीं।
• Tokens में सस्ता: हर बेकार round trip, हर गलत तरीके से frame किया context reload tokens में चुकाना पड़ता है, यानी पैसे और latency दोनों।
• कम regressions के साथ: साफ intent से tight diff मिलता है, कोई जंगली rewrite नहीं जो तीन और चीज़ें तोड़ दे।

एक vague prompt और एक precise prompt की cost एक जैसी नहीं होती:

Vague prompt                         Precise prompt
"fix the cart bug"                   "In cart.ts, computeTotal()
                                      applies the discount before VAT.
                                      Flip the order: VAT first,
                                      then discount on the net total."
        │                                     │
        ▼                                     ▼
  3 round trips                          1 pass
  ~45k tokens                            ~12k tokens
  2 regressions                          0 regression

यही AgentsRoom का पूरा मकसद है: intent को एक actionable instruction में बदलना, जल्द से जल्द, सही format में, बिना context को बार-बार repeat किए। ये रहे वो building blocks जो ठीक इसी के लिए बने हैं।

1. Persistent context: CLAUDE.md और AGENTS.md

पहला message भेजने से पहले, आपके agents को पता होना चाहिए कि वो कहां कदम रख रहे हैं: conventions, architecture, project की खास बातें। वो सब जो आप हर session में दोबारा explain नहीं करना चाहते। यही काम context files करती हैं (CLAUDE.md, AGENTS.md), जिन्हें हर बड़ा provider startup पर automatically पढ़ता है।

        Without context                With CLAUDE.md / AGENTS.md
┌─────────────────────────┐        ┌─────────────────────────┐
│ You re-explain the       │        │ The agent already knows: │
│ stack, the style, the    │        │  - the stack             │
│ folders... on EVERY       │        │  - the conventions       │
│ new prompt               │        │  - the files to avoid    │
│                          │        │                          │
│ = wasted tokens          │        │ = you go straight to     │
│   every session          │        │   the point              │
└─────────────────────────┘        └─────────────────────────┘

यह सबसे ज्यादा return देने वाला communication investment है: एक बार लिखो, हर prompt पर फायदा उठाओ। हमारा CLAUDE.md गाइड बताता है इसमें क्या डालें और क्या नहीं।

2. Prompt Library: एक ही prompt दोबारा कभी न लिखें

आपके पास जरूर कुछ instructions हैं जो आप बार-बार टाइप करते हैं: "diff का security review करो", "हमारे convention से इस module के tests लिखो", "Conventional Commits message draft करो"। Prompt Library इन्हें store करती है, organize करती है, और दो clicks में किसी भी agent में re-inject करती है।

Chaining भी important है। Linked prompts से आप एक बड़े task को क्रमिक steps में बांट सकते हैं जो एक के बाद एक fire होते हैं, एक monolithic wall की बजाय जिसे agent आधा-अधूरा ही execute करता है।

One giant prompt                 Linked prompts (chained)
┌──────────────────────┐         ┌─────────┐   ┌─────────┐   ┌─────────┐
│ "Do A, then B,        │        │ 1. A     │──▶│ 2. B     │──▶│ 3. C     │
│  then C, and don't    │        │  scoped  │   │  scoped  │   │  scoped  │
│  forget D..."         │        └─────────┘   └─────────┘   └─────────┘
│                       │
│ the agent forgets     │        each step verified
│ half of it            │        before the next
└──────────────────────┘

3. Skills Library: एक paragraph नहीं, पूरी procedure encode करें

Prompt बताता है क्या करना है। Skill बताती है यहां यह कैसे होता है, step by step, आपके rules के साथ। Skills Library इन reusable procedures (SEO audit, component migration, release checklist) को save करती है और सही समय पर agent से जोड़ती है। यह condensed communication है: दस-line का process बार-बार explain करने की बजाय skill attach करो, और agent protocol follow करता है।

4. Scratchpad: भेजने से पहले compose करें

एक अच्छा prompt draft होता है, गर्मी में improvise नहीं। Scratchpad एक draft है जो हमेशा पास रहती है: एक stack trace paste करो, spec का टुकड़ा, कोई idea, उसे साफ करो, structure दो, और जब तैयार हो तब agent को भेजो। "ओह रुको, मेरा मतलब था..." कम होगा, तो round trips भी कम।

5. Intent बोलें: Voice Dictation और Voice Mode

बोलना टाइपिंग से तीन-चार गुना तेज होता है, और intent describe करने के लिए अक्सर ज्यादा natural भी। AgentsRoom दो modes offer करता है:

• Voice dictation आपकी आवाज को सीधे composer में transcribe करता है। बोलो, पढ़ो, भेजो।
• Voice mode एक real दो-तरफा conversation खोलता है: आप बोलते हैं, agent जोर से जवाब देता है, hands free।

Keyboard   ████████████████████████  ~40 words/min
Voice      ████████████████████████████████████████████████████████████  ~150 words/min

Architecture के बारे में जोर से सोचना हो, expected behavior describe करना हो, या agent को steer करना हो जब हाथ कहीं और हों, तब यह बेहतरीन है।

6. बताने की बजाय दिखाएं: Sketch और Screenshot to Agent

कुछ चीज़ें शब्दों में साफ बयान करना नामुमकिन होता है। "button बहुत बाईं तरफ है, ऊपर की spacing अजीब है, और modal यहां खुलना चाहिए": एक image हजार tokens के बराबर है।

• Sketch से आप screen capture करते हैं, उसे annotate करते हैं (arrows, boxes, notes), और वो visual agent को feedback के रूप में भेजते हैं।
• Screenshot to Agent से एक keyboard shortcut किसी region को capture करके prompt में attach कर देता है।

"Nudge that thing a bit          [annotated capture]
 to the right, I think,           ┌───────────────┐
 you know what I mean..."         │  ┌──┐  ←── here│
                                  │  │  │          │
   vague, interpreted             │  └──┘  too low │
                                  └───────────────┘
                                    precise, no ambiguity

7. Feedback loop: आपके agents आपको जवाब देते हैं

Communication सिर्फ भेजना नहीं है। यह सुनना भी है जब agent को किसी decision की जरूरत हो। AgentsRoom नए message वाले agents को unread mark करता है, messaging app जैसे, और desktop और mobile पर notify करता है जब agent आपका इंतजार कर रहा हो। अब scrolling terminal नहीं देखना: agent आपको ping करता है।

        YOU                                        AGENT
         │   1. Context (CLAUDE.md / AGENTS.md)      │
         │ ────────────────────────────────────────▶ │
         │   2. Intent (text / voice / sketch)        │
         │ ────────────────────────────────────────▶ │  executes
         │   3. Status + question (unread badge)      │
         │ ◀──────────────────────────────────────── │
         │   4. Decision / correction                 │
         │ ────────────────────────────────────────▶ │
         ▼                                            ▼
   fewer tokens       fewer regressions          faster

Details यहां: notifications और unread messages।

8. Conversation measure करें: Token Usage

आप वही optimize करते हैं जो आप measure करते हैं। Token usage tracking हर session और हर agent के लिए दिखाता है कि हर exchange में कितना खर्च हुआ। आप तुरंत देखते हैं किस तरह का prompt bill उड़ा देता है और कौन-सा lean रहता है। Communication एक measurable line item बन जाता है, gut feeling नहीं।

9. Provider बदलें, thread न टूटे

Architecture के लिए Claude, backend के लिए Codex, तेजी से बदलती feature के लिए Gemini या Grok Build: provider बदलने का मतलब सब कुछ दोबारा explain करना नहीं होना चाहिए। Multi-provider support एक running agent को एक provider से दूसरे पर flip करता है और एक handoff summary बनाता है (touched files, session activity, progress) ताकि नया CLI वहीं से शुरू करे जहां पिछला रुका था।

   Claude ──▶ [handoff summary] ──▶ Codex ──▶ [summary] ──▶ Grok Build
   (arch)        context kept        (backend)              (feature)

10. अपने agents को आपस में बात करने दें

सबसे फायदेमंद communication कभी-कभी वो होती है जो आपको खुद नहीं करनी पड़ती। तीन building blocks यह संभालते हैं:

• Teams: एक dev agent, QA agent को handoff करता है, जो अपना feedback वापस भेजता है, एक loop में, हर exchange में आपके बिना।
• Agent delegation: एक महंगा agent mechanical tasks (tests run करना, browser में check करना) एक सस्ते model के agent को delegate करता है। उस काम पर कम tokens जो उन्हें deserve नहीं करता।
• AgentsRoom MCP server: आपके agents cockpit के अंदर read और write करते हैं (backlog, prompts, terminals, browser), तो वो आपके environment से communicate करते हैं, सिर्फ आपसे नहीं।

11. कहीं से भी communicate करें

एक अच्छा idea आपके Mac पर आने का इंतजार नहीं करता। Mobile-desktop sync और remote control आपको phone से agent launch करने, सवाल का जवाब देने या diff approve करने देते हैं। Communication loop तब नहीं टूटती जब आप desk छोड़ते हैं।

Recap: कौन-सा channel किस काम के लिए

निष्कर्ष: communication ही नया skill है

काम पलट गया है। कोड लिखना अभी भी काम आता है, लेकिन अब game वहां नहीं जीता जाता। एक तेज, frugal developer और round trips में tokens जलाने वाले developer के बीच फर्क है उनके agents से communication की quality: सही तरीके से set किया context, साफ intent, सही channel सही message के लिए, और एक feedback loop जो आपका एक मिनट न ले।

AgentsRoom इसी idea के इर्द-गिर्द बना है। कोई और chat client नहीं, बल्कि एक cockpit जहां हर building block इसलिए है कि Claude, Codex, Gemini और Grok Build के साथ side by side बेहतर, तेज और सस्ते में communicate हो सके।

आजमाना चाहते हैं? AgentsRoom download करें, अपना provider connect करें, और देखें कैसे हर feature की cost गिरती है जैसे-जैसे आपकी communication sharp होती है। Prompts लिखने के बारे में और गहराई में जाना हो तो हमारा prompt engineering for code page देखें, या सभी features explore करें।