ఒక Orchestrator, మూడు CLIs: Codex మరియు Geminiకి డెలిగేట్ చేయడం వలన నిజంగా మీ Claude Tokens ఆదా అవుతాయా?

2026లో చాలా మంది డెవలపర్‌ల మాదిరిగానే, నేను ఒకే మెషీన్‌లో మూడు AI కోడింగ్ CLIలను ఇన్‌స్టాల్ చేసుకున్నాను, మరియు ఒక్కొక్కటి విభిన్న కారణాల వల్ల దాని స్థానాన్ని సంపాదించుకుంది:

• Claude Code — ఆర్కెస్ట్రేటర్-గ్రేడ్ ఏజెంట్. బహుళ-దశల రీజనింగ్, ఆర్కిటెక్చర్, డిబగ్గింగ్, మరియు పెద్ద కోడ్‌బేస్‌లో పనిచేయడంలో అత్యుత్తమమైనది. అలాగే నేను ఎక్కువగా శ్రద్ధ వహించే టోకెన్లు కూడా దీనివే.
• OpenAI Codex CLI — స్పష్టమైన స్పెసిఫికేషన్‌తో బాగా నిర్వచించబడిన, స్వతంత్రమైన టాస్క్‌ను అందించినప్పుడు అద్భుతంగా పనిచేసే సామర్థ్యం గల కోడింగ్ ఏజెంట్.
• Google Gemini CLI — మల్టీమోడల్ వర్క్‌హార్స్. ఇమేజ్ జనరేషన్, ఆడియో మరియు TTS, ట్రాన్స్‌క్రిప్షన్, మరియు ప్రత్యేకించి ప్రాంతీయ భాషలకు సంబంధించి నాణ్యమైన అనువాదం.

ఏదో ఒక సమయంలో స్పష్టమైన ప్రశ్న వస్తుంది: ఈ మూడింటిలో అత్యంత తెలివైనది రోజంతా రన్ చేయడానికి అత్యంత ఖరీదైనది కూడా. కాబట్టి నేను దాన్ని మేనేజర్గా చేయవచ్చా? Claude కి ఒక టాస్క్ ఇచ్చి, దాని పనిని విభజించి, Codex మరియు Gemini కి భాగాలుగా అప్పగించి, అవి పూర్తయిన తర్వాత markdown ఫైల్‌తో రిపోర్ట్ ఇచ్చేలా చేయవచ్చా — అదే సమయంలో Claude కేవలం కష్టమైన భాగాలు మరియు చివరి రివ్యూపై మాత్రమే టోకెన్లను ఖర్చు చేస్తుందా?

నేను ఇప్పుడు వారాల తరబడి నిజమైన పని కోసం ఈ ప్యాటర్న్‌ను అమలు చేశాను — పూర్తి మార్కెటింగ్-సైట్ రీడిజైన్, AI-జనరేటెడ్ హీరో చిత్రాల సమితి, ఎనిమిది భాషల్లోకి అనువాదాలు, యుటిలిటీ స్క్రిప్ట్‌లు, బల్క్ కంటెంట్ పని. ఈ పోస్ట్ ఒక సమగ్రమైన playbook: ఈ ప్యాటర్న్ ఎలా పనిచేస్తుంది, నేను ఉపయోగించే కచ్చితమైన prompt ఆకారాలు, దీన్ని నమ్మదగినదిగా ఉంచే రిపోర్ట్ కాంట్రాక్ట్, ఆదా నిజంగా ఎక్కడ జరుగుతుంది, మరియు ఈ మొత్తం విషయం విలువైనదేనా కాదా అని నిర్ణయించే రెండు దాగి ఉన్న ఖర్చులు.

సంక్షిప్త సమాధానం: అవును, ఈ ప్యాటర్న్ పనిచేస్తుంది, మరియు ఆదా నిజమే — కానీ మీరు హ్యాండ్‌ఆఫ్‌లను సరిగ్గా ఇంజనీరింగ్ చేస్తే మాత్రమే. పూర్తి వివరణ కింద ఇవ్వబడింది.

మొదట, మీరు నిజంగా దేనికి చెల్లిస్తున్నారో అర్థం చేసుకోండి

ఏదైనా వ్యూహం అర్థవంతంగా ఉండటానికి ముందు, agentic CLI సెషన్‌లో టోకెన్లు ఎక్కడికి వెళుతున్నాయో మీకు స్పష్టమైన అవగాహన ఉండాలి. సుమారు నాలుగు విభాగాలు:

1. ఇన్పుట్ టోకెన్లు — మోడల్ చదివే ప్రతిదీ: మీ prompt, ఫైల్ కంటెంట్‌లు, టూల్ అవుట్‌పుట్‌లు, మునుపటి సంభాషణ. దీర్ఘకాలిక కోడింగ్ సెషన్‌లో ఇది మిగతా అన్నింటికంటే చాలా పెద్దదిగా ఉంటుంది, ఎందుకంటే ఏజెంట్ ప్రతి టర్న్‌లోనూ కాంటెక్స్ట్‌ను మళ్లీ చదువుతుంది.
2. అవుట్‌పుట్ టోకెన్లు — మోడల్ రాసే ప్రతిదీ: కోడ్, వచనం, టూల్ కాల్స్. సాధారణంగా ఇన్‌పుట్ కంటే ఎక్కువ ధరతో బిల్ చేయబడుతుంది.
3. మళ్లీ చదవడం — నిశ్శబ్దంగా నష్టం చేసేది. "ఏదైనా తనిఖీ చేయడానికి" ఏజెంట్ 1,000-లైన్ల ఫైల్‌ను తెరిచిన ప్రతిసారీ, మీరు ఆ 1,000 లైన్ల కోసం మళ్లీ ఇన్‌పుట్‌గా చెల్లిస్తారు.
4. పునరావృత పని — నిరంతరం పెరిగే నష్టం. సరిగ్గా అర్థం చేసుకోని టాస్క్ మొదటి ప్రయత్నానికి, దాన్ని గుర్తించే రివ్యూకి, మరియు రెండవ ప్రయత్నానికి ఖర్చు పెంచుతుంది.

డెలిగేషన్ విభాగం 1 మరియు 2లపై దాడి చేస్తుంది: సబ్-ఏజెంట్ యొక్క జనరేషన్ దాని బిల్లుపై (వేరొక సబ్‌స్క్రిప్షన్, తక్కువ ధరకు లభించే మోడల్, లేదా ఫ్రీ టైర్) జరుగుతుంది, మరియు ఆర్గనైజర్ (orchestrator) కేవలం సంక్షిప్త సారాంశాన్ని మాత్రమే చదువుతుంది. కానీ సరిగ్గా చేయని డెలిగేషన్ పెంచుతుంది 3 మరియు 4 విభాగాలు — మరియు ఈ వ్యాసం యొక్క ప్రధాన సారాంశం అదే.

Orchestrator ప్యాటర్న్, సరిగ్గా నిర్వచించబడింది

దాని అత్యంత సులభమైన రూపంలో ఆర్కిటెక్చర్ ఇక్కడ ఉంది:

            ┌─────────────────────────┐
            │   YOU (one instruction)  │
            └───────────┬─────────────┘
                        ▼
            ┌─────────────────────────┐
            │  CLAUDE (orchestrator)   │
            │  plans · splits · specs  │
            │  reviews · integrates    │
            └─────┬──────────────┬────┘
        spec + exact output path │
              ▼                  ▼
   ┌─────────────────┐  ┌─────────────────┐
   │  CODEX (coder)   │  │ GEMINI (media)   │
   │ scoped modules,  │  │ images, audio,   │
   │ tests, boiler-   │  │ translation      │
   │ plate, scripts   │  │                  │
   └────────┬────────┘  └────────┬────────┘
            │  artifacts → disk   │
            │  report.md (≤40 ln) │
            ▼                     ▼
            ┌─────────────────────────┐
            │  CLAUDE reads reports,   │
            │  verifies, fixes/retries │
            │  or integrates & ships   │
            └─────────────────────────┘

Orchestrator నాలుగు విషయాలను కలిగి ఉంటుంది మరియు కేవలం నాలుగు విషయాలను మాత్రమే: ప్రణాళిక (plan), స్పెసిఫికేషన్లు (specs), రివ్యూ (review), మరియు ఇంటిగ్రేషన్ (integration). పెద్దదిగా మరియు మెకానికల్‌గా ఉన్న ప్రతిదీ క్రిందికి నెట్టబడుతుంది, రెండు కచ్చితమైన నిబంధనలతో:

నిబంధన 1 — ఆర్టిఫాక్ట్‌లు ఒక కచ్చితమైన పాత్‌లో డిస్క్‌కు వెళ్తాయి. సబ్-ఏజెంట్ ఎప్పుడూ తన అవుట్‌పుట్‌ను సంభాషణలోకి పేస్ట్ చేయదు. ఇది ఫైళ్లను రాస్తుంది. ఆర్గనైజర్ (orchestrator) యొక్క కాంటెక్స్ట్ స్పష్టంగా ఉంటుంది.

నిబంధన 2 — ప్రత్యుత్తరం దాదాపు ఏమీ ఉండదు. చాలావరకు ఒకే ఒక పదం మరియు చిన్న markdown రిపోర్ట్. రిపోర్ట్ మాత్రమే ఏకైక విషయం, దాన్ని orchestrator కచ్చితంగా చదువుతుంది.

ఈ వ్యాసం నుండి మీరు ఇంకేమీ గుర్తుంచుకోకపోయినా: డెలిగేషన్ prompt మరియు రిపోర్ట్ మాత్రమే ఒక డెలిగేట్ చేయబడిన టాస్క్‌పై orchestrator టోకెన్లను ఖర్చు చేసే రెండు ప్రదేశాలు. మిగతావన్నీ వేరొకరి బిల్లుకి చెందుతాయి. మీ మొత్తం ఆప్టిమైజేషన్ పరిధి ఆ రెండు పత్రాలు మాత్రమే.

వాల్క్‌త్రూ #1: Gemini కి ఇమేజ్ జనరేషన్‌ను డెలిగేట్ చేయడం

నేను రన్ చేసే అత్యంత విలువైన డెలిగేషన్ ఇది, ఎందుకంటే ఆర్గనైజర్ దీన్ని నికరంగా చేయలేదు — Claude Code వెనుక ఎలాంటి ఇమేజ్ మోడల్ లేదు. Claude రాసి Gemini CLI పై ఉపయోగించే prompt యొక్క నిజమైన రూపం ఇక్కడ ఉంది:

Generate a single photorealistic editorial corporate portrait.
Concept: <detailed art direction — subject, pose, wardrobe,
lighting, background, composition>.

CRITICAL: the entire subject must be fully inside the frame with
generous margin on all sides — do not crop arms or held objects.
Plain seamless light-grey studio background for easy cutout.
No text, no watermark, no logos, no props.

Save the image to /tmp/work/hero-cyber.png (overwrite if it exists).
Then reply only DONE.

ఈ prompt లోని ఇంజనీరింగ్‌ను గమనించండి:

• అవుట్‌పుట్ పాత్ కచ్చితంగా ఉంది. "ఎక్కడో సేవ్ చేయండి" అని ఉండదు — ఆర్గనైజర్ ఎక్కడ చూడాలో కచ్చితంగా తెలుసు, కాబట్టి ఎలాంటి గందరగోళం ఉండదు.
• "Reply only DONE." Gemini CLI 400 టోకెన్ల కోసం దాని సృజనాత్మక ప్రక్రియను వివరించడానికి ఇష్టపడుతుంది. మనకు అది అవసరం లేదు. ఒకే పదం.
• నిబంధనలు (constraints) స్పష్టంగా వివరించబడ్డాయి ("fully inside the frame," "no watermark") ఎందుకంటే మీరు రాయని ప్రతి నిబంధన ఒక పునరావృత పనికి దారితీస్తుంది. నేను ఆ ప్రతీ లైన్‌ను ఒక విఫలం నుండి నేర్చుకున్నాను — దాని గురించి కింద మరిన్ని వివరాలు ఉన్నాయి.

ఆ తర్వాత orchestrator ఒక క్వాలిటీ గేట్‌ను చిత్రం చూడటానికి ముందే రన్ చేస్తుంది — ఇది ఒక తక్కువ ఖర్చుతో కూడిన, మెకానికల్ చెక్:

# does the file exist and is it non-trivial?
test -s /tmp/work/hero-cyber.png || echo "FAILED: missing/empty"

# entropy gate: catches blank/placeholder images without
# spending any model tokens at all
python3 -c "
from PIL import Image; import sys
img = Image.open('/tmp/work/hero-cyber.png')
# a flat placeholder has near-zero entropy; a real photo is > 4
print(img.entropy())
"

గేట్ ఉత్తీర్ణమైన తర్వాత మాత్రమే orchestrator నిజంగా చిత్రాన్ని చూస్తుంది — స్క్రిప్ట్ తనిఖీ చేయలేని వాటిని (కాంపొజిషన్, ఆర్టిఫాక్ట్స్, బ్రాండ్-సేఫ్టీ) తనిఖీ చేయడానికి ఒకే విజియన్ కాల్ ద్వారా. Orchestrator వైపు పూర్తి టోకెన్ ఖర్చు అది మాత్రమే: ఒక చిన్న బయటి prompt, ఒక పదం వెనక్కి, ఒక ఇమేజ్ వ్యూ.

వీటిని బ్యాక్‌గ్రౌండ్‌లో రన్ చేయండి. ఇమేజ్ జాబ్స్ ఒకటి నుండి ఐదు నిమిషాలు పడతాయి. వెయిట్ చేయడం అంటే మీ orchestrator తన పూర్తి కాంటెక్స్ట్‌ను మెమరీలో ఉంచుకుని ఖాళీగా కూర్చుంటుంది. జాబ్‌ను స్టార్ట్ చేయండి, ఇతర పనులను కొనసాగించండి, ఫైల్ వచ్చాక తిరిగి రండి. ప్రతి తీవ్రమైన ఏజెంట్ CLI ఇప్పుడు బ్యాక్‌గ్రౌండింగ్‌కు మద్దతు ఇస్తుంది; దాన్ని ఉపయోగించండి.

వాల్క్‌త్రూ #2: కోడింగ్ టాస్క్‌ను Codex కి డెలిగేట్ చేయడం

కోడింగ్ డెలిగేషన్ చాలా క్లిష్టమైనది, ఎందుకంటే వైఫల్యం ఒకే చూపులో కనిపించే చెడు చిత్రం కాదు — ఇది మీ కోడ్‌బేస్‌కు సరిపోని సరిగ్గా ఉన్నట్లు అనిపించే కోడ్. దీనికి పరిష్కారం ఏమిటంటే, "done" అనేది మెషీన్ ద్వారా తనిఖీ చేసే విధంగా స్పష్టమైన స్పెసిఫికేషన్‌ను కలిగి ఉండటం:

TASK: Write a standalone Node script at scripts/import-legacy.mjs

SPEC:
- Reads ./data/legacy-export.csv (papaparse is already a dependency)
- Maps columns per the table below … (exact mapping)
- Writes ./data/import-ready.json, an array of objects
- Node 22, ESM, no new dependencies
- Handle: missing fields → skip row + count; duplicate IDs → last wins

ACCEPTANCE (all must pass):
- node scripts/import-legacy.mjs runs clean on the sample file
- node --test tests/import-legacy.test.mjs passes (write these tests)
- npx eslint scripts/import-legacy.mjs → zero errors

REPORT: write REPORT-import.md (max 40 lines) with status, files
created, how to verify, and up to 5 gotchas. Do not paste file
contents into the report.

చాలా కోడింగ్ టాస్క్‌లు డెలిగేట్ చేయలేని విధంగా ఉన్న చోట మూడు లక్షణాలు దీనిని డెలిగేట్ చేసేలా చేస్తాయి:

1. స్వయంసమృద్ధి (Self-contained) — ఒక కొత్త ఫైల్, موجود మార్డ్యూల్స్‌కు ఎటువంటి ఎడిట్‌లు లేవు, ఆర్కిటెక్చరల్ నిర్ణయాలు లేవు.
2. మెషీన్ ద్వారా తనిఖీ చేయగల ఆమోదం — orchestrator కోడ్‌ను లైన్-బై-లైన్ చదవడం ద్వారా కాకుండా, మూడు కమాండ్‌లతో సరిచూస్తుంది.
3. పరిమిత ఇంటర్‌ఫేస్ (Bounded interface) — ఇన్‌పుట్ ఫైల్, అవుట్‌పుట్ ఫైల్, అయిపోయింది. సబ్-ఏజెంట్ మిగిలిన కోడ్‌బేస్‌లోకి వెళ్ళలేదు.

రిపోర్ట్ వచ్చినప్పుడు, orchestrator ఆమోద కమాండ్‌లను రన్ చేస్తుంది (తక్కువ ఖర్చు), గొట్చాలను (gotchas) చదువుతుంది (తక్కువ ఖర్చు), మరియు ఏదైనా విఫలమైతే లేదా తప్పుగా అనిపిస్తే మాత్రమే అసలు కోడ్‌ను తెరుస్తుంది. స్వచ్ఛమైన పాస్‌లో, orchestrator సాధారణంగా రాసే 300 లైన్లను ఎప్పటికీ చదవదు — అదే ఆదా.

ఆదా ఎక్కడ నిజంగా ఉంటుంది — సుమారు గణాంకాలతో

1. బల్క్ జనరేషన్. ఒక టాస్క్ 2,000 లైన్ల అవుట్‌పుట్‌ను (~25k టోకెన్లు) ఉత్పత్తి చేస్తుందనుకుందాం. నేరుగా చేస్తే, orchestrator ~25k అవుట్‌పుట్ టోకెన్లతో పాటు దానికి సంబంధించిన మొత్తం కాంటెక్స్ట్-రీడింగ్‌కు చెల్లిస్తుంది. డెలిగేట్ చేస్తే, orchestrator: ~300-టోకెన్ స్పెసిఫికేషన్, ~400-టోకెన్ రిపోర్ట్ రీడ్, మరియు కొన్ని వందల టోకెన్ల వెరిఫికేషన్ కమాండ్స్ చెల్లిస్తుంది. దీన్ని ~30k కి వ్యతిరేకంగా ~1k టోకెన్లు — 95%+ కంటే ఎక్కువ తగ్గింపు ఆ టాస్క్‌పై, జనరేషన్ స్వయంగా సబ్-ఏజెంట్ యొక్క కోటాకి బిల్ చేయబడుతుంది.

2. Orchestrator ఎలాగూ చేయలేని పని. నేను ఇటీవల పంపిన ప్రతి ఇమేజ్, ప్రతి ఆడియో ఫైల్, ఎనిమిది భాషల అనువాద బ్యాచ్‌లలో ప్రతీది orchestrator రాసిన స్పెసిఫికేషన్ ఆధారంగా Gemini CLI ద్వారా సృష్టించబడింది. పోల్చడానికి ఎలాంటి Claude-సొంత ప్రత్యామ్నాయం లేదు — ఇది స్వచ్ఛమైన సామర్థ్య పెంపుదల, మరియు టోకెన్ ఖర్చు కేవలం spec + report మాత్రమే.

3. కచ్చితమైన స్పెసిఫికేషన్‌తో సుదీర్ఘమైన మెకానికల్ అవుట్‌పుట్. టెస్ట్ స్కాఫోల్డింగ్, డేటా మైగ్రేషన్లు, బాయిలర్‌ప్లేట్ మాడ్యూల్స్, ఫార్మాట్ మార్పులు, అవుట్‌లైన్ నుండి డాక్యుమెంట్ డ్రాఫ్ట్‌లు. సాధారణ అంశం: తక్కువ తీర్పు (judgment), ఎక్కువ పరిమాణం (volume). పరిమాణం (volume) అనేది అవుట్‌పుట్ టోకెన్ల ధరను నిర్ణయించేది; తీర్పు (judgment) అనేది చవకైన ఏజెంట్‌కు లేనిది. పరిమాణాన్ని డెలిగేట్ చేయండి, తీర్పును ఉంచుకోండి.

ఆదా ఎక్కడ ఆవిరైపోతుంది — రెండు పన్నులు మరియు ఒక ఓవర్‌హెడ్

వెరిఫికేషన్ పన్ను

ఇది ఎవరూ పరిగణించని ఖర్చు, కాబట్టి నా స్వంత ప్రాజెక్ట్ నుండి రసీదులను ఇస్తాను — ఒక వెబ్‌సైట్ కోసం AI-జనరేటెడ్ హీరో పోర్ట్రెయిట్‌ల బ్యాచ్:

• ఒక చిత్రం పోటీదారుని గుర్తించదగిన ల్యాప్‌టాప్ లోగోతో వచ్చింది. చట్టపరంగా మరియు బ్రాండ్ పరంగా ఉపయోగించలేనిది. రీజనరేట్ చేయండి — లేదు ఆగండి, నిజానికి దాన్ని ప్యాచ్ చేయండి ఒక ఇమేజ్ టూల్‌తో, ఆపై మళ్లీ సరిచూడండి.
• మరొక సెట్‌లో మూలాలు ఉన్న చిత్రాలు ఉన్నాయి ఇవి ట్రాన్స్‌పరెంట్‌గా ఉన్నాయని చెప్పబడ్డాయి కానీ కాదు — రంగుల బ్యాక్‌గ్రౌండ్‌లో మాత్రమే కనిపించే అస్పష్టమైన తెల్లటి రంగు. ఆలస్యంగా గుర్తించబడింది, ఫ్లడ్-ఫిల్ ద్వారా సరిచేయబడింది, మళ్లీ సరిచూడబడింది.
• మూడవది ప్రొడక్ట్ టాబ్లెట్‌ను కలిగి ఉంది ఇది సగం ఫ్రేమ్ వెలుపల జనరేట్ చేయబడింది — మోడల్ ఏ వస్తువును చూపించడానికి ఇమేజ్ ఉందో దాన్ని క్రాప్ చేసింది. కొత్త "everything fully inside the frame" నిబంధన లైన్‌తో పూర్తి రీజనరేషన్.

ఆ చిత్రాలలో ప్రతీది ఉత్తీర్ణమైంది చవకైన మెకానికల్ గేట్లను. ప్రతి ఒక్కదానికి ఇప్పటికీ orchestrator నిజంగా చూడటం, విశ్లేషించడం మరియు పరిష్కరించడం అవసరం. డెలిగేషన్ రివ్యూ దశను తొలగించలేదు — ఇది జనరేషన్ ఖర్చును వేరే ప్రదేశానికి తరలించి, రివ్యూ ఖర్చును అలాగే ఉంచింది.

మరియు ఒక డెలిగేట్ చేయబడిన టాస్క్ రివ్యూలో విఫలమైనప్పుడు, మీరు చెల్లిస్తారు మూడు సార్లు: డెలిగేషన్, దాన్ని పట్టుకున్న రివ్యూ, మరియు మళ్లీ చేయడం. ఒకే టాస్క్ యొక్క రెండు విఫలమైన డెలిగేషన్లు సాధారణంగా orchestrator మొదటిసారి నేరుగా చేయడం కంటే ఎక్కువ ఖర్చు అవుతాయి. అందుకే నా ఇమేజ్ ప్రొంప్ట్‌లలోని ప్రతి నిబంధన లైన్ ఒక గాయం లాగా ఉంటుంది — ప్రతీది ఒక గాయమే .

బడ్జెట్ నిబంధన: డెలిగేట్ చేయబడిన సృజనాత్మక పనులలో 20–30% సవరణ చక్రం అవసరమని భావించండి, మరియు దాని ఆధారంగా నిర్ణయం తీసుకోండి. టాస్క్ తనిఖీ చేయడానికి తక్కువ ఖర్చుతో కూడుకున్నదైతే (టెస్ట్‌లను రన్ చేయడం, ఫైల్‌ను చెక్ చేయడం), పునరావృత పని ఉన్నప్పటికీ డెలిగేషన్ గెలుస్తుంది. ఒకవేళ వెరిఫికేషన్ అంటే "అన్నింటినీ జాగ్రత్తగా చదవడం" అని అర్థమైతే, ఆదా అనేది ఒక భ్రమ మాత్రమే.

ఇంటిగ్రేషన్ పన్ను

ఒకవేళ టాస్క్ అనేక ఫైళ్లను తాకినా, మీ కోడ్‌బేస్ పద్ధతులతో సరిపోలాల్సి ఉన్నా, లేదా orchestrator మనస్సులో ఉండే కాంటెక్స్ట్‌పై ఆధారపడి ఉంటే — ఆర్కిటెక్చర్ నిర్ణయాలు, క్రాస్-మాడ్యూల్ రీఫ్యాక్టర్, రేస్-కండిషన్ డిబగ్ — దాన్ని అప్పగించడం పొరపాటు ఆదా అవుతుంది. సబ్-ఏజెంట్‌కు మీ కాంటెక్స్ట్ లేదు; orchestrator దాన్ని సురక్షితంగా విలీనం చేయడానికి సబ్-ఏజెంట్ తాకిన ప్రతీదాన్ని మళ్లీ చదవాల్సి వస్తుంది. ఒకే అవగాహన కోసం మీరు రెండుసార్లు చెల్లించారు: ఒకసారి సబ్-ఏజెంట్ తన స్వంత పాక్షిక చిత్రాన్ని రూపొందించడానికి, మరొకసారి orchestrator పూర్తి చిత్రాన్ని పునర్నిర్మించడానికి.

గుర్తు సులభం: స్పెసిఫికేషన్ రాయడానికి మీ ఆర్కిటెక్చర్‌ను వివరించాల్సి వస్తే, టాస్క్‌ను డెలిగేట్ చేయవద్దు. కేవలం స్పెసిఫికేషన్ రాయడానికే ఆదా కంటే ఎక్కువ ఖర్చు అవుతుంది, మరియు తప్పుగా అర్థం చేసుకునే ప్రమాదం చాలా ఎక్కువగా ఉంటుంది.

ఓవర్‌హెడ్ పరిమితి (The overhead floor)

ఒక మంచి డెలిగేషన్ prompt రాయడానికి 200–400 టోకెన్ల ఖర్చు అవుతుంది. రిపోర్ట్ చదవడానికి 300–500 ఖర్చు అవుతుంది. వెరిఫికేషన్ మరొక కొన్ని వందలు. కాబట్టి ఒక పరిమితి ఉంది: టాస్క్ యొక్క ప్రత్యక్ష ఖర్చు సుమారు 1,000–2,000 టోకెన్ల (~50–100 లైన్ల అవుట్‌పుట్) లోపు ఉంటే, దాన్ని డెలిగేట్ చేయడం ప్రతిసారీ నష్టాన్ని కలిగిస్తుంది. నేరుగా చేసేయండి.

markdown రిపోర్ట్ కాంట్రాక్ట్ — ఆదా ఇక్కడే నిలుస్తుంది లేదా పోతుంది

ఈ ప్యాటర్న్ చాలా మందికి ఉపయోగపడేలా చేసే ఆలోచన రిపోర్ట్ ఫైల్: ప్రతి సబ్-ఏజెంట్ పని పూర్తి చేసి orchestrator కోసం ఒక markdown సారాంశాన్ని అందిస్తుంది. ఇది సరైన ఆలోచనే — మరియు ఈ మొత్తం విధానం నిశ్శబ్దంగా విఫలమయ్యే చోటు కూడా ఇదే. ఒకవేళ Codex 500-లైన్ల రిపోర్ట్ రాసి, Claude దాన్ని పూర్తిగా చదివితే, మీరు ఎలాగూ చెల్లించారు — రాయడానికి బదులుగా చదవడానికి.

ఇక్కడ ఒక చెడు (bad) రిపోర్ట్ ఉంది (మీరు ఏజెంట్లను పరిమితం చేయకపోతే అవి ఇలా తయారు చేస్తాయి):

ఒక 340-లైన్ వ్యాసం: టాస్క్‌ను మళ్లీ చెబుతుంది, ప్రతి నిర్ణయాన్ని కాలక్రమేణా వివరిస్తుంది, "రెఫరెన్స్ కోసం" సృష్టించిన రెండు ఫైళ్ల పూర్తి కంటెంట్‌ను పేస్ట్ చేస్తుంది, పూర్తి టెస్ట్ అవుట్‌పుట్‌ను కలిగి ఉంటుంది, మరియు చివరికి భవిష్యత్తు మెరుగుదలల కోసం మూడు పేరాల హెచ్చరికలు మరియు సూచనలతో ముగుస్తుంది.

దాన్ని చదవడం అనేది కోడ్ రాయడం కంటే ఎక్కువ ఖర్చుతో కూడుకున్నది. దానికి బదులుగా నేను అమలు చేసే కాంట్రాక్ట్ ఇక్కడ ఉంది:

# Task: import-legacy script
Status: DONE
Files created:
  - scripts/import-legacy.mjs
  - tests/import-legacy.test.mjs
How to verify:
  - node --test tests/import-legacy.test.mjs
  - node scripts/import-legacy.mjs && head data/import-ready.json
Gotchas:
  - 14 rows in the sample CSV had no email; skipped, count logged
  - CSV dates are DD/MM/YYYY, not ISO — parser handles both

మరియు ప్రతి రిపోర్ట్‌ను ఈ రూపంలో ఉంచే నాలుగు నిబంధనలు:

1. హార్డ్ క్యాప్: 40 లైన్లు. దాన్ని డెలిగేషన్ prompt లో తెలియజేయండి. Status, paths, verify commands, gotchas — మరేదీ ఉండకూడదు.
2. పాత్‌లు (Paths), కంటెంట్‌లు కావు. ఆర్టిఫాక్ట్‌లు డిస్క్‌లో ఉంటాయి; రిపోర్ట్ వాటిని చూపుతుంది. వెరిఫికేషన్ అవసరమైనప్పుడు మాత్రమే orchestrator ఫైల్‌ను తెరుస్తుంది — రెండుసార్లు చదవడం ఒక ఎంపికగామారుతుంది, డిఫాల్ట్‌గా కాదు.
3. కేవలం జనరేషన్ కోసం "Reply only DONE". ఆర్టిఫాక్ట్ స్వయంగా చెప్పినప్పుడు (ఒక చిత్రం, ఒక ఆడియో ఫైల్), రిపోర్ట్ కూడా ఎక్కువే. ఫైల్ వస్తుంది, ఒక పదం వెనక్కి వస్తుంది, గేట్లు రన్ అవుతాయి.
4. ప్రతి స్పెసిఫికేషన్‌లో మెషీన్ ద్వారా తనిఖీ చేయగల ఆమోద ప్రమాణాలు. "బాగా చేయండి" అనేది పునరావృత పనికి కారణమవుతుంది. "All tests pass, zero lint errors, output is a 1200×630 JPEG under 200 KB" అనేది orchestrator ఒకే కమాండ్‌తో సరిచూసే పాస్/ఫెయిల్‌ను ఇస్తుంది. మీ ఆమోద ప్రమాణాల నాణ్యతే మీ డెలిగేషన్ నాణ్యత.

పని విభజన: ఎవరికి ఏమి ఇస్తారు, మరియు ఎందుకు

టాస్క్ (Task)	ఎవరికి ఇవ్వాలి (Give it to)	ఎందుకు (Why)
Images, audio/TTS, transcription	Gemini CLI — ఎల్లప్పుడూ	Orchestrator వీటిని అస్సలు చేయలేదు; పరిపూర్ణ లాభం
అనువాదం (ముఖ్యంగా ప్రాంతీయ భాషలు)	Gemini CLI	మంచి నాణ్యత, అధిక పరిమాణం, శాంప్లింగ్ ద్వారా సులభంగా తనిఖీ చేయదగినది
కచ్చితమైన స్పెసిఫికేషన్‌తో కూడిన స్వయంసమృద్ధ స్క్రిప్ట్/మాడ్యూల్	Codex CLI	అధిక పరిమాణం, తక్కువ తీర్పు అవసరం, మెషిన్ ద్వారా తనిఖీ చేయదగినది
టెస్ట్ స్కాఫోల్డింగ్, మైగ్రేషన్లు, బాయిలర్‌ప్లేట్	Codex CLI	యాంత్రిక అవుట్‌పుట్; అంగీకారం = పరీక్షలు మాత్రమే
ఆర్కిటెక్చర్ & డిజైన్ నిర్ణయాలు	Claude — ఎప్పుడూ డెలిగేట్ చేయవద్దు	పరిపూర్ణ విచక్షణ; స్పెసిఫికేషన్ రాయడానికి అయ్యే వ్యయం టాస్క్ కంటే ఎక్కువ
మల్టీ-ఫైల్ రీఫ్యాక్టర్లు, ఇంటిగ్రేషన్ పనులు	Claude	ఇంటిగ్రేషన్ శ్రమ డెలిగేషన్‌ను ఒక నకిలీ పొదుపుగా మారుస్తుంది
డీబగ్గింగ్	Claude	సేకరించిన కాంటెక్స్ట్ అవసరం; sub-agent సున్నా నుండి ప్రారంభిస్తుంది
డెలిగేట్ చేసిన ప్రతిదాని తుది సమీక్ష	Claude	మీరు ప్రీమియం మోడల్‌కు చెల్లిస్తోంది నిజానికి ఈ పని కోసమే

చెప్పదగిన ఒక ముఖ్య విషయం: ఇది "Claude మంచిది, ఇతరులు చెడ్డవారు" అని కాదు. ఇది పరిమాణం వర్సెస్ విచక్షణ. Codex అద్భుతమైన స్వయంసమృద్ధమైన కోడ్‌ను రాస్తుంది; Gemini ఇమేజ్ మరియు అనువాద నాణ్యత నిజమైన ప్రొడక్షన్ వర్క్‌కు ఉపయోగపడుతుంది. ఈ విభజన అనేది ప్రతి స్థానానికి అయ్యే ఖర్చు మరియు ప్రతి టాస్క్‌కి ఏమి అవసరమో దాని ఆధారంగా ఉంటుంది.

ఆపరేషనల్ ప్లేబుక్

పొదుపును మరింత పెంచే కొన్ని అలవాట్లు:

నిదానంగా జరిగే ప్రతిదాన్నీ బ్యాక్‌గ్రౌండ్‌లో రన్ చేయండి. జనరేషన్ జాబ్స్ ఒకటి నుండి ఐదు నిమిషాలు నడుస్తాయి. వాటిని డెటాచ్‌ చేసి రన్ చేయండి, orchestrator ను వేరే పనిపై పనిచేయనివ్వండి, ఫైల్స్ వచ్చాక ఫలితాలను ప్రాసెస్ చేయండి. ఖరీదైన ఏజెంట్‌ను ఎప్పుడూ బ్లాక్-వెయిట్ చేయనివ్వద్దు.

దూకుడుగా బ్యాచింగ్ చేయండి. ఆరు చిత్రాలను ఆరు సంభాషణలుగా చేయడం వల్ల ఆరు రౌండ్ల ప్రోంప్ట్+రిపోర్ట్ ఓవర్‌హెడ్ అవుతుంది. నామకరణ విధానంతో (naming convention) ఆరు ఫైళ్లను ఉత్పత్తి చేసే ఒకే ప్రోంప్ట్ (hero-01.png … hero-06.png), ఒక రిపోర్ట్, ఒక రివ్యూ పాస్. అనువాదాలకు కూడా అంతే: ఎనిమిది భాషలనూ ఒకే డెలిగేషన్‌లో.

తెలివిగా సమీక్షించే ముందు యాంత్రికంగా గేట్ చేయండి. ఫైల్ ఉంది → సైజ్ సరైనది → ఎంత్రోపీ/లింట్/టెస్ట్‌లు పాస్ అయ్యాయి → ఆ తర్వాత orchestrator టోకెన్లను విచక్షణపై ఖర్చు చేయండి. గేట్ పట్టుకునే ప్రతి వైఫల్యం మీరు చెల్లించాల్సిన అవసరం లేని మోడల్-రివ్యూ.

వేగంగా విఫలం అవ్వండి, ఒకేసారి ఎస్కలేట్ చేయండి. డెలిగేషన్ తప్పుగా తిరిగి వస్తే, orchestrator కి లభిస్తుంది ఒకే ఒక కచ్చితమైన నిబంధనతో సరిదిద్దే పునఃప్రయత్నం ("మునుపటి ప్రయత్నం టాబ్లెట్‌ను క్రాప్ చేసింది — మొత్తం టాబ్లెట్ స్పష్టంగా కనిపించాలి"). పునఃప్రయత్నం కూడా విఫలమైతే, ఆ టాస్క్‌ను డెలిగేట్ చేయడం ఆపేయండి; orchestrator నేరుగా చేస్తుంది లేదా ప్రత్యామ్నాయ మార్గాన్ని ఎంచుకుంటుంది. ముగింపు లేని పునఃప్రయత్న లూప్‌ల వల్లే డెలిగేషన్ అత్యంత ఖరీదైన మార్గంగా మారుతుంది.

orchestrator సెషన్‌ను క్లీన్‌గా ఉంచండి. సుదీర్ఘంగా నడిచే orchestrator సెషన్‌లు కాంటెక్స్ట్‌ను కూడబెడతాయి, మరియు కాంటెక్స్ట్ అనేది మీరు ప్రతి టర్న్‌లో చెల్లించే ఇన్‌పుట్-టోకెన్ అద్దె. ఆర్టిఫాక్ట్‌లు సంభాషణలో కాకుండా డిస్క్‌లో ఉండటం వల్లే డెలిగేషన్ సహాయపడుతుంది — దానిని నాశనం చేయవద్దు cat-ing ఫైళ్లను చాట్‌లోకి "ఒకసారి చూడటానికి" పంపడం ద్వారా.

మీరు నేర్చుకున్న నిబంధనలను టెంప్లేట్‌లలో రాయండి. ప్రతి రీవర్క్ ఒక ప్రోంప్ట్ లైన్‌ను నేర్పుతుంది ("no watermark," "fully inside frame," "no new dependencies"). ఒకే పాఠానికి రెండుసార్లు ఖర్చు చేయకుండా ఉండటానికి టెంప్లేట్‌లు సహాయపడతాయి.

ఒక వారం పాటు ఇది నిజంగా ఎలా కనిపిస్తుంది

గుణాత్మకంగా, ఒక నిజమైన ప్రాజెక్ట్ వారంలో ఈ విధానాన్ని నడిపిన తర్వాత: orchestrator కాంటెక్స్ట్ చిన్నదిగా ఉంది మరియు దాని టర్న్లు వేగంగా ఉన్నాయి, ఎందుకంటే బల్క్ అవుట్‌పుట్ ఎప్పుడూ సంభాషణలోకి ప్రవేశించలేదు. కనిపించే టోకెన్ ఖర్చు దాదాపు పూర్తిగా స్పెసిఫికేషన్‌లు, రిపోర్ట్‌లు మరియు రివ్యూలకు మారింది — సరిగ్గా ఇక్కడే మీరు కోరుకుంటారు ప్రీమియం మోడల్ తన శ్రద్ధను ఖర్చు చేయాలని. Sub-agents తమ పరిమాణంపై సొంత కోటాలను ఖర్చు చేశాయి. వైఫల్యాలు నిజమైనవే కానీ పరిమితమైనవి: క్రియేటివ్ జనరేషన్లలో సుమారు పావు వంతులో ఫిక్స్ సైకిల్, స్పష్టమైన స్పెసిఫికేషన్ ఉన్న కోడ్ టాస్క్‌లపై దాదాపు సున్నా రీవర్క్, మరియు ఒక టాస్క్ (క్రాస్-కటింగ్ రీఫ్యాక్టర్) స్పెసిఫికేషన్ డ్రాఫ్ట్ ఆర్కిటెక్చర్ డాక్యుమెంట్‌గా మారడం ప్రారంభించిన తర్వాత నేను సరైన నిర్ణయంతో orchestrator వద్దే ఉంచాను.

ఈ విధానం ఖరీదైన మోడల్‌ను చవకగా మార్చలేదు. కానీ దానిని ఒక టైపిస్ట్‌గా ఉపయోగించడం ఆపేలా చేసింది.

తీర్పు, మరియు ఒక చెక్‌లిస్ట్

ఈ వ్యూహం సరైనదేనా? చాలా వరకు, అవును. జనరేషన్ ఎక్కువగా ఉండే పనికి పొదుపు నిజమైనది మరియు పెద్దది — అది దేని డెలిగేషన్ అంటే అవుట్‌పుట్, మరియు అవుట్‌పుట్‌కే మీరు డబ్బు చెల్లిస్తారు. విచక్షణ ఎక్కువగా ఉండే పనికి పొదుపు అనేది ఒక భ్రమ — అది దేని డెలిగేషన్ అంటే అవగాహన, మరియు అవగాహన ఎల్లప్పుడూ orchestrator బిల్లుపైనే పడుతుంది, సాధారణంగా వడ్డీతో సహా.

ఖరీదైన CLI ని ఒక మంచి, చవకైన టీమ్‌తో ఉన్న పిక్కీ టెక్ లీడ్‌గా పరిగణించండి: ఇది స్పెసిఫికేషన్‌లు రాస్తుంది, చిన్న నివేదికలను సమీక్షిస్తుంది మరియు ఏదైనా తేడాగా అనిపించినప్పుడు మాత్రమే పరిశీలిస్తుంది.

మీరు ఒక టాస్క్‌ను డెలిగేట్ చేయడానికి ముందు, ఈ చెక్‌లిస్ట్‌ను పరిశీలించండి:

• అవుట్‌పుట్ అనేది పెద్దదా (>100 లైన్లు / >2k టోకెన్లు) లేదా orchestrator అస్సలు ఉత్పత్తి చేయలేనిదా?
• నేను స్పెసిఫికేషన్‌ను నా ఆర్కిటెక్చర్‌ను వివరించకుండా రాయగలనా?
• "పూర్తయింది" అనేది మెషిన్ ద్వారా తనిఖీ చేయదగినదా ("అంతటినీ శ్రద్ధగా చదవడం" కన్నా (పరీక్షలు, లింట్, ఫైల్ లక్షణాలు) నా?)
• అవుట్‌పుట్ పాథ్ కచ్చితమైనదా, మరియు సమాధానం దేనికి పరిమితం చేయబడిందా DONE + ≤40-లైన్ల నివేదిక?
• నేను కేటాయించానా ఒక ఫిక్స్ సైకిల్ — మరియు అది రెండుసార్లు విఫలమైతే ఏమి చేయాలో నిర్ణయించానా?

ఐదు అవును సమాధానాలు అయితే: డెలిగేట్ చేయండి, బ్యాక్‌గ్రౌండ్‌లో రన్ చేయండి, గేట్ చేయండి మరియు ఫలితాన్ని ఆస్వాదించండి. ఏ ఒక్కటైనా కాదు అంటే: ప్రీమియం మోడలే నేరుగా చేస్తుంది — ఎందుకంటే మీరు ఖర్చు చేసే అత్యంత ఖరీదైన టోకెన్లు రెండుసార్లు ఖర్చు చేసినవే.