Operating Layer / 002

Eight Days With GPT-6 Astra

A founder field report on using Codex, Astra, model routing, and daily AI operations to move real work forward.

Eight Days With GPT-6 Astra cover showing a bright galaxy and operating layer headline
  • 8days in stack
  • 10xphone-to-Codex leverage
  • 3game prototypes
  • fullsocial suite

I have been using GPT-6 Astra for the last 8 days.

My honest take: this is the first model that feels less like “AI help” and more like an operating partner.

That is not a small statement.

I have been building with AI every day since the 2022-2023 era. Across creative work, websites, games, audits, social, launch operations, side projects, experiments, and the strange little fires that come with building anything real, Codex has become my daily partner and executive assistant.

Astra feels like the next jump in that relationship.

The Unlock Is Movement

The biggest unlock is not the model being “smart.”

Smart is table stakes now.

The unlock is movement.

I can be away from the desk, on my phone, in between errands, standing in line, or sitting with a spare five minutes, and still push work forward.

I give Codex simple commands remotely and it can take action across the stack: draft this, check that, audit this folder, build that prototype, post this, find the blocker, verify the live link, clean up the workflow, turn that rough idea into something usable.

That ability alone has probably increased my productivity 10x.

It feels like I am dialed into everything at once: projects, code, websites, campaigns, audits, social, files, next actions, and the operational mess that normally eats half the day.

I know that sounds hard to explain.

It is.

But if you know, you know.

This is not just chat anymore. This is command, coordination, execution, verification, and iteration.

What We Created In 8 Days

In the last 8 days, using Astra and Codex inside the stack, I have moved through work that normally would require a full team.

  • Built 3 game apps and prototypes.
  • Built a full interactive website experience.
  • Audited current projects and active workstreams.
  • Ran full audits across personal laptops and desktops.
  • Reverse engineered and recovered parts of a few apps.
  • Created and organized a full social media suite.
  • Posted and prepared content across major platforms.
  • Improved game and beta launch workflows.
  • Developed cinematic creative prototypes.
  • Expanded a private founder operating system.

Most importantly, scattered founder thoughts became code, copy, campaigns, pages, systems, and next actions.

That last part matters most.

The real value is not that AI can generate a thing.

The value is that it can help close loops.

A draft is not done.

A deploy is not live until checked.

A post is not posted until the public URL is verified.

A local file is not the same thing as a finished product.

That is where Astra starts to feel different.

It can stay with a messy task across files, browsers, notes, code, creative direction, screenshots, accounts, and verification.

It does not just answer. It helps operate.

The Stack Matters

One of the first things I did was set up global model-routing rules in my stack.

Before taking action, the system identifies which model fits the task.

Not every task needs the strongest model.

Some work needs speed.

Some needs cost control.

Some needs deep reasoning.

Some needs browser or computer use.

Some needs careful verification.

That routing layer matters because tokens are real.

I have already run out twice, so yes, lesson learned.

You cannot treat every task like it needs the biggest engine in the room. Sometimes you need fast execution. Sometimes you need a careful reviewer. Sometimes you need a builder. Sometimes you need someone to click through the boring stuff and confirm what is actually live.

That is the new skill.

Not prompting.

Operating.

What I Love

What I love most about Astra is the follow-through.

The best AI tools are not just clever.

Clever is fun, but clever does not ship.

Follow-through ships.

Astra is strong at staying with complicated work across multiple surfaces. It can help shape an idea, turn it into an asset, write the copy, place it into a workflow, check the destination, correct the mistake, and keep going.

That matters when you are building across creative, software, social, publishing, product, and operations all at once.

Most people do not need “more ideas.”

They need help turning 47 open loops into 5 finished outcomes.

That is where this starts to feel serious.

My Gripes

It is still new.

Access and model switching can be confusing. Browser and account work still has friction. Some workflows still need babysitting. Sometimes the model needs to be reminded that done means verified, not almost done.

And yes, Astra can over-engineer simple tasks.

That one is real.

My stack has included Claude/Fable, Codex Sol, and now Astra. One reason I moved away from Claude/Fable as my main engineering partner was that it could overcomplicate simple work. A small task could turn into a large system.

Sol was better for me in that lane because the pattern was often simple:

Prompt.

Action.

Approval.

Done.

With Astra, I am seeing some of that over-engineering come back in certain tasks.

Nevertheless, I am training it.

Because that is the part people miss.

The operator still matters.

You have to set the rules. You have to define what “done” means. You have to route the work. You have to keep the system honest. You have to know when to say: this does not need architecture, this needs execution.

The magic is not just generation.

The magic is disciplined execution.

The Bigger Picture

AI is no longer just helping me make content.

It is helping me build the company around the content.

That is the shift.

It is not about replacing the founder, the artist, the engineer, or the operator.

It is about giving one person more leverage than they had yesterday.

Astra feels like a major step forward, but it is not magic by itself.

The model matters.

The stack matters.

The rules matter.

The operator matters.

And when all of that starts working together, things get weird in the best way.

Eight days in, my take is simple:

AI is becoming less like a tool you open.

It is becoming the operating layer you build with.