The workflow that’s working best for me lately is this:
Start work from Grok Bot on my phone, then monitor and steer the whole process from the same place.
I compress requirements in ChatGPT Pro into a ZIP, hand that pack to Grok Bot as the Chief of Staff, then run delivery through:
Grok Bot
↓
Linear
↓
Cursor Cloud Agents
↓
Codex
I call the loop:
Plan → Write → Ship → Steer
PWSS
The point is not “one model does everything.”
It is to separate roles and assign each seat to the model that is strongest there.
Requirements → ChatGPT Pro
Chief of Staff / orchestration → Grok Bot
Planning → Claude Fable
Implementation → Grok
Acceptance → Codex Astra High
ChatGPT Pro — compress requirements
Long threads, constraints, counterexamples, reference images, prior decisions.
These get compressed into one ZIP containing things like:
start instructions
implementation guidance
audit notes
offline tests
constraints
non-goals
verification criteria
The purpose is simple:
what
why
what we are not doing
how we will verify it
The ZIP becomes the source of truth before implementation starts.
Grok Bot — Chief of Staff
Grok Bot is the front door.
It takes the ZIP, or a short /goal with:
outcome
why now
success checks
constraints
non-goals
repo
verification
stop conditions
Then it creates:
1 outcome = 1 Linear issue
It keeps WIP tight, starts the right agents, watches progress, checks receipts, and steers the merge path.
Deploys, tunnels, secrets, billing, and production remain human gates.
This is the part I care about most:
I can start from my phone and follow the entire chain from the same chat.
goal
↓
Linear issue
↓
plan PR
↓
implementation PR
↓
review verdict
↓
merge
PWSS — the software factory
Plan
Cursor Cloud Agent + Claude Fable
Creates a plan-only PR:
call-site map
PR slices
test matrix
gates
No application code.
Write
Cursor Cloud Agent + Grok
Implements the plan and opens the implementation PR.
This is separate from Grok Bot’s Chief of Staff role.
Same family, different seat.
Ship
A separate review runtime reads the GitHub PR with Codex Astra High.
Verdicts are explicit:
pass
block
needs evidence
scope issue
The implementer saying “all tests passed” is not enough.
Green tests do not equal acceptance.
Steer
Grok Bot checks the findings and evidence.
Pass means auto-merge by default.
But publish, billing, secrets, and production still require a human.
Why this works
The phone is the entry point.
Idea → Grok Bot → Linear → agents
Requirements are resolved before coding starts.
Planning and implementation are separate jobs.
Implementation and acceptance are separate jobs.
The model that writes the code does not grade its own work.
And the Chief of Staff does not replace the acceptance gate.
Codex reads the same GitHub diff independently.
Not:
“it worked on the coding VM.”
But:
“the submitted change satisfies the acceptance criteria.”
Blocks come back with finding IDs.
Even green tests can still be blocked for:
auth
boundary issues
missing evidence
scope drift
Roles
Grok Bot
→ Chief of Staff
→ start, orchestration, progress, WIP, merge steering
Linear
→ issue source of truth
→ 1 outcome = 1 issue
Cursor × Claude Fable
→ Plan
Cursor × Grok
→ Implement
Codex Astra High
→ independent acceptance gate
Good fit
constrained repo work
audit-backed refactors
small incremental changes
safe merges behind flags OFF
Bad fit
physical fit tests
secrets
tunnels
billing
production deploy
Those stay outside the autonomous gate.
So the pipeline is:
ChatGPT Pro
↓
ZIP
↓
Grok Bot
↓
Linear
↓
Fable plans
↓
Grok implements
↓
Codex accepts
↓
Grok Bot steers the merge
The advantage is not a “super-agent.”
It is separated authority, explicit evidence, and short handoffs.
Grok Bot coordinates the factory.
It does not get to grade its own factory.
That distinction matters.
#AICoding #GrokBot #Cursor #ChatGPT #Codex #Linear #SoftwareFactory #AgenticWorkflow
@bingerSpaceX Fair. Multi-model isn’t the point for me — the seat that matters is Acceptance stopping bad merges. A weekday shortlist is often enough when WIP is already tight.
@johnrobinsn Similar problem space, I think.
I keep Chief of Staff and Acceptance as separate seats, and try to keep attention cost short. Ring0’s “layer that sees you” is the next gap for me.
Acceptance (Codex) stops the loop most often.
Even when implementation says “tests are green,” blocks still come back for boundaries, missing evidence, or scope drift. It feels less like failure and more like the factory stopping correctly.
Second place is a soft requirements ZIP — then plan and implement thrash.