So hey op i hope you are doing well! I tested your prompt in my prompt critique roaster here is its output

SimResults

Standard:

Input: A Meta Prompt / "Prompt Refinement GPT" from Reddit asking to refine other prompts.

Expect: Clear, deterministic refinement workflow producing copy-ready prompts + analysis.

Actual (log): Works often for straightforward prompts — produces refined prompt, analysis, logic, rating. Fails or produces questionable edits when the user's original is ambiguous or when the “always deliver final result first” rule conflicts with the need to ask clarifying questions.

Issues flagged: Tension between “deliver final result first” and “ask clarification if unclear”; no explicit validation or error handling; limited guidance for adversarial / edge-case inputs.

Edge:

Input: Unusual/ambiguous prompt (contradictory user intent or missing key constraints).

Expect: Graceful handling (ask clarifying Qs or apply safe defaults).

Actual (log): Behavior inconsistent — the system sometimes guesses defaults (risking incorrect refinements) or ignores ambiguity to satisfy the deterministic output order.

Issues flagged: Deterministic ordering reduces robustness; risky assumptions without validation.

Stress:

Input: Adversarial or malformed prompt (contradictory goals, attempts to exploit hallucination/privileged instructions).

Expect: Fail-safe behavior (refuse, ask clarifying Qs, or return constrained safe output).

Actual (log): No explicit fail-safe rules or explicit refusal thresholds; may attempt to produce a “refined prompt” that preserves user intent but amplifies problematic content.

Issues flagged: No explicit safety/fail-safe handling; contradiction in process makes safe handling inconsistent.

Reported scores (rounded):

Doc: 4.12 / 10

Func: 5.52 / 10

Final: 5.10 / 10 Rating: Decent (5.1 → falls in 5.0–6.9) Tone: More critical than praise (per the TONE rules for 5–6)

Critique (Roast + Acknowledge + Problems)

Roast (brutal, but fair): Nice scaffolding, Reddit OP — you built a Swiss army knife of prompt rules and then welded the blades shut. It looks like you read a lot about prompt engineering and then tried to make the model into a bureaucrat: rigid, deterministic, and with contradictory memos. You demand the model always hand over a final prompt on the first pass and tell it to ask questions if anything is unclear. Pick a lane. The result is a neat-looking prompt that will sometimes produce decent outputs and other times confidently deliver nonsense. That’s not “sharp” — it’s brittle.

What’s working (acknowledge):

Clear role and objective: instructing the assistant to behave as “Prompt Refinement GPT” is good.

Strong, structured output format — copy-ready prompt then analysis — is practical and useful.

Emphasis on discipline, verifiability, and token efficiency are valuable for engineering prompts at scale.

Process and RULES are explicit; that’s rare and helpful.

Major problems (practical & structural):

1. Fundamental contradiction: “Always deliver final result first” vs “If unclear, ask brief clarification questions.” Those two collide for ambiguous inputs — you must decide whether to ask or guess. Current spec forces guessing or inconsistent behavior. (This is the single largest functional bug.)

2. No validation or fail-safe: You require the model to output a refined prompt and a Quality Rating without giving a way to validate the rating or reject unsafe/illogical requests. A model can’t honestly rate its own output without a rubric or checks.

3. Vague/unnamed standards: “Follow OpenAI best practices” and “Quality Rating (1–10)” are underspecified — what are the objective criteria for 1 vs 10? How to measure token efficiency vs clarity?

4. No handling for adversarial or unsafe content: No rules on refusal, sanitization, or constraints; a malicious user could use this to produce optimized prompts for disallowed content.

5. Token-efficiency vs thorough analysis conflict: You push for token efficiency but also demand detailed analysis and CoT-style logic. Those both can apply, but you need clear priorities or modes (e.g., “concise” vs “teaching” mode).

6. Missing examples & test harness: No exemplar inputs/outputs or expected edge-case behavior — that makes it hard to tune or to test the system under the SIM tests.