I Think I’ve Been Using GPT-6 Astra Wrong

I think I’ve been using GPT-6 Astra wrong this entire time. I kept giving it the same job I’ve given the strongest model available for the past several years: understand everything, plan everything, write everything, fix everything, and somehow keep all my rules straight along the way.

I got so hung up on people one-shotting things that I kept trying to make that approach work for projects with existing code, a backlog, and a UI I’ve already spent a lot of time getting right. There are plenty of places where a technically correct change can still be the wrong change.

To those of you who follow me and have listened to me groaning since Astra came out, I owe you an apology. I was still stuck in “Man make fire” mode: give the more powerful model a bigger prompt and expect it to do everything. I feel a little dumb that it took me this long to change the assignment.

It’s like asking Eisenhower to storm the beaches of Normandy himself. His strength was in planning the operation, coordinating the forces, and putting the right people in position to carry it out. I had Astra down in the foxhole working through every task while also expecting it to keep the whole operation in its head.

I’m getting much more value from having it understand the project, assign the work, review what comes back, and decide what can happen next.

What I’m doing now

In Codex, I have Astra read the project documentation, inspect the actual code, and reconcile that with the open issues. I’ve used Astra up to Extra High reasoning for this work. It then breaks the implementation into assignments for GPT-5.6 Sol, generally using Medium reasoning.

I usually run three to five independent tasks at a time. Astra gives each one the relevant context, a defined scope, the rules it must follow, and a concrete way to prove the work is done.

For example, a batch might have three separate assignments: update product terminology without changing the UI, build a read-only database diagnostic, and extract a still-useful integration from an old branch without bringing back obsolete code. Each should produce its own focused pull request.

That is a much better fit for how I work than asking one model to carry the whole backlog through one long conversation.

I’m seeing work come back faster because several independent pieces can move at once. Three to five threads describes the concurrency. I haven’t run a controlled before-and-after benchmark, and dependencies, review, and integration still take time.

Give Astra responsibility for the handoff

I already have guardrails and standard operating procedures covering things like preserving unrelated work, reading the architecture, following the design system, and testing the behavior that changed. They also cover the mistakes I want to avoid, like turning a small fix into a redesign or calling something shipped because a test passed.

I now have Astra turn those rules into specific instructions for each assignment. The task updating visible wording needs an explicit instruction to preserve layout, interactions, routes, and stored identifiers. The database task needs an explicit instruction to inspect without modifying retained data. “Follow my SOPs” is a lot less useful than telling each task which parts apply and what evidence to return.

Astra still has to follow those rules itself. It also has to check the work it delegated. Moving the code into another task doesn’t remove that responsibility.

These are the kinds of prompts I’m using. They’re templates to adapt to your own repo and permissions.

1. Read the project and divide the work

1Read the repository instructions, architecture docs, and open issues.
2Inspect the current code before deciding what is missing. Separate
3implemented work from partial work, unverified claims, and actual gaps.
4
5Build a dependency-ordered plan. Identify three to five tasks that can
6run independently. For each, define the outcome, scope, files or
7interfaces it owns, relevant guardrails, and completion checks.
8
9Preserve the current UI. Raise product decisions that need my input,
10and keep working on items that do not depend on those answers.

2. Delegate the implementation

1Delegate the ready tasks to GPT-5.6 Sol with Medium reasoning.
2Start with three; expand to five when the work is independent.
3
4Give each task the relevant source documents, an isolated working
5branch, explicit boundaries, and the applicable repository rules.
6Serialize overlapping changes. Do not assign two tasks ownership
7of the same migration or shared interface without coordination.
8
9Require local checks, rendered verification for UI changes, and
10a focused pull request with evidence and known limitations.
11Preserve unrelated changes. Do not enable GitHub CI in this repo.
12If the requested model is unavailable, tell me before substituting.

3. Finish the workflow and keep it moving

1Review each completed task's actual diff and verification evidence.
2Fix findings and run any missing checks. Merging ordinary verified
3PRs is already authorized; complete the merge and verify it landed.
4Honor explicit draft-only and owner-decision boundaries.
5
6Start the next dependency-ready assignments while completed work
7is being reviewed. Keep the issue tracker accurate.
8
9Create a 15-minute scheduled check-in and verify it is active.
10Check for finished, blocked, or idle tasks and continue the backlog.
11Notify me about meaningful results or decisions I need to make.
12Stay quiet when nothing changed. Stop the schedule when the work
13is complete or only items requiring my input remain.

“Done” needs to include what happens next

I hit another part of this myself. The delegated tasks produced pull requests, but those pull requests were still sitting open after I had authorized merging verified work. I had to make the follow-through explicit.

That left me looking at the old version of the app while completed changes waited elsewhere.

So I’m making the whole sequence explicit: implement, verify, review, merge when authorized, and update the preview. The next independent batch can start while that review happens. A draft that I explicitly asked to keep open stays a draft.

In Codex, I can also have Astra schedule follow-ups. It described that as: “A quiet 15-minute coordination check will keep reviews, merges, and subsequent work moving.” Those checks can identify tasks that need review, help with a blocker, or their next assignment. I want them to move the workflow forward and tell me when I need to make a decision. I don’t need a notification every 15 minutes saying that work is still happening.

I’m still responsible for the product decisions and the boundaries. I’m also spending less of the process asking one model to switch between architect, implementer, reviewer, and project manager in the same conversation.

This is a fresh lesson for me. As the models get better, I need to question all my assumptions about how to use them. We’re entering uncharted territory, and I want to give myself room to think freely instead of forcing every new model into the job I gave the last one.

If you’ve been working the way I was, try this on one backlog you know well. Give Astra the planning and coordination work, give Sol a few clear implementation assignments, and define completion all the way through review and merge. Then check whether more usable work reaches you with less intervention.

Start small, think big.