Stop Fighting Prompts: How I Reduced Formatting Errors to 0.1%

LLMs are great at generating content, but terrible at keeping it clean. In the ai-developer-knowledge-hub project, we faced a recurring nightmare: the technical documents generated by the LLM were riddled with formatting issues. Specifically, code blocks often lacked closing markers or had unclosed strings, crashing our frontend rendering engine.

We tried the obvious route: optimizing the Prompt. We begged the model to "output correct markdown syntax." The result? A 15% error rate. That's unacceptable for an automated publishing pipeline.

The core challenge is bridging the gap between a probabilistic system (the LLM) and a deterministic requirement (valid Markdown). Direct Regex cleaning was too fragile, and letting the LLM self-correct led to infinite loops.

The Root Cause

1. Symptom: Missing closing backticks or quotes in code blocks break the Markdown structure.
2. Mechanism: Relying on Prompts is a "soft constraint." The model follows syntax rules probabilistically, not deterministically.
3. Gap: We lacked a structured intermediate layer. We were treating raw streaming text as the final product, letting errors slip through.
4. The Breaking Point: A missing } in a JSON config block once threw a TemplateSyntaxError in Jinja2, blocking the entire publishing pipeline.

The Solution: AST Parsing & Jinja2 Hard Rendering

The breakthrough was decoupling content generation from style rendering. Instead of trusting the raw text, we pipe it through a validation layer using AST (Abstract Syntax Tree) parsing.

If the AST check fails, we sanitize. If it passes, we extract structured blocks and feed them into a Jinja2 template. This ensures the output structure is 100% locked down by the template engine, not guessed by the LLM.

Here is the implementation:

# Before: Relying on Prompt engineering (fragile)
prompt = "Please output markdown code blocks with correct syntax."
raw_text = llm.generate(prompt)

# After: Pipeline processing with forced validation
def render_pipeline(llm_output: str) -> str:
    # 1. AST Syntax Check (catches missing closing quotes/markers)
    try:
        markdown_parser.parse(llm_output)
    except SyntaxError:
        return fallback_sanitize(llm_output)

    # 2. Structured extraction and cleaning
    content_blocks = extract_code_blocks(llm_output)

    # 3. Jinja2 hard constraint rendering
    template = jinja_env.get_template("article_layout.md")
    return template.render(blocks=content_blocks)

Production-Grade Fallback & Retry

Parsing can fail, and LLMs can hang. We needed a strategy that prioritizes content delivery over perfection. We implemented an exponential backoff retry mechanism with a "text-only" fallback.

If rendering fails after retries, we don't crash; we strip the formatting and serve the raw text. Content is king, but we also log 10% of these failures for debugging without exploding our storage costs.

# Before: Simple retry, no circuit breaker
for _ in range(3):
    result = generate_and_check()

# After: Exponential backoff + Hard fallback + Sampling logs
MAX_RETRIES = 2
TIMEOUT = 5.0  # seconds
LOG_SAMPLE_RATE = 0.1  # 10% error sampling rate

for attempt in range(MAX_RETRIES):
    try:
        return strict_render(llm_output, timeout=TIMEOUT)
    except ASTParseError as e:
        if attempt == MAX_RETRIES - 1:
            # Last retry failed: downgrade to plain text, keep content, drop format
            if random.random() < LOG_SAMPLE_RATE:
                logger.error(f"Render failed: {e}")
            return text_only_fallback(llm_output)
        time.sleep(2 ** attempt) # Exponential backoff

Key Takeaways

• Hard Constraints > Soft Constraints: Engineering determinism beats prompt engineering. Jinja2 guarantees structure, bringing error rates from 15% down to 0.1%.
• Fail Gracefully: When AST parsing fails, never let the pipeline crash. Output a sanitized text version and log it for later review.
• Timeouts are Non-Negotiable: LLM outputs or parsing can block indefinitely. A 5-second timeout fuse prevents the whole document pipeline from stalling.

By moving the formatting responsibility from the LLM to a deterministic rendering pipeline, we solved the reliability issue once and for all.