After I switched this project to GPT-6 Astra, the pace picked up noticeably. Things that had kept coming back as unfinished finally got implemented, tested, and put into the running system.

That's my experience on this project, not a scientific model comparison. Astra inherited days of work, a pile of records, and a much clearer list of problems. But from my side of the keyboard, the difference was obvious.

I asked it to inspect what we'd actually built. Not admire the plan. Look at the code, follow a strategy through the system, and find the parts that didn't agree.

The part I didn't know to ask about

I'm an IT guy, not a trading-system engineer. When the bot said we had researched strategies and backtested them, I figured those same strategies were what the paper desk would trade.

That was not safe to assume. A research script could test one set of rules while a paper-trading ticket used different exits or timing. Both pieces could run without errors. They just weren't testing the same thing.

We also had strategy ideas without complete instructions a computer could execute. “Buy when this looks good” leaves a lot unanswered. When do you enter? What makes you leave? What does the trade cost? What happens if the data stops arriving?

I shouldn't have needed to discover those requirements one complaint at a time. The engineering bot should have raised them early. My part in it was pushing for more agents, more indicators, and more activity before we'd proved one whole trade could make it through correctly.

We had built a lot of the company before making sure its basic job worked.

What finally got connected

The last push concentrated on three unfinished pieces.

  • Give the research usable instructions. Ten selected strategy families now have explicit, versioned paper-trading rules. Historical tests and paper operation use shared signal code. Change the rules and it's a new version, not an excuse to reuse an old good-looking score.
  • Stop giving the simulator easy answers. Historical replay accounts for trading costs, limited available quantity, price gaps, and movement inside a price bar. It doesn't get to assume every order fills at the nicest price on the chart.
  • Finish the learning handoff. A separate worker can test a tightly limited change against its parent strategy, save both results, and leave a record. It cannot declare itself a winner and start trading real money.

Some fixes were ordinary bugs with misleading consequences. A report was using the wrong account basis. A simulated target could receive an overly favorable fill. An exit needed to stay pending when there wasn't enough quantity available, rather than pretend the whole position had closed.

That's the stuff I wanted the stronger model digging into. Not another paragraph telling me the architecture was promising.

What “finished” meant this time

At the September 7 checkpoint, 519 automated tests passed. Twenty historical replay runs covered the ten contracts under normal and increased trading costs. Those are engineering checks, not twenty winning strategies.

The independent worker completed an explicitly labeled commissioning job and saved its report in the database. Running it again didn't repeat the finished work. Its schedule was active, and the deployed dashboard, database, and market feed passed their health checks.

It wasn't flawless on the first try. The new worker's startup script had a syntax error. That got fixed, and a test was added to catch that kind of error. Switching models didn't remove the need to verify the actual installation.

The trading remains simulated. Historical fills are still a model of what could have happened, not a recording of every order available at the time. Fresh statistical evidence takes time to collect. Nothing here proves we found a profitable strategy.

The single prompt I wish I'd started with

The final request was basically: finish the three remaining gaps. That worked because the project and its records already existed. It was not one sentence building this whole thing from nothing.

For someone starting over, this is the cleaned-up brief I'd use. It's a reusable version, not a dump of my private setup:

Act as my engineering lead. I want a crypto research and paper-trading system. I'm not a trading expert, so identify missing requirements and propose sensible defaults instead of waiting for me to discover them.

First make one strategy work all the way through: verified data, realistic historical testing, simulated entry and exit, correct accounting, and a simple screen showing what happened and why. Use the same trading rules in testing and operation. Include costs and deliberately bad scenarios.

Prove that path works before adding more strategies or agents. Keep research suggestions separate from the software that controls money and permissions. No real orders, wallet access, or transfers. Ask me to set spending and risk limits before unattended work starts.

Work through the implementation, use parallel help where useful, keep a changelog, and verify the deployed system. Stop repeating the same failure. Show me what's working, what's blocked, and what still needs evidence. Don't promise profit or manufacture activity to make me happy.

I still have to decide what I'm willing to spend and risk. A prompt can't make those decisions disappear. It can stop me from having to act as the project manager for every little connection.

What I'd do differently

I'd get one boring, complete example working first. Then three. Then bring in more agents to do useful work through that tested path.

I'd also ask for periodic audits of the running system, especially after changing models. Show me the evidence behind “done.” A working function isn't a working service, and a working service isn't proof the business idea makes money.

Astra helped us clear the remaining implementation hurdles in this pass. Now the experiments have a better chance of telling me the truth, including when an idea is crap. That's actual progress. The money question is still open.

Earlier notes: the expensive testing loop, why I built an agent company, and why historical testing isn't the finish line.