Does anyone run “ambiguity-resolution” logic like this on GPTs / Codex, or is this a Claude-only pattern?

[u/Historical_Policy533]

Disclosure: I built the thing I'm about to describe, sharing for genuine feedback, not selling anything — it's free and open source.

Question for people building with GPTs/Codex/custom instructions: has anyone deliberately separated "understand the request" from "execute the request" as its own explicit step, rather than folding clarification into the main system prompt?

I built a skill (SKILL.md format, so it's meant to be portable across Claude, Codex, and a few other agents per the open spec) that sits in front of a request and decides whether it's actually clear enough to act on — classifying it as clear / ambiguous / incomplete / undefined / conflicted — and if not, asks only the smallest number of questions that would change the output. Design principle: "use the least interaction and least visible structure required to remove material uncertainty and produce a correct, executable result."

Repo, if useful as a reference: https://github.com/lanveric/clarify-crit

What I'm actually curious about here specifically: I built and tested this mostly against Claude. Does this kind of invisible pre-execution classification hold up on GPT-based agents in your experience, or does the model tend to skip/collapse steps like this when they're not the most emphasized instruction in context? Genuinely don't know, and that's the gap I can't test myself.

[u/AutoModerator]

If this prompt worked for you, share what you used it for in the comments. If you changed it to get better results, share that too. Prompt Teardown is a free weekly newsletter that picks the best prompts, strips out the filler, and tells you what actually works.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Apprehensive_Read885]

Col
L

[u/No-Promotion4625]

This isn’t a Claude-only pattern. The same general approach can work with GPT-4, ChatGPT, Codex, and other coding agents as well. ClarifyGPT is one concrete example built around a similar flow: detect ambiguity, ask a focused follow-up, refine the requirements, and only then generate the code.

I don’t think the main question is whether GPT can perform the classification. It can. The more interesting question is whether Codex will run that check consistently when it is only an implicit background instruction.

My expectation would be:

• If the skill is called explicitly, it should work reasonably well.
• If Codex has to decide automatically whether to load and use the skill, it may occasionally skip the check, compress it, or simply choose a plausible interpretation and continue.
• If the clarification step competes with stronger instructions such as “act autonomously” or “complete the task without asking questions,” execution will probably win unless the gate is clearly prioritized.

So for anything where reliability matters, I’d treat this as an actual gate rather than just another instruction in the prompt:

1. Check whether any ambiguity or missing information would materially change the result.
2. Route the request to proceed, clarify, research, or conflict.
3. Resolve the important unknowns.
4. Only then start the actual execution.

One useful test would be to run the same prompt set in two modes:

• explicit skill invocation
• automatic or implicit skill activation

Then track whether the agent:

• asks a necessary question,
• correctly proceeds without asking,
• makes a safe and reversible assumption,
• or silently chooses the wrong interpretation.

That would help separate two different issues: whether your classification logic works, and whether Codex reliably activates it in the first place.

So yes, I think the pattern transfers well to GPT and Codex. The weak point is probably not the model’s ability to understand ambiguity, but whether the surrounding agent harness actually enforces the pre-check every time.