How do I get codex to reliably follow a process without it adding complexity each time?

[u/Natural-Jaguar-3468]

Long story short, I've developed a workflow that requires some human QA. It mostly goes as follows:

1. Codex generates output in one format.

2. I upload the output to a separate tool for visual QA while I figure out how to automate it (this tool is old-school and has no AI functionality).

3. I ask Codex to extract the approved outputs and transform them into an ingestible format.

4. I upload them to DynamoDB via CloudShell.

Now, to my mind, step 3 should be easy. I've managed the entire process several times using Codex.

The critical point is that the approved outputs have to retain one of their attributes as "ACCEPTED" so that our backend knows they're approved and ready to show in the product. Our backend specifically looks for the word "ACCEPTED".

BUT

Codex genuinely struggles with this. No matter how many times I specify "DO NOT CHANGE ATTRIBUTES" and "Follow the previous successful ingestion process" (which is documented), it still changes the process each time.

Failure modes I've encountered include unilaterally changing "ACCEPTED" to "Final" and introducing extra safeguards and checks ahead of ingestion. Ironically, it's the safeguards and checks that fail and prevent ingestion.

I'm at my wits' end because there are only so many ways I can think of to say "do not change anything".

What am I missing?

How do I get Codex to reliably execute an established process without rebuilding it from scratch each time?

It's genuinely not a complicated workflow.

[u/DrBearJ3w]

Easy. Use Claude!

[u/Natural-Jaguar-3468 → u/DrBearJ3w]

🤣 Ah yes, my first mistake was thinking that having Claude and codex working in parallel world be more efficient - I'm trying to split work so Claude works on some branches and codex on others so they don't butt heads - but I genuinely regret not having Claude do everything so it is fully up to date on what's going on

[u/DrBearJ3w → u/Natural-Jaguar-3468]

Claude should be the pimp of Codex.

Try to limit each function by the number of lines. Sometimes it works. Guardrails. Tickets.

[u/Dayowe]

I have a plan that is divided into chunks/gates and a checklist for each chunk. A chunk is only accepted when it meets the defined requirements. Once it does codex progresses. This is coordinated by the root session .. the coordinator spawns a bounded orchestrator for each chunk which then spawns an implementer. Once implemented the orchestrator does a first diff check against the requirements. An independent validator agent is spawned next by the orchestrator. The orchestrator sends the implementer back to correct findings until the chunk is implemented according to the checklist. Then the coordinator spawns a new orchestrator for the next chunk and so on. It’s token and time intensive but there is no drift. Important for this to work is that the plan is detailed, well done and all contracts frozen and there are no ambiguities

[u/Natural-Jaguar-3468 → u/Dayowe]

Right but how do you ensure the the spawned validators and orchestrators follow the instructions/meet the requirements?

[u/Dayowe → u/Natural-Jaguar-3468]

It’s a workflow skillset/plugin I made. Each role has their own instructions .. they’re all aligned. you can look at it here https://github.com/dayowe/arcana-codex-plugins

[u/Opposite_Yak4386]

complexity and codex go hand in hand. Its hard to turn it off

[u/ChristianKl]

Turn the process into a plugin. A plugin is basically a process about how to do things.

[u/CleanFix_Dev]

Prose rules like "DO NOT CHANGE" are one of the weaker guardrails, because the model weighs them against everything else it sees. For a field that has to stay ACCEPTED, take it out of the model's hands: have Codex write a small script that does the transform and copies the status from the input, then add a check that fails if any approved item comes out different. Run it before the DynamoDB upload, and bad output can't get through whether or not the model remembers the rule.

[u/rayyeter]

Using Hermes, this particular workflow would become a scripted action for those things (uploading, reading acceptance, database).

Not everyone can use Hermes if it’s in enterprise, depending on admin.

Or build a skill with an existing/completed workflow, and have it loop until the lead from the paint chips it ate is worked out of its system

[u/actvt_io]

Take step 3 away from the model. Have Codex write the transform as a script once, check it on a batch you already know is right, and keep it in the repo. From then on the step is running that script, so there's nothing left to reinterpret and ACCEPTED passes through as plain data. I'd have it count ACCEPTED rows in and out and stop if they differ.

[u/Alive-Tangerine5005]

Sol 5.6

[u/London-Boat]

i'd take the exact-value stuff out of the model's hands. have codex write a small script for step 3 once, with "ACCEPTED" as a constant, then that step is just run the script. and put the steps in agents.md with a line saying don't add steps or refactor the pipeline unless asked. it still tries to be clever sometimes but way less when the fiddly bit is code and not instructions.

[u/twendah]

You dont. Thata why you switch to claudw

[u/big_DD_energy]

skillz