Trading Bot Brotherhood Intelligence.

The internet has a familiar trading-bot story. Feed in a little money, let AI work while you sleep, and wake up to a five-figure profit. The title says Rs 10 lakh a month. The screenshots never show the capital, fees, slippage, drawdown, or the losing days.

I reviewed a different kind of build: a six-prompt workflow for a TypeScript and Node.js paper-trading bot. It uses real market data, keeps live orders out of the project, builds a no-memory baseline first, and only then adds a small memory layer. That is a good engineering sequence. It is not proof of a profitable strategy.

1. Start with the evidence, not the thumbnail

The source material is a prompt pack, not a verified performance report. It specifies what an agent should build and what it should report. It does not provide a completed out-of-sample track record, a live account statement, or a capital-and-return calculation that supports Rs 10 lakh per month.

That distinction matters. A design can be careful and still produce a losing strategy. A clean dashboard can make a bad backtest look respectable. Before believing any performance claim, ask four questions:

• How much capital was used?
• What exact market, timeframe, and date range were tested?
• Were fees, slippage, spread, and rejected orders included?
• What happened on data the strategy did not use to tune itself?

If those answers are missing, the right label is unverified experiment, not passive income.

2. What the v2 workflow actually builds

The workflow is deliberately gated. Each prompt produces an artifact that can be checked before the next stage begins. The full copy-paste prompts are included in the companion download below, so this page explains the system without hiding the actual build instructions.

1. Connection check. Verify the venue and MCP or API in paper mode with read-only smoke tests. No order is placed.
2. Strategy backtest. Define the market, timeframe, entry and exit rules, risk rules, fees, and slippage before code becomes the source of truth.
3. Instructions file. Convert the trader's actual preferences into explicit rules, limits, and a definition of done.
4. Raw build. Build a complete paper bot with real public market candles and no memory layer.
5. Memory comparison. Add a ledger and plain-English lessons, then run the raw and memory paths side by side.
6. Experiment-ready finish. Add a README, environment template, reset command, and guardrails against accidental live orders.

The default example is BTCUSDT on a 5-minute interval with a 9-period and 21-period moving-average crossover. That is a starting hypothesis, not a discovered edge.

3. How to set it up

Use the prompts in order inside Claude Desktop, Claude Code, Claude in the browser, Cursor, or another MCP-capable client. Prompts 01 through 03 stop for your answers and confirmation. Prompts 04 through 06 create files and run checks only after that groundwork exists.

1. Prepare a safe workspace. Use a local TypeScript and Node.js project. Keep secrets in the client configuration or a server-side environment file, never in the prompt, browser, or frontend.
2. Complete the connection check. Confirm paper or test mode, verify account status, balances, positions, open orders, and market data with read-only checks.
3. Backtest before building. Test the strategy in TradingView. Include fees, slippage, explicit rules, and an out-of-sample window where possible.
4. Write the instructions file. Let the interview produce trading_bot_instructions.md. Review it before any code is generated.
5. Build the raw baseline. Run npm install, npm run scan, and npm run replay:raw. Record the real metrics.
6. Add memory and compare. Create ledger.csv and learnings.md, then run npm run replay:memory beside the raw path.
7. Finalize and reset. Add README, .env.example, .gitignore, guardrails, and npm run memory:reset. Verify that an empty memory returns HOLD rather than inventing a lesson.

4. Why the no-memory baseline comes first

Adding memory before measuring the raw strategy makes it impossible to tell what actually helped. The first run therefore has no ledger.csv, no learnings.md, and no adaptive filter. It fetches real candles, detects actual crossover events, simulates paper execution, and reports what the data says.

The required output is boring by design: total setups, wins, losses, win rate, average PnL, best trade, worst trade, and drawdown where the data supports it. If there are not enough setups, the bot should say that. If the strategy loses, it should say that. A system that cannot admit “not enough evidence” is not ready to trade.

5. Memory is a journal, not intelligence

The memory layer is the most useful idea in the build, but it needs a precise name. It is not a mind that understands markets. It is an auditable journal plus a filter.

ledger.csv records the timestamp, symbol, action, price, quantity, reason, mode, outcome, and PnL. learnings.md stores plain-English lessons from real paper or replay outcomes. Before a future BUY or SELL, the bot checks whether a similar setup has lost before and whether the lessons file contains a matching warning.

If the evidence matches, the final decision becomes SKIP and the reason is logged. If no real warning exists, the memory path should HOLD or tell you to keep paper testing. It must never seed fake losses to make the new version look smarter.

That is disciplined journaling. Calling it “the bot learned a strategy” would overstate what is happening. A skip filter can also over-block and miss a future winner, so it needs its own out-of-sample review.

6. The risk model is the part thumbnails hide

A win rate without a risk model is almost meaningless. The project needs configurable quantity, maximum position, stop or invalidation rules, maximum daily loss, and a drawdown limit before anyone discusses live money.

Fees and slippage belong in the test. So do spread, partial fills, latency, exchange outages, and the tax treatment that applies to the trader's jurisdiction. These are not polish items. They decide whether a small theoretical edge survives contact with execution.

There is also a simple capital reality check. A target return is inseparable from the capital and risk required to chase it. If someone promises Rs 10 lakh per month without stating both, they are selling an outcome, not explaining a system.

7. What this bot can prove

After a clean run, the workflow can give you evidence about process:

• The connection stayed in paper or test mode.
• The strategy rules were explicit and reproducible.
• The raw path used real market data rather than invented candles.
• The memory path changed decisions only when real prior evidence supported the change.
• The final project has visible guardrails and no secret keys in frontend code.

It still cannot prove that the next month will resemble the last one. Markets change. A strategy can decay. A backtest can be overfit. Paper fills can be kinder than live fills. The responsible conclusion is therefore narrow: the experiment is better controlled. The profit question remains open.

8. The build order I would keep

I would keep the six-stage order and change the marketing around it. Call the first run a baseline. Call the memory layer an evidence-backed filter. Publish the exact test window and assumptions. Show the losing trades as clearly as the winning ones. Then run a fresh date range that the strategy did not use while it was being tuned.

The strongest output may be a string most trading content avoids:

That is not a failure of automation. It is the first sign that the automation is being treated like a system instead of a slot machine.

9. The critique additions that make it stronger

The companion critique changes the standard trading-bot story in three blunt ways. First, a headline such as “make Rs 10 lakh a month” needs capital, win rate, drawdown, fees, slippage, and a test window before it deserves to be treated as evidence. Without those numbers, it is a marketing claim.

Second, the memory layer is not a self-improving trader. In this design it is a journal plus a conservative skip filter. It blocks a setup only when a real prior paper or replay loss and a matching lesson support the decision. That filter can over-block and miss a winner, so it needs its own out-of-sample review.

Third, the risk model is not a footnote. Quantity, maximum position, stop or invalidation rules, maximum daily loss, drawdown, commission, spread, slippage, latency, outages, and the applicable tax treatment belong in the experiment before anyone discusses live money.

10. Download the complete prompt pack

The companion PDF contains the six original prompts in full, the file names and commands they expect, and the critique additions that keep the build honest. It is the practical setup document; this article is the explanation and review.

Final take

An AI trading bot cannot create an edge because the prompt sounds confident. It can, however, make the experiment repeatable, keep a record of decisions, and stop the same mistake from being repeated without explanation.

That is a worthwhile project. It is also a much more honest promise than Rs 10 lakh while you sleep.

This article is for education and software review only. It is not financial advice, a recommendation to trade, or evidence of future performance. The underlying workflow is paper-trading first and contains no live-order path by default.