Opus 5.5 को रिवर्स इंजीनियरिंग मशीन में कैसे बदलें: 8 चरणों का पूरा कोर्स

8 अक्टूबर 2026 को एक ऐसा रिपॉजिटरी, जिसके बारे में तीन महीने पहले किसी ने नहीं सुना था, GitHub ट्रेंडिंग में नंबर एक पर आ गया।

इसका नाम REA है — Reverse Engineer Anything — और यह आपके एजेंट को एक असली डिसअसेंबलर देता है।

**इसे बुकमार्क कर लें - अगर आपको पूरा वर्ज़न चाहिए, तो इस पर आधारित 20-लेसन का पूरा कोर्स यहाँ लाइव है:**

reacourse.xyz

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

उस हफ्ते हर जगह लोगों का रिएक्शन एक जैसा ही था।

Matthew Berman ने इसे तीन शब्दों में बयां किया, और 36 लाख लोगों ने उसे देखा।

https://x.com/MatthewBerman/status/2108245653843509415

REA एक ओपन-सोर्स MCP सर्वर और CLI है जो Claude Code, Codex, Cursor और Gemini CLI से जुड़ जाता है।

MIT लाइसेंस, morluto द्वारा बनाया गया, पहला रिलीज़ 12 जुलाई 2026 को हुआ, और तीन महीने बाद इसके GitHub स्टार्स 1,00,000 पार कर गए।

सब कुछ लोकली चलता है, और हर निष्कर्ष पर "observation", "inference" या "unknown" का टैग लगा होता है, साथ में उसके पीछे का एड्रेस या कॉल साइट भी दी होती है।

एक सील किए हुए बाइनरी से लेकर आपके अपने रीबिल्ड तक का पूरा रास्ता यही है, बस आठ स्टेप्स में।

स्टेप्स से पहले: लोग इसके साथ क्या-क्या शिप कर चुके हैं

असली कहानी टूल नहीं है, बल्कि वह है जो चार हफ्तों में बनकर तैयार हो गया।

ArtCraft ने Adobe के सात ऐप्स को फ्री ओपन-सोर्स विकल्पों के रूप में दोबारा बनाया, फिर WordCraft, GridCraft और DeckCraft के साथ Office की तरफ रुख किया।

अब तक बारह ऐप्स, सब Rust में शुरू से लिखे गए, तीन प्लेटफॉर्म्स पर नेटिव, और एक को छोड़कर बाकी सभी WebAssembly के ज़रिए ब्राउज़र टैब में भी चलते हैं।

गेम्स की बात करें तो सबूत और भी पक्के हैं:

• Super Mario Sunshine का नेटिव PC पोर्ट बना: लगभग 365 एजेंट घंटे और 17.3B टोकन, Claude और Codex दोनों को साथ इस्तेमाल करके
• आधिकारिक REA ब्लॉग पर एजेंट्स की मदद से रीबिल्ड किया गया एक Touhou गेम: 697 फंक्शन, 696 बिल्कुल सटीक मैच, करीब 12 दिनों में खेलने लायक
• Aegis ऑथेंटिकेटर (3,077 क्लासेस) को खोलकर दोबारा बनाया गया, और इसके सभी 133 टेस्ट केस पास हुए
• DX-Ball के साउंड-पैन फंक्शन को C में दोबारा बनाया गया, जिसने 3,205 ओरिजिनल x86 टेस्ट केस पास किए और कंपाइल किए गए सभी 63 बाइट्स को बिल्कुल वैसा ही रिप्रोड्यूस किया

ध्यान दें कि यह लिस्ट क्या नहीं है।

किसी ने कोई लाइसेंस चेक नहीं तोड़ा, किसी ने किसी और का सोर्स कोड पब्लिश नहीं किया।

इनमें से हर एक एक ऐसा बिहेवियर है जिसे वापस निकाला गया, लिखा गया, और नए कोड में दोबारा बनाया गया।

01. कुछ भी खोलने से पहले टारगेट को राउट करें

यह इतना तेज़ इसलिए नहीं फैला क्योंकि यह किसी एक चीज़ को अच्छे से पढ़ता है। यह लगभग सब कुछ पढ़ता है, और अपनी हर बात के लिए सबूत दिखाता है।

https://x.com/RoundtableSpace/status/2109165852578992582

यह लिस्ट आपका पहला फैसला भी है। दोपहर भर बर्बाद करने का सबसे आम तरीका यह है कि जब टारगेट कोई Electron ऐप हो जिसका JavaScript वहीं मौजूद है, तब भी आप डिसअसेंबलर खोल बैठें।

REA को Electron पर पॉइंट करें और बिना किसी इंजन के सेकंडों में आपको मॉड्यूल्स, इम्पोर्ट्स और IPC बाउंड्रीज़ मिल जाएँगी, जबकि नेटिव Mach-O या ELF एक Hopper डेटाबेस खोलेगा, जो गहरा रास्ता है और धीमा भी।

यह जानना कि आप किस रास्ते पर हैं, घंटों बचाता है, इसलिए इसे अपना पहला प्रॉम्प्ट बनाएँ।

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

वो हिस्सा जिसका ज़िक्र लगभग कोई नहीं करता: कई Unity गेम्स अपना लॉजिक .NET के रूप में शिप करते हैं, और REA बिना किसी अतिरिक्त इंजन के .NET पढ़ लेता है।

यही पूरी वजह है कि खरीदा हुआ Steam गेम आधे घंटे के अंदर बाइनरी से एडिटेबल C# में बदल जाता है।

और आपकी मशीन पर मौजूद हर Electron ऐप अभी पढ़ा जा सकता है, बिना उसे लॉन्च किए भी:

1# जहाँ JavaScript रहता है
2macOS:   /Applications/<App>.app/Contents/Resources/app.asar
3Windows: C:\Users\<you>\AppData\Local\Programs\<App>\resources\app.asar
4    npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json

02. पाँच मिनट में इंस्टॉल करें, फिर एक इंजन जोड़ें

इसे कामयाब बनाने वाली चीज़ कोई चालाक प्रॉम्प्ट नहीं है। यह एक असली डिसअसेंब्ली इंजन है जो एजेंट से जुड़ा हुआ है, और ठीक यही बात एक डेवलपर ने कही थी।

https://x.com/techNmak/status/2108431092462338178

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

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

node -v # Node 22.19+, 24.11+ या 26+। वर्ज़न 23 और 25 सपोर्टेड नहीं हैं

1npx rea-agents@latest setup          # MCP सर्वर रजिस्टर करता है, लिखने से पहले पूछता है
2npm install --global rea-agents      # छोटी rea कमांड, हमेशा के लिए
3rea --help
4# एजेंट को रीस्टार्ट करें, फिर वेरिफ़ाई करें। doctor सिर्फ चेक करता है, कुछ बदलता नहीं
5npx -y rea-agents@latest doctor --client claude_code --json

रीस्टार्ट उतना मामूली नहीं है जितना लगता है: टर्मिनल सेशन को नए सिरे से शुरू करना पड़ता है, और डेस्कटॉप ऐप्स को पूरी तरह बंद करना पड़ता है, क्योंकि सिर्फ विंडो बंद करना काफी नहीं है।

फिर सिर्फ उसी चीज़ के लिए इंजन जोड़ें जिसे आप सच में पढ़ना चाहते हैं:

अपने पहले असली टारगेट से पहले एक फाइल लिखना ज़रूरी है: claude-md में हाउस रूल्स।

सिर्फ वही एनालाइज़ करें जो आपका अपना है, हर दावे को observation, inference या unknown का टैग दें, उसके पीछे का एड्रेस बताएँ, और बिना पास हुए टेस्ट के किसी भी रिकवर किए गए बिहेवियर को "कंप्लीट" न मानें।

1# नेटिव प्रोग्राम और गेम्स: Ghidra 12.1.x और JDK 21 या उससे नया
2    export GHIDRA_INSTALL_DIR=/absolute/path/to/ghidra_12.1.4_PUBLIC
3    export JAVA_HOME=/absolute/path/to/jdk-21
4    npx -y rea-agents@latest doctor --provider ghidra --json
5
6    # Android ऐप्स: JDK 17+ और jadx-headless-mcp 0.7.1
7    export REA_JADX_MCP_JAR=/absolute/path/jadx-headless-mcp-0.7.1-all.jar
8    rea inspect-android-package /path/App.apk
9
10    # स्मार्ट कॉन्ट्रैक्ट बाइटकोड, अभी के लिए Linux x64
11    rea inspect-evm-interface ./runtime.hex hex --json

03. रेकॉन: कोड से पहले मैप आता है

अभी तक एक भी फंक्शन न खोलें।

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

वही टेक्स्ट दिन भर में मिलने वाला सबसे तेज़ सुराग है: एंडपॉइंट्स, एरर स्ट्रिंग्स और फीचर नाम, कोई भी लॉजिक पढ़ने से पहले ही ऐप की कहानी बता देते हैं।

1rea.open_binary        { path: "/Applications/Target.app/Contents/MacOS/Target" }
2rea.binary_overview    {}
3  arch:        arm64
4  functions:   1,284 identified
5  entry:       _main @ 0x1000051c0
6
7rea.search             { query: "http" }
8  0x10004a2c0  "https://api.target.app/v3/sync"
9  0x10004a300  "Authorization: Bearer "
10
11rea.xrefs              { address: "0x100012ab0" }
12  147 references  ->  core config loader, called everywhere

REA गिनता है कि हर फंक्शन कितनी बार कॉल हुआ, और यही गिनती क्रॉस-रेफरेंस नंबर है

जो फंक्शन 147 बार कॉल हुआ वो ऐप की आर्किटेक्चर है, जो दो बार कॉल हुआ वो हेल्पर है जो इंतज़ार कर सकता है।

इसी नंबर के हिसाब से छाँटें और नीचे की तरफ बढ़ें, कभी फाइल ऑर्डर में नहीं, क्योंकि फाइल ऑर्डर ही वो तरीका है जिससे लोग ऐसे बाइनरी में पूरा वीकेंड गँवा देते हैं जिसमें सिर्फ चार दिलचस्प फंक्शन होते हैं।

04. एक फंक्शन डीकंपाइल करें, फिर Opus से उसके अंदर सब कुछ नामकरण कराएँ

डीकंपाइलर कच्ची मशीन इंस्ट्रक्शन्स को वापस C जैसी किसी चीज़ में बदल देता है।

यह थोड़ा अधूरा निकलता है: var_28 जैसे नाम, हर जगह casts, उलझे हुए branches, और अधूरा होना ठीक है, क्योंकि मॉडल को बस पढ़ने लायक चीज़ चाहिए होती है।

1# एड्रेस से एक फंक्शन, JSON में जिसे आप सेव करके दोबारा इस्तेमाल कर सकते हैं
2rea decompile /path/to/Target 0x100012ab0 --provider hopper --json > fn_config.json
3
4# या नाम से ढूँढें और उसके रेफरेंस फॉलो करें
5rea function /path/to/Target parseConfig --provider hopper --json
6rea xrefs    /path/to/Target 0x100012ab0 --provider hopper --json

फिर उस आउटपुट को Opus 5.5 को दें और उससे वो काम कराएँ जो डिसअसेंबलर नहीं कर सकता:

1यह 147 क्रॉस-रेफरेंस वाले फंक्शन का डीकंपाइल किया गया स्यूडोकोड है।
2
31. हर वेरिएबल का नाम उसके इस्तेमाल के हिसाब से बदलो, और उसका मकसद एक लाइन में बताओ।
42. वो डेटा स्ट्रक्चर्स की लिस्ट बनाओ जिन्हें यह पढ़ता और लिखता है, और उस पैटर्न का नाम बताओ जिसे यह फॉलो करता है।
53. इसे उस भाषा में साफ़ और सटीक कोड के रूप में दोबारा लिखो जिसका संकेत कॉलिंग कन्वेंशन्स दे रहे हैं।
64. अगर कोई एरर हैंडलिंग, इनपुट वैलिडेशन या सिक्योरिटी चेक छूटा है तो उसे फ्लैग करो।
7
8जवाब देने से पहले xhigh effort पर सोचो। जिस चीज़ में तुम्हें यकीन न हो, उसे मार्क करो।

Opus 5.5 पाँच effort लेवल के साथ आता है: low, medium, high, xhigh और max।

Medium जाँचता और नेविगेट करता है, high सामान्य फंक्शन्स पर नोट्स लगाता है, max ऑबफ़स्केटेड कोड और भारी pointer math के लिए है।

Effort इस पूरी पाइपलाइन का सबसे बड़ा क्वालिटी कंट्रोल है, और ज़्यादातर लोग इसे डिफ़ॉल्ट पर छोड़ देते हैं और फिर मॉडल को दोष देते हैं।

डीकंपाइलेशन बताता है कि कोड क्या करता है, मॉडल बताता है कि क्यों, और उसे दोबारा बनाने के लिए नाम क्या होंगे।

05. ऑबफ़स्केशन: जो तोड़ना ज़रूरी है उसे तोड़ो, बाकी का बजट बनाओ

कुछ ऐप्स ठीक उसी चीज़ को रोकने के लिए बनाए जाते हैं जो आप कर रहे हैं: लॉजिक इधर-उधर कर दिया गया, स्ट्रिंग्स एन्क्रिप्ट कर दी गईं, सिर्फ आपका ध्यान भटकाने के लिए नकली branches जोड़ दिए गए।

यह वो एक जगह है जहाँ बेहतरीन मॉडल भी अटकता है, और इसके पक्के आँकड़े मौजूद हैं।

Elastic Security Labs ने 20 टास्क में Tigress scrambler पर Claude Opus को लगाया, और उसमें से दो बातें सीधे निकलकर आईं।

एक फेल कोशिश की लागत सफल कोशिश से लगभग दोगुनी होती है, क्योंकि मॉडल हार मानने से पहले लगातार ज़ोर लगाता रहता है, और मल्टी-लेयर ऑबफ़स्केशन में सफलता शून्य रही, इसलिए इसे घिसते रहना कुछ न सीखने का सबसे महँगा तरीका है।

व्यावहारिक नियम यह है कि बजट हर फंक्शन के हिसाब से हो, सेशन के हिसाब से नहीं।

पहले फालतू हिस्सा हटाएँ, क्योंकि Caveman नाम का एक फ्री टूल डीकंपाइल किए गए कचरे का लगभग 75% हटा देता है और फिर मॉडल अपना ध्यान असली लॉजिक पर लगाता है।

1यह फंक्शन ऑबफ़स्केटेड लग रहा है। max effort पर काम करो।
2
31. मौजूद तकनीकों की पहचान करो (control-flow flattening, opaque predicates,
4   dead code, string encryption, function splitting) और यहाँ हर एक की तरफ इशारा करो।
52. उन्हें सुलझाओ: dead branches हटाओ, opaque predicates को evaluate करो,
6   dispatch को unflatten करो, अगर key मिल सकती है तो inline strings डिक्रिप्ट करो। दिखाओ कि क्या बचा।
73. 1-10 में confidence रेट करो। 6 से कम होने पर अनिश्चित हिस्सों के नाम बताओ और यह भी कि कौन सा context
8   उन्हें सुलझा सकता है। चुपचाप अनुमान मत लगाओ।

06. स्वार्म: एक कंट्रोलर, कई वर्कर्स

एक अकेली चैट 500 फंक्शन्स को अच्छे से नहीं पढ़ सकती।

वो भूल जाती है कि चालीस फंक्शन पहले उसने क्या देखा था, एक ही struct को तीन अलग-अलग नाम दे देती है, और चुपचाप खुद का ही खंडन करने लगती है।

इसका समाधान ज़्यादा context नहीं है, बल्कि रोल बाँटना है: एक कंट्रोलर जो काम बाँटे, और वर्कर्स जो एक-एक फंक्शन लें और वहीं रुक जाएँ।

1तुम एक रिवर्स-इंजीनियरिंग कंट्रोलर हो। फंक्शन मैप functions.json में है
2(address, name, size, xref_count)।
3
41. फंक्शन्स को call-graph की नज़दीकी के हिसाब से क्लस्टर करो; क्लस्टर्स को xref count के हिसाब से क्रमबद्ध करो।
52. हर क्लस्टर को एक वर्कर को भेजो। खुद कभी किसी फंक्शन का एनालिसिस मत करो।
63. पहले से resolve किए गए structs को हर brief में डालो ताकि नाम एक जैसे रहें।
74. 6 से कम confidence वाले को resolved पड़ोसियों के context के साथ दूसरा पास दो।
85. कुल token खर्च ट्रैक करो और हर क्लस्टर के बाद उसकी रिपोर्ट दो।
9
10तुम एक वर्कर हो। तुम्हें एक डीकंपाइल किया गया फंक्शन और अब तक resolve किए गए structs मिलेंगे।
11ठीक यही लौटाओ: address, purpose, confidence (1-10), structs_used, structs_new,
12clean_source, flags। मौजूदा struct नामों का इस्तेमाल करो, कभी उस struct के लिए दूसरा नाम मत गढ़ो
13जो कंट्रोलर तुम्हें पहले दे चुका है। सिर्फ एक फंक्शन। काम खत्म होते ही रुक जाओ।

REA में MCP सर्वर के अंदर गाइडेड वर्कफ़्लो भी बने हुए हैं जिन्हें ज़्यादातर लोग कभी खोलते ही नहीं:

• - investigate_feature - किसी फीचर को खोज से लेकर बिल्कुल सही फंक्शन्स तक ट्रैस करो
• - compare_application_versions - दो रिलीज़ का diff निकालो और देखो कि असल में क्या बदला
• - verify_reconstruction - अपने रीबिल्ड को सेव किए गए सबूतों से मिलाकर चेक करो
• - audit_residual_unknowns - उन चीज़ों की लिस्ट बनाओ जो अभी भी साबित नहीं हुई हैं

07. क्लीन रूम: दो contexts के बीच की दीवार ही असली प्रोडक्ट है

क्लीन-रूम रीबिल्ड का मतलब है कि आप ऐप क्या करता है उसे कॉपी करें, उसके अंदर का कोड कभी नहीं।

सही किया तो जो आप शिप करेंगे वो पूरी तरह आपका होगा, गलत किया तो आप किसी और का कॉपीराइट अपने रिपॉजिटरी में ढो रहे होंगे।

यह 40 साल पुराना तरीका है, 2026 की खोज नहीं।

80 के दशक की शुरुआत में Compaq ने IBM के BIOS को इसी तरीके से करीब 10 लाख डॉलर में दोबारा बनाया था, और यही एक वजह है कि दूसरे ब्रांड्स के PC मौजूद हैं।

1992 में Sega v. Accolade केस में कोर्ट ने कहा कि कोड को खोलना fair use हो सकता है जब उसे समझने का यही एक रास्ता हो, और 2000 में Sony, Sony v. Connectix में 3-0 से हार गया क्योंकि तैयार एमुलेटर में Sony का एक भी कोड नहीं था।

लाइन का दूसरा हिस्सा भी उतना ही साफ़ है: 2011 में George Hotz ने Sony के साथ समझौता किया और PS3 root key पब्लिक होने के बाद रुकने पर राज़ी हुए।

चार नियम आपको सही रास्ते पर रखते हैं, और ArtCraft टीम हर बिल्ड पर इन चारों को ऑटोमैटिकली चेक करती है:

• - देखो, कॉपी कभी मत करो। टारगेट को black-box की तरह चलाओ, सिर्फ उसकी अपनी विंडो का स्क्रीनशॉट लो, उसका कोड कभी अपने प्रोजेक्ट में पेस्ट मत करो
• - सोर्स नहीं, स्पेक्स। फाइल फॉर्मेट्स पब्लिक स्टैंडर्ड्स से आएँ (OOXML यानी ECMA-376 / ISO 29500, साथ में पब्लिश्ड RTF और ODF स्पेक्स), कभी किसी प्रतिद्वंद्वी के parser को पढ़कर नहीं
• - सिर्फ ओरिजिनल assets। हर आइकन, फॉन्ट, टेम्पलेट और साउंड कोड में बनाया गया हो, public-domain हो या ओपनली लाइसेंस्ड हो, और attribution फाइल में उसकी एक लाइन हो
• - दोनों कामों को अलग करो। एक एजेंट बिहेवियर निकाले और spec लिखे, एक अलग context सिर्फ उसी spec से इम्प्लीमेंट करे

आखिरी नियम ही वो है जिसे लोग छोड़ देते हैं, और यही असली सीमा है।

आपका जाँच करने वाला एजेंट परिभाषा से ही "दूषित" है, क्योंकि उसने डीकंपाइल पढ़ा है, और आपका बनाने वाला एजेंट ऐसा नहीं होना चाहिए।

1पूरे हुए एनालिसिस से, रीइम्प्लीमेंटेशन के लिए एक क्लीन-रूम स्पेसिफिकेशन लिखो।
2
3सिर्फ BEHAVIOR बताओ: हर public interface, डेटा मॉडल, यूज़र को दिखने वाला हर
4फीचर एक टेस्टेबल requirement के रूप में, पढ़े और लिखे जाने वाले फाइल फॉर्मेट्स, एरर हैंडलिंग।
5
6एड्रेस, offsets, डीकंपाइल किए गए वेरिएबल नाम, assembly, या ओरिजिनल से कॉपी की गई
7कोई भी चीज़ शामिल मत करो। जिस डेवलपर ने कभी बाइनरी नहीं देखा, उसे सिर्फ इसी डॉक्यूमेंट से
8कम्पैटिबल वर्ज़न बना लेना चाहिए।
9
10सेक्शन्स: Architecture, Data Model, Public API, File Formats, Test Cases।

किसी विवरण से काम करना सिर्फ कानूनी सुरक्षा नहीं है।

यह आपको अपनी भाषा के लिए सही फैसला लेने देता है, बजाय इसके कि आप वो फैसले विरासत में लें जो किसी ने दो दशक पहले लिए थे, और यही वजह है कि कुछ जगहों पर WordCraft, Word से तेज़ है।

08. पैरिटी वेरिफ़ाई करें, फिर इसे MCP के ज़रिए शिप करें

आपके पास ओरिजिनल सोर्स कभी था ही नहीं, इसलिए आप लाइन-बाय-लाइन diff नहीं निकाल सकते।

आप बिहेवियर की तुलना करते हैं: दोनों बिल्ड्स में एक जैसे इनपुट डालो, एक जैसे आउटपुट वापस आने चाहिए।

1ओरिजिनल बाइनरी और मेरे रीबिल्ड की तुलना करने वाला एक behavioral test harness बनाओ।
2
350 इनपुट जनरेट करो: 30 सामान्य, 10 edge (खाली, max size, unicode), 10 error
4(गलत बनावट वाले, corrupt)। हर एक को दोनों से चलाओ, जहाँ हो सके byte-for-byte तुलना करो
5और बाकी जगह semantically। match rate, अंतर, और हर एक की severity
6(cosmetic / behavioral / critical) की रिपोर्ट दो। report.md में सेव करो।

"मुझे लगता है यह मैच करता है" सबूत नहीं है, match rate सबूत है, और वो रिपोर्ट सबसे भरोसेमंद चीज़ है जिसे आप किसी रिलीज़ पोस्ट के ऊपर रख सकते हैं।

फिर रीबिल्ड को उसी तरह रिलीज़ करें जैसे REA और Craft ऐप्स ने किया, एक MCP सर्वर के रूप में, ताकि अगले व्यक्ति का एजेंट आपके टूल को वैसे ही चला सके जैसे आपने REA को चलाया।

हर फंक्शन को एक साफ़ नाम और एक-लाइन इंस्टॉल दें, और हर action एक named command बन जाएगा जिसे एक क्लिक, एक शॉर्टकट और एक एजेंट बिल्कुल एक जैसे ट्रिगर करेंगे।

1claude mcp add wordcraft -- wordcraft-cli mcp
2
3> report.docx खोलो, हर heading 14pt bold करो, PDF में export करो
4  ok  select.all-headings -> 12 selected
5  ok  format.font-size 14 . format.bold
6  ok  export report.pdf (selectable text, bookmarks kept)

सीमाएँ, और वो पाँच गलतियाँ जो पूरा वीकेंड बर्बाद कर देती हैं

REA सर्वर को छू नहीं सकता, क्योंकि यह वही पढ़ता है जो आपकी मशीन पर है, और किसी कंपनी के सर्वर पर चलने वाला कोड कभी आपको शिप ही नहीं किया गया था।

डीकंपाइल किया गया कोड एक पुनर्निर्माण है, ओरिजिनल सोर्स नहीं, और यही पूरी वजह है कि स्टेप 08 मौजूद है।

Stripped C++ बाइनरी Unity .NET गेम्स से कहीं ज़्यादा मुश्किल रहते हैं, और कमर्शियल इंजन्स को आज भी असली लाइसेंस चाहिए।

• - Electron ऐप पर डिसअसेंबलर खोलना जब JavaScript वहीं मौजूद हो
• - सारा बाइनरी डंप कर देना, सारांश पढ़ने से पहले, जिससे लॉजिक दब जाता है और बिल बढ़ जाता है
• - क्रॉस-रेफरेंस काउंट की जगह फाइल ऑर्डर में फंक्शन्स पढ़ना
• - मॉडल को कोड आपके रीबिल्ड में कॉपी करने देना, जो एक पेस्ट में क्लीन रूम तोड़ देता है
• - पैरिटी रिपोर्ट के बिना शिप करना

कानूनी पक्ष की ईमानदार बात, क्योंकि X पर आधे लोगों ने एक हफ्ता पाइरेसी को लेकर शोर मचाया: अपने कंप्यूटर पर किसी ऐप को पढ़ना सीखना है, उसके बिहेवियर से फीचर दोबारा बनाना वो तरीका है जिससे 80 के दशक से इंडस्ट्री काम कर रही है, और कोड कॉपी करना या पेड फीचर्स को क्रैक करना वो हिस्सा है जिससे आप पर केस होता है।

ओरिजिनल को पढ़ो, अपना खुद का शिप करो।

इन आठ स्टेप्स में से हर एक का पूरा लेसन यहाँ मौजूद है

reacourse.xyz , बिल्कुल सही प्रॉम्प्ट्स, फेलियर मोड्स, और वो हिस्से जहाँ यह काम करना बंद कर देता है, सबके साथ।

पहले closed source का मतलब होता था कि आप कभी नहीं जान पाएँगे।

अब इसका मतलब है — मुझे सबूत दिखाओ।

ज़्यादातर लोग उस फीचर के लिए हर महीने पैसे देते रहेंगे जिसे वे एक दोपहर में समझ सकते थे और एक वीकेंड में दोबारा बना सकते थे।

जो कुछ लोग सॉफ़्टवेयर पढ़ना सीख लेंगे, वे जो चाहेंगे वो बनाएँगे।

मुझे फॉलो करें और मेरे Telegram चैनल को सब्सक्राइब करें:

https://t.me/+75nMf005jRpjMDU1