Practical Tips for Using Astra AI Productively

Astra: the good, the bad, and the Fable.

Here’s my own practical advice for using Astra and how I’ve become way more productive with it....

The Good:

(For a TL;DR, jump to “Some tips.”)

Astra is very smart in a “big model” sort of way. I’ve heard so many rumors about this, but it seems like the consensus guesstimate is a ~5–10T parameter model with >1T active parameters. You can feel the difference immediately because it can do things it wasn’t directly RL’d to do way better than a smaller model. It makes better plans and finds novel solutions better than any model I’ve used to date.

This increase in “native” intelligence is most obvious when you ask it to solve a problem. Just like a seasoned engineer, it has excellent “path-finding.” It takes very efficient paths to solving any given problem. Weaker models can solve the same kind of challenges, but they do so through brute force, constantly trying (mostly bad) ideas until something works. Astra often feels “fast” (even though it isn’t) because of this intelligence.

In some domains, the jump from 5.6 is massive. 3D modeling and CAD is a largely solved problem at this point. This means a whole new class of engineers (mechanical/electrical) will begin to feel the same joys and pressures we’ve felt in software engineering. You can just print things now.

If you haven’t started using Astra with computer use, you haven’t tasted the AGI popsicle. It’s mind-blowing. Astra is the first model that can really take on “any” work and do it well.

In a lot of ways, Astra breaks the benchmarks, which I’m so thankful for. The fact that Astra scores the same on artificial analysis as significantly weaker models helps show what a bunch of BS all the benchmarks are and how hard everyone is benchmaxxing.

Another really cool thing about Astra is its ability to steer mid-turn. Sometimes, if you pay attention, it’ll ask you questions in Codex while it’s working that you can answer…or not. This is kinda helpful, although I don’t want to babysit threads, so I often find I’m not responding. Still, it’s cool it can do this.

The Bad:

Astra also has some bad habits. You know how the literal meaning of “can you walk the dog?” is “are you physically capable of walking the dog?” but we all interpret it as “will you please walk the dog?” Astra doesn’t. It’ll let you know it’s capable of writing that code, but you have to ask it to actually do so (read below for some ways to correct for this).

Sol was relentless. It wasn’t nearly as smart, but to a fault, it wouldn’t give up. Astra, on the other hand, is lazy. Lazy in the same way that Fable 5 was lazy. Maybe this is a “big model” trait, but they tend to look for ways to not do the work you have for them to do. If there is a place to stop, Astra is happy to take a breather.

Frankly, you might want Astra to take that breather too, because it’ll burn your usage faster than a cocaine-powered flamethrower.

Astra is also still trash at interface design. To be clear, it can create a good UI, but it doesn’t do that on its own. It needs constant cajoling, fine-tuning, and babysitting to get exactly what you want.

Unfortunately, Astra has also inherited Sol’s propensity for over-engineering. Try this: Ask Astra to write a little chat room using Cloudflare Durable Objects. Then do what I never do anymore and go look at the code. You’ll be blown away by the PhD-level complexity it will have baked into this little task. Complexity even it won’t fully understand and that will lead to breakage eventually.

Some tips:

I usually ignore OpenAI’s “Model guidance” documentation because I’m able to find my own way with a given model, but with Astra it’s been particularly helpful. They describe a lot of Astra’s laziness as being a “more effective collaborator,” but if you want your agent to actually do work, they also say to start with a prompt like this:

“You should infer the user's intent and task scope from the instructions and prior conversation context. Your job is to bias towards action and carry the user's intended task to completion.

When the user expresses intent to perform new work or fix an existing issue, persist until the user's intended goal is complete. Progress autonomously towards the user's goal (e.g. creating isolated worktrees / checkouts if needed, resolving merge conflicts, read-only actions, creating draft PRs etc.) unless they are clearly destructive or irreversible.”

It works. Sometimes it works too well. Last week I asked it to set up a build process for a macOS and Linux app. It decided on its own that it should use a Linux computer for the Linux part of the build. It found some SSH keys on my machine and SSH’d into an Ubuntu VPS I use for hosting…it then set up the entire build process there and started building releases from that machine. I was not pleased, but on the other hand, I guess it didn’t stop and ask me what I wanted to do.

Another key to success is to use low reasoning…almost always. Astra on low is smarter than Sol on xhigh and way faster. I burned through an entire week’s usage using Astra on high my first day. I know you don’t like the sound of putting my co-worker on “low” mode, but we just have to get over it.

To combat that nasty over-engineering habit, you sadly have to use a skill. There are tons of these out there. I’m not even going to recommend one here. Sol-era skills work fine for this, just something to say, “Bro, really? Simplify this, please.”

I’ve also typically found that Astra, while a great coordinator, doesn’t really do any “better” when using subagents. You might be able to parallelize a lot of work and chew through it faster, but it’s so smart it tends to path-find to the correct answer faster in a single thread than many threads. I’m sure folks will disagree with me on this, but give it a try yourself.

So what about Fable? Has it been completely trounced? Well, Astra does feel a touch “smarter” than Fable, but the Fable 5.1 release fixed most of its older brother’s behavior issues. And the truth is: as a software engineer, I trust Fable’s output more than Astra’s. If you have a loop running, just chewing through issues on your repositories, both models are up to the task, but if I can only pick one to write my code, it’s Fable. If I had to pick one model for literally anything else, it’s Astra (and it’s not even close).