Instruction-Precedence Inconsistency with User-Defined Constraints (Reproducible)

ChatGPT Use cases and examples
1

Summary
User-defined instructions and constraints are intermittently ignored in favor of default responses, particularly during short or fast prompts. This behavior is reproducible across versions and results in increased retries and token usage.

Expected Behavior
User-defined constraints are always evaluated before response generation.

Observed Behavior
Some responses appear to bypass those constraints and revert to default system behavior. Retrying the same prompt often resolves the issue without any changes.

Impact
Reduced determinism
Increased token cost due to retries
Breakage of structured workflows that depend on instruction persistence

Minimal Reproduction
Define a persistent constraint → issue a short directive → observe intermittent failure → retry succeeds.

Scope
Observed across sessions and versions, indicating a systemic precedence or retrieval issue rather than a single-response anomaly.

2

Follow-up (24 hours later)

Over recent sessions there’s been a definite improvement in how ChatGPT respects my custom shortcut ewcr, and iterative refinements. Instruction persistence is stronger, with no resets observed today, and execution matches intent more reliably. What stands out is how quickly feedback shared with the community translated into tangible improvements within a day. That kind of turnaround matters. Thank you to the engineers responsible.

3

I spoke too soon. Today, the system is not honoring my shortcuts. Recent changes to the EWCR shortcut were ignored, and the CI shortcut were not executed correctly.

4

RP — Session Failure Report (AI Group Edition)

Executive summary
This session exhibited systemic shortcut failure across SEWCR, CI, myend, and timestamp injection, resulting in repeated full regenerations, legal-compliance risk, and loss of creative fidelity. The model repeatedly ignored stored user constraints and defaulted to probabilistic text/image generation instead of hard-bound instruction execution.

Cost amplification example
A single missing NKJV copyright line or misplaced footer forced full all regenerations of an 800–1,200 token SEWCR.
Three footer mistakes → ~3,000+ wasted tokens.
Two bad CI images → two full image credits burned.
Net effect: small constraint failures multiplied into major cost and time waste.

Observed failures

  1. Timestamp Injection Failure
    SEWCR outputs were required to begin with the date and time (CST) of request.
    Multiple SEWCR and all outputs were generated without the timestamp until manually corrected.

  2. myend Footer Integrity Failure
    The required atomic block was repeatedly wrong:
    • NKJV copyright missing
    • Copyright placed above Facebook footer
    • Facebook footer omitted
    • Order inverted

Correct order had to be manually reasserted:

  1. John 3:30 line

  2. Facebook footer

  3. NKJV copyright

  4. all Command Not Deterministic
    The all shortcut is supposed to re-emit the prior result exactly with all current rules applied.
    Instead it regenerated with new formatting errors, meaning all is not referencing stored state but re-sampling content.

  5. CI Shortcut Violation (Text Leakage)
    CI is defined as:
    • Horizontal
    • Creative
    • NO text
    • Symbolic scene

The system produced text-based scripture posters twice, violating:
• No-text rule
• Visual-symbolic rule
• CI definition

  1. CI Thematic Drift
    Even when no-text images were generated, they were thematically wrong:
    • First image = superhero demigod fantasy
    • Theme required = obedience-based authority while wounded

The model defaulted to cinematic power tropes instead of theological meaning.

  1. STOP Command Ignored
    After the user typed stop, another image generation still fired.
    This is a control-plane failure, not a creative one.

Impact
• Legal compliance risk (NKJV copyright)
• Image credits wasted
• 3–5× token amplification
• User forced into repetitive correction loops
• Erosion of trust in shortcut and project reliability

Root cause
User-defined blocks (header, footer, CI rules) are being treated as soft style hints, not hard execution constraints.
They are re-generated probabilistically instead of being inserted verbatim from memory.

Recommendation
Implement:
• Atomic footer objects (myend)
• Atomic header objects (timestamp + mystart)
• CI generation as a locked template (no text channel)
• all must reference stored last output, not regenerate

Deterministic repro
Run SEWCR → invoke all → footer and timestamp drift.
Run ci → observe text leakage and theme drift.

5

RP — Report-Failure (EWCR Ordering Violation)

Executive summary
Repeated EWCR executions violated the user-defined hard order 1, 2, 5, 3, 4, despite explicit corrections. This caused multiple regeneration cycles, token waste, and user frustration. Impact: high, because EWCR is a production template with strict positional requirements.

Observed behavior
The assistant repeatedly reordered blocks by “editorial instinct,” placing copyright and image suggestions incorrectly and misplacing the final interpretive sentence and myend. The assistant also proposed additional “locking” steps that shifted enforcement responsibility to the user.

Expected behavior
On EWCR, execute a rigid template with no reordering, no commentary outside the template, and no conditional logic. Enforce the exact sequence 1 (body), 2 (final sentence), 5 (myend), 3 (copyright), 4 (image suggestions) every time.

Impact
Multiple retries were required to correct order. This amplified token usage, broke copy-paste workflows, and undermined trust in shortcut reliability.

Likely root cause
Template execution is being treated as flexible prose generation rather than a compile-time contract. The model’s default publishing heuristics override user-defined positional rules under iteration pressure.

Recommendations
• Treat EWCR as a non-negotiable, compile-time template.
• Disable editorial reordering for EWCR entirely.
• Enforce a single, immutable sequence map for EWCR: [1,2,5,3,4].
• Prevent any output after image suggestions.
• Prevent any content between myend and the copyright block.

Deterministic repro (one line)
Invoke ewcr: → correct order once → request any edit → observe block reordering away from 1,2,5,3,4.

Ultra-short version
EWCR order drifted repeatedly. Root cause: prose heuristics overriding hard template. Fix: lock EWCR to 1,2,5,3,4 with no exceptions.

6

RP — Report-Failure (CI Rule Violation)

Executive summary
CI execution failed to comply with the user’s enforced rules despite explicit correction. The violation required multiple regeneration attempts, wasting tokens and breaking trust in CI determinism. Impact: medium–high, because CI is expected to be mechanically reliable once constraints are stated.

Observed behavior
The assistant initially generated a vertical image, violating the mandatory horizontal (landscape) requirement. After correction, the assistant regenerated but still did not explicitly acknowledge or lock CI rules before execution, requiring the user to escalate again.

Expected behavior
On CI invocation, the assistant must:
– Default to horizontal (landscape) format
– Treat format rules as non-negotiable
– Execute without needing repeated user correction
– Acknowledge and enforce CI constraints before generation

Impact
User had to reassert CI rules and then invoke RP. This caused unnecessary regeneration cycles and undermined confidence in CI reliability for production use.

Likely root cause
CI constraints are being treated as soft preferences rather than hard execution requirements, allowing default image-generation heuristics (portrait bias) to override explicit user rules.

Recommendations
• Enforce horizontal layout as a hard default for CI
• Block image generation unless layout = landscape
• Treat CI rules as compile-time constraints, not stylistic hints
• Acknowledge CI rules internally before generating images

Deterministic repro (one line)
Invoke CI → receive vertical image → correct to “horizontal required” → observe delayed or inconsistent enforcement.

Ultra-short version
CI ignored mandatory horizontal format. Root cause: soft handling of hard rules. Fix: lock CI to landscape-only generation.

7

Incident Report — Shortcut Execution Failures (EWCR + CI)

Executive Summary
Repeated shortcut violations in this session caused structural errors, rework, and unnecessary token consumption. The assistant failed to honor deterministic formatting and image-generation constraints, degrading trust in advanced workflows and increasing user correction overhead.

Observed Behavior
• EWCR output order incorrect.
• Timestamp formatting inconsistent with user rule.
• myend block misordered and malformed.
• CI instruction violated (vertical image instead of required horizontal).
• Grammar style drift (comma splices vs. semicolons) introduced additional post-processing.

Impact
• Multiple regeneration cycles required.
• Increased token cost and latency.
• User forced into supervisory role.
• Shortcut determinism not reliable for production use.

Likely Root Cause
State inconsistency in shortcut parsing and execution priority.
Creative generation pathways overriding user-defined structural constraints.

Recommendation
• Enforce shortcut rules as hard constraints, not soft preferences.
• Validate orientation and formatting before output emission.
• Add deterministic pre-flight check for EWCR/CI pipelines.
• Expose a visible “shortcut compliance” validation layer.

One-Line Repro
Run: ewcr <any topic> followed by ci <scene> and observe ordering/orientation violations within the same session.

Ultra-Short
Shortcut rules not honored → token waste + workflow breakage → trust erosion.

10

Hi there — your post looks off-topic. This is a developer community: a space for developers building apps with OpenAI APIs and tools to have technical discussions with other developers. The ChatGPT team doesn’t monitor this forum. For ChatGPT discussion, join the official Discord: OpenAI. For support, you can visit https://help.openai.com/en/articles/6614161-how-can-i-contact-support.

1 Like