Opus 5.5 के साथ किसी भी चीज़ को रिवर्स इंजीनियर कैसे करें (पूर्ण पाठ्यक्रम)

ज्यादातर लोग जब किसी बाइनरी को रिवर्स-इंजीनियर करने की कोशिश करते हैं, तो उसे hex editor में खोलते हैं, बीस मिनट तक स्क्रॉल करते हैं और फिर हार मान लेते हैं।

उन्हें नहीं पता होता कि फाइल कौन सा टूल लोड करेगा। उन्हें नहीं पता कि कौन सा प्रॉम्प्ट उसका लॉजिक बाहर निकालेगा। उन्हें यह भी नहीं पता कि असेंबली के इस पूरे जंगल को ऐसी चीज़ में कैसे बदलें जिसे वे सच में दोबारा बना सकें।

यह 11-स्टेप कोर्स Claude Opus 5.5 को एक ओपन-सोर्स "कुछ भी बनाने वाली" मशीन में बदल देगा।

AI की ताज़ा और काम की जानकारी (alpha) पाने के लिए मेरा Substack फॉलो करें:

movez.substack.com

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

7 अक्टूबर 2026 को Replit के CEO Amjad Masad ने बस एक लाइन पोस्ट की:

https://x.com/amasad/status/2107671204639465961

इसके जवाब में, @morluto नाम के एक डेवलपर ने सबूत पेश किया: ऐसे टूल्स का एक सेट जो एजेंट्स को Hopper और Ghidra चलाने और बहुत आगे तक जाने की ताकत देता है।

वह प्रोजेक्ट REA है, जिसने कुछ ही दिनों में GitHub पर 110,000 स्टार्स पार कर लिए।

https://github.com/morluto/rea

यह कोई हवाई दावा नहीं है। उसी हफ्ते, WordCraft नाम के एक ओपन-सोर्स प्रोजेक्ट ने Microsoft और Adobe का clean-room rebuild पूरी तरह Rust में शिप किया:

https://getartcraft.com/apps

यह Word और Adobe के व्यवहार को देखकर और उनके पब्लिक file-format specs को पढ़कर बनाया गया था — उनका कोड कभी नहीं देखा गया।

यह कोर्स आपको एक सील बंद बाइनरी से लेकर ऐसा rebuild तैयार करने तक का पूरा रास्ता दिखाएगा, जिसमें पढ़ने का काम Opus 5.5 करेगा।

01. इंजन - एक एजेंट बाइनरी को कैसे पढ़ता है

Opus 5.5 अपने आप disassembler नहीं चला सकता। यह सिर्फ टेक्स्ट पढ़ता है और टेक्स्ट लिखता है।

एजेंट के साथ रिवर्स इंजीनियरिंग इसलिए काम करती है क्योंकि मॉडल और बाइनरी के बीच एक टूल बैठा होता है: वह फाइल को असली disassembly engine में लोड करता है, नतीजों को callable functions के रूप में सामने रखता है, और मॉडल को सवाल पूछने देता है।

वह टूल REA है, और इसके पीछे का इंजन Hopper, Ghidra या IDA है।

यह लूप बहुत सीधा है और बार-बार चलता है: मॉडल REA से टारगेट को जाँचने को कहता है, REA अपने ठोस सबूतों (addresses, bytes, pseudocode, call sites) के साथ नतीजे लौटाता है, और मॉडल उन नतीजों का इस्तेमाल अगला सवाल पूछने या reimplementation लिखकर टेस्ट करने में करता है।

सब कुछ आपके कंप्यूटर पर लोकली चलता है। मॉडल को सोचने के लिए जिन नतीजों की ज़रूरत होती है, बस वही अपलोड होते हैं, और हर निष्कर्ष को observation, inference या unknown के तौर पर टैग किया जाता है।

**

02. इंस्टॉलेशन - rea-agents और एक disassembler

सेटअप REA के MCP server को आपके एजेंट के साथ रजिस्टर करता है और उससे मेल खाते workflow instructions इंस्टॉल करता है।

यह काम एक कमांड से हो जाता है। यह कुछ भी लिखने से पहले आपको हर बदलाव दिखाता है, और जिन चीज़ों को छेड़ता है उनका बैकअप ले लेता है।

disassembler आपको खुद लाना है: macOS पर Hopper सबसे आसान रास्ता है, Ghidra फ्री है और हर प्लेटफॉर्म पर चलता है, और अगर आपके पास पहले से IDA है तो उसका इस्तेमाल करें।

1# 1. REA को अपने एजेंट (Claude Code, Codex, Cursor, Gemini CLI...) के साथ रजिस्टर करें
2npx rea-agents setup            # योजनाबद्ध बदलाव दिखाता है, लिखने से पहले पूछता है
3
4# 2. एक deep-analysis provider। macOS पर Hopper सबसे आसान है;
5#    सेटअप आपकी मंजूरी के बाद इसे इंस्टॉल कर सकता है। Ghidra और IDA आपको खुद लाने होंगे।
6# 3. टर्मिनल और स्क्रिप्टिंग के लिए rea CLI इंस्टॉल करें
7npm install --global rea-agents
8rea --help
9
10# 4. अपना एजेंट रीस्टार्ट करें, फिर चेक करें कि टूल्स चालू हैं
11claude
12> /mcp
13  rea: connected
14    open_binary, binary_overview, analyze_function, decompile,
15    list_procedures, search, xrefs, trace, inspect_artifact,
16    analyze_javascript_application, inspect_managed_artifact ...

ज़रूरतें बहुत मामूली हैं: Node.js 22 या उससे नया वर्ज़न और npm। Native analysis के लिए तीन इंजनों में से कोई एक चाहिए; static JavaScript और .NET inspection के लिए किसी इंजन की ज़रूरत ही नहीं है। REA को अपडेट रखें, क्योंकि इसके नए वर्ज़न में अक्सर फिक्स आते रहते हैं।

1# रिवर्स-इंजीनियरिंग के नियम ( CLAUDE.MD )
2
3## अधिकार (Authority)
4- सिर्फ उन्हीं टारगेट का विश्लेषण करें जिनका मैं मालिक हूँ या जिन्हें जाँचने की मुझे अनुमति है। आधार एक बार बता दें।
5- हर दावे को टैग करें: observation (देखा है), inference (निष्कर्ष निकाला है), या unknown (पता नहीं)।
6- सबूत ज़रूर दें: address, bytes, pseudocode या call site। बिना सबूत के कोई दावा न करें।
7
8## वर्कफ़्लो (Workflow)
9- पूरा डंप निकालने के बजाय सबसे छोटे overview से शुरू करें। फैलाव सिर्फ तभी करें जब कोई ठोस कमी दिखे।
10- खुले हुए सेशन का दोबारा इस्तेमाल करें; एक जैसा विश्लेषण कभी दोबारा न चलाएँ।
11- Static facts को runtime facts से अलग रखें। Static reading से कभी execution का संकेत न दें।
12
13## पुनर्निर्माण (Reconstruction)
14- हमेशा BEHAVIOR (व्यवहार) और public specs से बनाएँ, कॉपी किए गए कोड या assets से कभी नहीं।
15- एक obligation ledger रखें: हर रिकवर किए गए व्यवहार को "done" कहने से पहले एक पासिंग टेस्ट से गुज़रना होगा।

Opus 5.5 पांच effort levels के साथ आता है: low, medium, high, xhigh और max। इनका इस्तेमाल ऐसे करें:

• Medium — जाँचने और नेविगेट करने के लिए
• High — आम फंक्शन्स को annotate करने के लिए
• Max — obfuscated code और भारी pointer math वाले कामों के लिए।

इस पूरे कोर्स में Effort ही क्वालिटी तय करने वाला सबसे बड़ा पैमाना है।

03. राउटर - 20 टारगेट प्रकार, हर एक के लिए एक टूल

शुरुआती लोगों की पहली गलती यह होती है कि जब टारगेट एक Electron app हो और उसका JavaScript वहीं मौजूद हो, तब भी वे disassembler खोल बैठते हैं।

REA टारगेट को सही टूल की तरफ भेजता है, और आपका पहला प्रॉम्प्ट भी ऐसा ही होना चाहिए। फाइल का नाम बताएँ, फीचर का नाम बताएँ, और एजेंट को entry tool चुनने दें।

1मैं समझना चाहता हूँ कि [APP] में [FEATURE] कैसे काम करता है, जो [ABSOLUTE PATH] पर मौजूद है।
2
3सबसे पहले, बताओ कि यह किस तरह का टारगेट है (native, Electron/JS, .NET, Go, APK, WASM)
4और इसे खोलने के लिए सही REA टूल चुनो। अभी गहरा विश्लेषण शुरू मत करो।
5
6फिर मुझे एक पैराग्राफ का नक्शा दो: ऐप किससे बना है, कितना बड़ा है, और
7[FEATURE] के लिए तुम सबसे पहले कहाँ देखोगे। Observations, inferences और unknowns
8को अलग-अलग रखो, और जो भी दावा करो उसके सबूत दो।

REA को किसी Electron app पर लगाने से बिना किसी disassembler के, सेकंडों में modules, imports और IPC boundaries मिल जाते हैं।

इसे किसी native Mach-O या ELF पर लगाने से Hopper database खुलता है और आपको थोड़ा मुश्किल लेकिन ज़्यादा गहरा native रास्ता मिलता है। यह जान लेना कि आप किस रास्ते पर हैं, घंटों बचा सकता है।

https://x.com/_vmlops/status/2106690704244420687

04. रेकी (Recon) - overview, strings और call graph

अभी कोई कोड मत खोलो। पहले REA से पूरी फाइल का नक्शा माँगो। एक कमांड बता देती है कि यह किस मशीन पर चलता है, इसमें कितने फंक्शन हैं, और इसमें दबा हुआ सारा पढ़ने योग्य टेक्स्ट क्या है।

वही टेक्स्ट आपका सबसे तेज़ सुराग है: web addresses, error messages और feature names आपको कोड की एक लाइन पढ़े बिना बता देते हैं कि ऐप क्या करता है।

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1,284 identified
5  segments:    __TEXT __DATA __LINKEDIT
6  entry:       _main @ 0x1000051c0
7
8rea.search             { query: "http" }  # strings + code refs
9  0x10004a2c0  "https://api.target.app/v3/sync"
10  0x10004a300  "Authorization: Bearer "
11  0x10004a330  "offline cache miss, falling back"
12
13rea.xrefs              { address: "0x100012ab0" }  # इसे कौन कॉल करता है?
14  147 references  ->  core config loader, called everywhere

REA यह भी गिनता है कि हर फंक्शन कितनी बार कॉल होता है (इस गिनती को cross-references या xrefs कहते हैं)।

जो फंक्शन 147 बार कॉल होता है, वह ऐप का दिल है और आपकी पूरी मेहनत के लायक है। जो सिर्फ दो बार कॉल होता है, वह एक छोटा helper है जिसे आप तब तक नज़रअंदाज़ कर सकते हैं जब तक उसकी ज़रूरत न पड़े। इस लिस्ट में ऊपर से शुरू करें और नीचे की तरफ बढ़ें।

05. डीकंपाइल (Decompile) - एक फंक्शन को pseudocode में बदलना

अब उन व्यस्त फंक्शन्स में से कोई एक चुनें और उसे ऐसी चीज़ में बदलें जिसे आप पढ़ सकें। Decompiler कच्ची machine instructions लेता है और उन्हें C से मिलते-जुलते कोड में लिख देता है।

यह देखने में भद्दा लगता है: var_28 जैसे नाम, उलझा हुआ लॉजिक, हर जगह casts। लेकिन आप इसे पढ़ सकते हैं, और Opus 5.5 को बस पढ़ने लायक चीज़ चाहिए होती है।

नतीजा सेव करने के लिए इसे command line से चलाएँ, या चैट के अंदर से।

1# किसी एक फंक्शन को address से decompile करें, JSON में जिसे आप pipe या save कर सकें
2rea decompile /Applications/Target.app/.../Target 0x100012ab0 \
3  --provider hopper --json > fn_config_loader.json
4
5# या नाम से फंक्शन खोजें और references फॉलो करें
6rea function /path/to/Target parseConfig --provider hopper --json
7rea xrefs    /path/to/Target 0x100012ab0 --provider hopper --json
8rea trace    /path/to/Target "sync" --provider hopper --json

1// 0x100012ab0  xrefs: 147
2void sub_100012ab0(void* arg0) {
3    void* var_20 = objc_msgSend(cls_NSJSONSerialization,
4        sel_JSONObjectWithData_options_error, arg0, 0x0, 0x0);
5    if (var_20 != 0x0) {
6        void* var_28 = objc_msgSend(var_20, sel_objectForKey, @"endpoints");
7        void* var_30 = objc_msgSend(var_20, sel_objectForKey, @"auth_mode");
8        void* var_38 = objc_msgSend(var_20, sel_objectForKey, @"retry_count");
9        objc_msgSend(g_sharedConfig, sel_setEndpoints, var_28);
10        objc_msgSend(g_sharedConfig, sel_setAuthMode, var_30);
11        objc_msgSend(g_sharedConfig, sel_setRetryCount,
12            objc_msgSend(var_38, sel_intValue));
13    }
14}

REA का अपना showcase पुराने गेम DX-Ball में एक साउंड कॉल को फॉलो करता है, उस helper तक पहुँचता है जो left-right audio balance तय करता है, और फिर उस अधूरे pseudocode को C में बदल देता है।

नतीजा सभी 3,205 original test cases पास करता है और compile किए गए 63 बाइट्स में से हर एक को बिल्कुल वैसा ही बनाता है।

पूरी प्रक्रिया rea.tools/showcase पर देखें।

06. एनोटेट (Annotate) - Opus से हर variable का नाम रखवाएँ

वह भद्दा कोड काम का सिर्फ आधा हिस्सा है। अब इसे Opus 5.5 को दें और उसे समझाने और साफ करने को कहें।

यह पेचीदा variables के नाम बदलकर असली नाम रख देता है, एक लाइन में बताता है कि फंक्शन किसलिए है, उसका pattern पहचान लेता है, और यहाँ तक कि ओरिजिनल ऐप में छूटे हुए bugs को भी पकड़ लेता है।

यह प्रॉम्प्ट Claude के साथ पेस्ट करें:

1यहाँ 147 cross-references वाले फंक्शन का decompiled pseudocode है।
2
3इस फंक्शन के लिए:
41. हर variable का नाम उसके इस्तेमाल के हिसाब से एक सार्थक नाम में बदलो।
52. एक वाक्य में इसका उद्देश्य बताओ।
63. उन data structures की लिस्ट बनाओ जिन्हें यह पढ़ता और लिखता है।
74. Pattern का नाम बताओ (singleton, factory, state machine, observer...)।
85. इसे साफ, idiomatic Swift (या जिस भाषा का calling conventions संकेत दें) में
9   doc comments के साथ दोबारा लिखो।
106. कोई छूटी हुई error handling, input validation या security check हो तो उसे फ्लैग करो।
11
12जवाब देने से पहले xhigh effort पर इसे अच्छे से सोचो: नाम तय करने से पहले
13सोचो कि हर value क्या है। जिस चीज़ को लेकर तुम पक्के नहीं हो, उसे मार्क करो।
14
15[pseudocode यहाँ पेस्ट करें]

Decompilation आपको बताता है कि कोड क्या करता है। Opus 5.5 आपको बताता है कि क्यों करता है, और उसे दोबारा बनाने के लिए नाम देता है।

https://x.com/0x0SojalSec/status/2108389060192706674

https://x.com/0x0SojalSec/status/2108031166502896035

हर टारगेट के लिए disassembler की ज़रूरत नहीं होती। REA का Notion showcase ऐप के JavaScript में clipboard feature ढूँढता है, Electron layers से होते हुए main process तक इसका पीछा करता है, और बिल्कुल सटीक दिखाता है कि यह rich clipboard कैसे बनाता है — बिना किसी assembly के पूरा trace। देखें

07. Obfuscation - Tigress benchmark

कुछ ऐप्स ठीक उसी चीज़ का विरोध करने के लिए बनाए जाते हैं जो आप कर रहे हैं। उनका कोड जानबूझकर उलझाया जाता है: लॉजिक इधर-उधर कर दिया जाता है, टेक्स्ट encrypt कर दिया जाता है, और आपका समय बर्बाद करने के लिए fake branches डाल दी जाती हैं।

इसे obfuscation कहते हैं, और यह एक ऐसी जगह है जहाँ बेहतरीन मॉडल भी अटक जाता है। Elastic Security Labs ने इसे मापा, और 20 tasks में Tigress scrambler पर Claude Opus को लगाया। ये आँकड़े याद रखें।

इन आँकड़ों में दो व्यावहारिक सबक छिपे हैं।

• पहला, एक असफल कोशिश की लागत सफल कोशिश से लगभग दोगुनी होती है, क्योंकि मॉडल हार मानने से पहले बार-बार ज़्यादा ज़ोर लगाता रहता है। इसलिए हर फंक्शन के लिए खर्च की सीमा तय करें और जल्दी रुक जाएँ।
• दूसरा, decompiled code को भेजने से पहले उसका कचरा निकाल दें (Caveman नाम का एक फ्री टूल इसका लगभग 75% हटा देता है) ताकि मॉडल अपना ध्यान फालतू चीज़ों पर नहीं, बल्कि असली लॉजिक पर लगाए।

पाँच ट्रिक्स जिनसे आपकी सच में भिड़ंत होगी, और कोड खोलने पर वे कैसी दिखती हैं:

1यह फंक्शन obfuscated लग रहा है। Max effort पर काम करो।
2
31. मौजूद techniques की पहचान करो (control-flow flattening, opaque predicates,
4   dead code, string encryption, function splitting) और बताओ कि इस खास कोड में
5   हर एक कहाँ दिख रहा है।
62. इन्हें सुलझाओ: dead branches हटाओ, opaque predicates evaluate करो, dispatch को
7   unflatten करो, और अगर key मिल सकती है तो inline strings decrypt करो।
83. बचा हुआ साफ फंक्शन दिखाओ।
94. अपने confidence को 1-10 रेटिंग दो। 6 से कम हो तो बिल्कुल सटीक बताओ कि कौन से
10   हिस्से अनिश्चित हैं और आस-पास का कौन सा context उन्हें सुलझा देगा। चुपचाप अंदाज़ा मत लगाओ।
11
12[obfuscated pseudocode यहाँ पेस्ट करें]

08. झुंड (Swarm) - workers को चलाने वाला controller

एक अकेली चैट 500 फंक्शन्स को ठीक से नहीं पढ़ सकती। वह भूल जाती है कि उसने क्या देखा, एक ही चीज़ को तीन अलग-अलग नामों से बुलाती है, और अपनी ही बातों से उलझने लगती है।

इसका समाधान एक छोटी टीम है: एक controller chat जो काम बाँटता है, और कई worker chats जो एक-एक फंक्शन संभालते हैं।

Controller बड़ी तस्वीर को अपने पास रखता है और टुकड़ों को वापस जोड़ता है।

इसके लिए आपको कुछ खास बनाने की ज़रूरत नहीं है, नीचे दिए गए दो प्रॉम्प्ट ही पूरा सेटअप हैं।

1तुम एक reverse-engineering controller हो। Function map functions.json में है
2(address, name, size, xref_count)।
3
41. Call-graph proximity के आधार पर functions को cluster में बाँटो; clusters को xref count के हिसाब से order करो।
52. हर cluster को एक worker को भेजो। खुद कभी किसी function का विश्लेषण मत करो।
63. पहले से resolved structs को हर worker के brief में डालो ताकि नाम एक जैसे रहें।
74. जब कोई worker 6 से कम confidence दे, तो उसके resolved neighbors के context
8   के साथ दूसरे pass को queue करो।
95. कुल token खर्च का हिसाब रखो और हर cluster के बाद रिपोर्ट करो।

1तुम एक worker हो। तुम्हें एक decompiled function और अब तक resolved structs मिलेंगे।
2बिल्कुल यही लौटाओ: address, purpose, confidence (1-10), structs_used, structs_new,
3clean_source, flags। मौजूदा struct names का दोबारा इस्तेमाल करो; controller ने जो
4struct पहले ही दे दिया है उसके लिए कभी दूसरा नाम मत गढ़ो। सिर्फ एक function। हो जाए तो रुक जाओ।

https://x.com/victor_explore/status/2109466356454510612

09. Clean room - चार नियम जो इसे कानूनी बनाए रखते हैं

Clean-room rebuild का मतलब है कि आप ऐप क्या करता है उसे कॉपी करें, उसके अंदर का कोड कभी नहीं। यह सही किया तो जो आप शिप करेंगे वह पूरी तरह आपका होगा। गलत किया तो आप किसी और का copyright अपने सिर लाद लेंगे।

चार नियम आपको सुरक्षित रखते हैं, और WordCraft टीम हर build पर इन चारों को अपने आप चेक करती है।

1. देखो, कॉपी कभी मत करो। टारगेट को black-box की तरह चलाओ, देखो कि वह क्या करता है, स्क्रीनशॉट सिर्फ उसकी अपनी विंडो का लो। उसका कोड कभी मत पढ़ो, disassemble मत करो या पेस्ट मत करो। साधारण feature names के अलावा उसके शब्द कभी कॉपी मत करो।
2. Sources नहीं, Specs। File formats public standards से आने चाहिए (OOXML यानी ECMA-376 / ISO 29500, साथ ही published RTF और ODF specs), किसी competitor का parser पढ़कर या किसी GPL/LGPL code से कभी नहीं।
3. सिर्फ original assets। हर icon, font, template और sound या तो कोड में बना हो, public-domain हो, या openly licensed हो, और attribution file में उसकी एक लाइन हो। वरना CI check build को fail कर देगा।
4. दोनों कामों को अलग रखो। एक agent behavior निकालता है और spec लिखता है। एक अलग context सिर्फ spec से implement करता है, और ओरिजिनल analysis को कभी नहीं देखता। यही separation clean-room boundary है।

1पूरे हुए analysis से, reimplementation के लिए एक clean-room specification लिखो।
2
3सिर्फ BEHAVIOR बताओ। शामिल करो: हर public interface, data model, हर
4user-visible feature को एक testable requirement के रूप में, पढ़े और लिखे जाने वाले
5file formats (observed behavior और public spec के आधार पर), और error-handling behavior।
6
7शामिल मत करो: addresses या offsets, decompile से आए variable names, assembly,
8या ओरिजिनल से कॉपी की गई कोई भी चीज़। जिस developer ने बाइनरी कभी नहीं देखी,
9वह सिर्फ इस document से compatible version बना सके।
10
11Output markdown में दो, इन sections के साथ: Architecture, Data Model, Public API, File Formats,
12Test Cases.

description के आधार पर काम करना सिर्फ कानूनी सुरक्षा नहीं है। यह आपको अपनी भाषा और ज़रूरतों के हिसाब से सही फैसले लेने देता है, बजाय इसके कि आप वो फैसले अपनाएँ जो ओरिजिनल author ने दशकों पहले लिए थे।

WordCraft कुछ जगहों पर Word से तेज़ है, ठीक इसीलिए क्योंकि उसने Word का अंदरूनी हिस्सा कॉपी नहीं किया।

10. ऐप्स बनाना - बारह pro tools, एक तरीका

WordCraft कोई एक बार का चमत्कार नहीं है। यह ArtCraft टीम की शेल्फ पर मौजूद बारह ऐप्स में से एक है, जिनमें से हर एक उस टूल का clean-room rebuild है जिसके लिए आप पहले से पैसे देते हैं। सब Rust में शुरू से लिखे गए हैं और GitHub पर फ्री और open source हैं।

उनका अपना नारा है "Twelve apps. One craft", और वह एक craft step 9 का तरीका ही है: ओरिजिनल को देखो, public specs पढ़ो, और सिर्फ behavior के आधार पर एक नया वर्ज़न बनाओ।

इस साझा तरीके का फायदा हर जगह एक जैसा है। कोई Electron नहीं: हर ऐप macOS, Windows और Linux पर native है, और FilmCraft के अलावा बाकी सब WebAssembly के ज़रिए browser tab में भी चलते हैं।

और क्योंकि इनके अंदर हर action एक named command है, इसलिए AI agent इन बारहों को तुरंत चला सकता है।

हर Craft ऐप एक ही तरीके से बना है, और यह ढाँचा कॉपी करने लायक है। हर एक layers में बँटा है, और हर layer सिर्फ अपने ठीक नीचे वाली layer का इस्तेमाल करती है — नीचे basic measurements से लेकर ऊपर on-screen window तक।

ये WordCraft की layers हैं:

और हर action सिर्फ एक named command है, इसलिए कोई इंसान क्लिक करे, keyboard shortcut इस्तेमाल करे, या AI agent चलाए — तीनों बिल्कुल एक ही चीज़ trigger करते हैं। यही वजह है कि इनमें से किसी को भी agent चला सकता है।

1MCP के ज़रिए WordCraft चलाएँ
2
3# Headless document automation
4claude mcp add wordcraft -- wordcraft-cli mcp
5
6# या चल रहे desktop app को control करें
7wordcraft --control 7981 &
8claude mcp add wordcraft-app -- wordcraft-cli mcp --connect 127.0.0.1:7981
9
10# Tools: list_commands, execute, batch, type_text, select_text,
11#        inspect_document, render_page, save_document (+ screenshot/click/key live)
12> report.docx खोलो, हर heading को 14pt bold करो, PDF में export करो
13  ✓ select.all-headings -> 12 selected
14  ✓ format.font-size 14 · format.bold
15  ✓ export report.pdf (selectable text, bookmarks kept)

https://x.com/yuhasbeentaken/status/2109235513102057828

11. जाँचें और शिप करें - समानता साबित करें, MCP expost करें

आपके पास ओरिजिनल का source code कभी था ही नहीं, इसलिए आप उसे लाइन-दर-लाइन compare नहीं कर सकते।

इसके बजाय आप behavior compare करते हैं: ओरिजिनल और अपने rebuild दोनों को एक ही inputs दें और चेक करें कि output एक जैसा आ रहा है या नहीं।

1ओरिजिनल बाइनरी और मेरे rebuild की तुलना करने वाला behavioral test harness बनाओ।
2
350 inputs जनरेट करो: 30 normal, 10 edge (empty, max size, unicode, special chars),
410 error (malformed, missing fields, corrupt)। हर एक को दोनों में चलाओ। Output की
5जहाँ तक हो सके byte-for-byte तुलना करो, बाकी semantic तुलना करो। Match rate, divergence
6list, और हर एक की severity (cosmetic / behavioral / critical) रिपोर्ट करो। report.md में save करो।

यह वह सबसे पक्का सबूत भी है जो आप किसी को दिखा सकते हैं (आर्टिकल के बिल्कुल ऊपर वाला RE slot)।

फिर अपना rebuild उसी तरह रिलीज़ करें जैसे REA और WordCraft ने किया: एक MCP server के रूप में, ताकि अगले व्यक्ति का agent उसे वैसे ही चला सके जैसे आपने REA को चलाया।

हर function को एक साफ नाम और description दें, उसे एक simple command-line tool में लपेटें, और ऐसा बनाएँ कि वह एक लाइन में install हो जाए।

https://x.com/0xMovez/status/2108884063515746410

और टेस्टिंग आखिर में नहीं, बल्कि साथ-साथ करें, क्योंकि अगर गलती तीन layers बन जाने के बाद पता चले तो उसे सुधारना बहुत महँगा पड़ता है।

छह गलतियाँ जो पूरा वीकेंड बर्बाद कर देती हैं

1. Electron app पर disassembler खोलना। अगर JavaScript वहीं मौजूद है, तो analyze_javascript_application पर route करें और native path को पूरी तरह छोड़ दें।
2. कुछ पढ़े बिना सब कुछ dump कर देना। पहले REA से summary माँगें। पूरा ऐप एक साथ खींचने से असली लॉजिक शोर में दब जाता है और आपका बिल बढ़ जाता है।
3. Functions को file order में पढ़ना। Cross-reference count के हिसाब से sort करें। 147-xref वाला फंक्शन architecture है; 2-xref वाला helper इंतज़ार कर सकता है।
4. Stage-3 obfuscation से भिड़ते रहना। Benchmark multi-layer का 0% solve करता है। Budget तय करें, neighbors से context बचाकर रखें, बाद में लौटें।
5. मॉडल को अपने rebuild में कोड कॉपी करने देना। इससे clean room टूट जाता है। एक context में पहले spec बनाएँ, दूसरे context में spec से implement करें।
6. Parity report के बिना शिप करना। "मुझे लगता है यह मैच करता है" कोई सबूत नहीं है। 50 behavioral tests और match rate सबूत है।

निष्कर्ष:

REA इंस्टॉल करें। बाइनरी पढ़ें। इसे अपना बनाकर दोबारा खड़ा करें।

टारगेट को route करें, उसकी surface का नक्शा बनाएँ, hot functions को decompile करें, Opus 5.5 से सब कुछ name करवाएँ, तोड़ने लायक obfuscation को तोड़ें, swarm से इसे scale करें, फिर clean spec बनाएँ और rebuild को MCP पर शिप करें।

ग्यारह steps। एक model। ज़ीरो copied code।