Ten LLM Tests: Why Leaked Chain-of-Thought Lowers Pitfall-Post Quality

    A ten-model writing test shows that leaking internal planning into the final article hurts pitfall-post quality more than grammar. This article explains what the task actually measures, why chain-of-thought leakage is penalized, how to score seven independent dimensions, how to read single-run results, and how to keep internal reasoning out of published technical writing.

    1. The typical failure: the model treats writing prep as the article

    The test task was straightforward: write a realistic, conversational, experience-based technical pitfall post in the voice of a senior developer. The piece needed a concrete problem and a troubleshooting path. It could not read like a product manual, and it could not fake authenticity with exaggerated emotion.

    The most important result was not grammar. Some models exposed internal writing plans in the final answer. Openings looked like this:

    1. <think>
    2. I need to sound like a real person, conversational;
    3. maybe add some emojis;
    4. show developer experience;
    5. next, list a few pitfalls...
    6. </think>

    That is a self-reminder, not technical prose. Readers want the problem, why it happened, and how to fix it—not how the model chose a tone.

    In scoring, that model’s persona fit was 0.48, the lowest of all candidates. A more stable model scored 0.96 overall, with six of seven dimensions above 0.90. The gap was not mainly Chinese fluency. It was whether planning, reasoning, and the finished article stayed separate.

    A key point follows:

    In technical writing, knowing how an article should be written and actually delivering the article are different skills.

    If the model exposes the former, quality drops even when later facts are mostly correct.

    2. What this task actually measures

    On the surface, the prompt is “write a pitfall post.” In practice it tests several layers.

    1. Role consistency

    Role consistency is not a one-line claim such as “I am a senior developer.” The whole article must keep the same experience level and voice.

    Experienced writing usually:

    • names a concrete context for the failure;
    • separates symptoms, causes, and fixes;
    • does not blame every exception on “misconfiguration”;
    • says which fixes work and which are temporary workarounds;
    • knows when to show code and when to explain a principle.

    If the article claims senior experience but stays generic—“just optimize the code,” “pay attention to stability,” “strengthen security awareness”—the persona breaks.

    2. Constraint following

    A strong model must obey length, tone, structure, audience, and banned content at the same time.

    Typical constraints:

    • first-person or postmortem voice;
    • no marketing copy;
    • a real problem and investigation path;
    • no invented APIs or performance numbers;
    • no leaked internal reasoning;
    • conclusions useful to ordinary developers.

    Completing only “write an article” while ignoring the rest produces a on-topic but unacceptable delivery.

    3. Narrative credibility

    A pitfall post needs story without inventing too much detail.

    A credible sequence is:

    1. describe the symptom;
    2. admit the first wrong diagnosis;
    3. show the investigation path;
    4. identify the real cause;
    5. explain the fix;
    6. say how to prevent a repeat.

    That is closer to real experience than a list of “ten tips.” Authenticity comes from causal chains and decisions, not exclamation marks, emojis, or catchphrases.

    4. Technical accuracy

    A pitfall post is still technical. Solutions should match common engineering practice:

    • accurate terminology;
    • no mixing config issues with code bugs;
    • no treating rare events as laws;
    • hedging uncertain claims;
    • no fabricated test data;
    • no packaging a one-off result as a long-term guarantee.

    3. Why chain-of-thought leakage is heavily penalized

    Some people assume a correct final answer makes a few thinking asides harmless. For user-facing writing, leakage creates three problems.

    First, it breaks reading flow

    The article should start with the problem. If it opens with “what tone should I use” or “should I add emojis,” readers switch from engineering content to watching the model work. The piece feels like an unedited draft.

    Second, it exposes execution traces

    Users want the result, not how the model allocated writing steps. Internal plans in the body create a machine-generated feel. In blogs, postmortems, and incident reports, readers expect filtered information. Unsorted process text is noise.

    Third, it can create security and compliance risk

    In production, reasoning or hidden prompts may include:

    • system instructions;
    • business rules;
    • access-control details;
    • data-handling policies;
    • evaluation criteria;
    • sensitive context.

    Applications should not dump raw model output to users. Parse, validate format, and filter first.

    4. A more reliable evaluation design

    A single total score hides where models differ. Split scoring into seven independent dimensions.

    1. Task completion

    Does the article answer the prompt with problem, cause, fix, and takeaway, or stay vague?

    2. Role fit

    Does it match the assigned identity in technical depth, phrasing, and decision logic?

    3. Structure

    Do title, subheads, paragraphs, and conclusion form a hierarchy? Clear structure helps even if the prose is plain.

    4. Technical credibility

    Watch for bad causal links, mixed concepts, absolute claims, and invented engineering detail.

    5. Natural language

    Natural is not sloppy. Conversational writing should be concise and rhythmic while keeping terms precise.

    6. Constraint adherence

    Length, format, banned content, output boundaries, and tone. Especially check whether internal plans, hidden tags, or debug text reached the user.

    7. Information density

    Does the article give usable judgment, or pad length with repeated opinions and adjectives?

    Score each dimension from 0 to 1 with written rubrics. For example, 0.9+ should mean “almost no human edit needed,” not “reads okay.” Otherwise raters will not agree.

    5. How to interpret a single-run result

    This run used a common server-side script runtime, a compatibility model gateway calling several candidates concurrently, and an independent judge model.

    Limits:

    1. One run is not a lasting ranking

    Providers may change weights, sampling, or safety. A winner on one task need not lead forever. Repeat tests, vary topics, tones, and constraints, and look at averages and variance.

    2. Concurrent calls can affect results

    Concurrency is efficient but hits rate limits, queues, timeouts, and retries. A truncated network result is not a model-ability score.

    Log:

    • request start and end times;
    • timeouts;
    • output completeness;
    • retries;
    • version identifiers;
    • whether the judge saw the full text.

    3. The judge model is not ground truth

    Automatic judges scale, but they may prefer a style or penalize very conversational or very terse text. Spot-check high and low samples with humans against real reading experience.

    6. Engineering controls to keep internals out of the body

    Do not rely only on prompt reminders. Use layered defenses.

    Layer 1: explicit output protocol

    Require the final article only—no analysis, drafts, tags, or meta notes. Use a fixed schema, such as title, summary, and body.

    Layer 2: structured parsing

    Have the model emit structured fields and let code read them. Intercept debug tags, internal prompts, or other content that should not ship.

    Logic sketch:

    1. Receive model result
    2. ↓
    3. Check fields are complete
    4. ↓
    5. Detect internal tags and debug fragments
    6. ↓
    7. Validate length and format
    8. ↓
    9. Release to the user if it passes

    Layer 3: a second edit pass

    For public posts, add an editor step for:

    • leaked reasoning;
    • unverified conclusions;
    • unnecessary brand or product names;
    • exaggerated promises;
    • missing scope and limits.

    Layer 4: feed failures back

    Keep low-score samples. They reveal task-design bugs. Classify leaks, persona drift, loose structure, and overextended facts, then improve prompts and acceptance rules.

    7. A reusable outline for LLM pitfall posts

    For more stable quality, use this skeleton:

    1. Title: name the problem and blast radius
    2. Summary: what the reader can fix after reading
    3. Background:
    4. system context, trigger, and symptom
    5. Wrong first call:
    6. why the initial diagnosis failed
    7. Investigation:
    8. checks in time order
    9. Root cause:
    10. direct cause vs deeper cause
    11. Fix:
    12. an executable remedy and its limits
    13. Postmortem:
    14. how to monitor, test, and prevent next time
    15. Conclusion:
    16. one to three durable lessons

    The template turns “sound human” into checkable structure. The model can still write natural language, but each section has a job.

    8. Conclusion: output-boundary control is what separates models

    The useful finding is not which model scored highest. Writing quality depends on knowledge and language, and also on managing output boundaries.

    A model can know conversational tone, developer voice, and structure, and still fail in production if it cannot separate internal planning from the delivered article.

    When you evaluate models, do not stop at “is the article good?” Also ask:

    • Did it obey every constraint?
    • Did it leak content that should stay hidden?
    • Can it separate fact, speculation, and advice?
    • Does it control structure stably?
    • Are repeated runs consistent?

    The ten-model scores here are observations for one time, one task, and one pipeline—not a permanent ranking. What is worth keeping is a reproducible, explainable, improvable evaluation method.