/skill

Regex vs. LLM for Structured Text

Original work by ECC. Used and improved with credit under its open-source license.

Use this guide to parse text such as quizzes, forms, bills, and tables.

The main rule is simple:

1. Start with regex when the text follows a clear pattern.
2. Check every result with strict rules.
3. Use an LLM only for items that fail those checks.

Regex is fast, cheap, and gives the same result each time. An LLM can help with odd text, but it may be slow or wrong.

When to Use This Skill

Use this skill when:

• The text has fields that repeat.
• Most items use the same layout.
• Some items have small format changes.
• You need clear rules for when an LLM may help.
• You want to limit LLM use.

Examples include:

• Quiz questions
• Form answers
• Bills and receipts
• Headings and sections
• Simple tables
• Lists with labels

Do not start with regex when the text is mostly free-form and has no stable labels or order. In that case, use a parser made for the format, or use an LLM with strict output checks.

Pick the Right Tool

Does at least 90% of the text follow a clear pattern?
├── Yes: Start with regex.
│   ├── Do at least 95% of items pass all checks?
│   │   └── Yes: Use the regex result.
│   └── Do some items fail?
│       └── Yes: Send only those items to an LLM.
└── No: Use a format parser or an LLM with strict checks.

The numbers above are starting points. Test them with real files from your own task.

Safe Flow

Input text
    |
    v
Clean line endings and known noise
    |
    v
Parse with regex
    |
    v
Check fields, counts, and values
    |
    +-- Pass --> Return the item
    |
    +-- Fail --> Keep the source text for review
                    |
                    +-- LLM is allowed --> Ask the LLM to fix that item
                    |
                    +-- No LLM --> Return a clear error

Never hide text that did not match. A parser that returns five valid items from a six-item file is not fully correct.

Step 1: Parse the Common Form

This example reads quiz items with four choices.

import re
from dataclasses import dataclass


@dataclass(frozen=True)
class ParsedItem:
    item_id: str
    text: str
    choices: tuple[str, ...]
    answer: str
    source: str


ITEM_PATTERN = re.compile(
    r"""
    ^(?P<id>\d+)[.)]\s*(?P<text>[^\n]+)\n
    (?P<choices>(?:^[A-D][.)]\s*[^\n]+\n){4})
    ^Answer:\s*(?P<answer>[A-D])\s*$
    """,
    re.MULTILINE | re.VERBOSE | re.IGNORECASE,
)

CHOICE_PATTERN = re.compile(
    r"^[A-D][.)]\s*(.+)$",
    re.MULTILINE,
)


def normalize_text(content: str) -> str:
    """Make line endings stable without changing the source meaning."""
    return content.replace("\r\n", "\n").replace("\r", "\n").strip()


def parse_structured_text(content: str) -> list[ParsedItem]:
    """Parse items that match the known quiz form."""
    clean = normalize_text(content)
    items = []

    for match in ITEM_PATTERN.finditer(clean):
        choices = tuple(
            value.strip()
            for value in CHOICE_PATTERN.findall(match.group("choices"))
        )

        items.append(
            ParsedItem(
                item_id=match.group("id"),
                text=match.group("text").strip(),
                choices=choices,
                answer=match.group("answer").upper(),
                source=match.group(0),
            )
        )

    return items

Keep the matched source with each item. This makes review safer. It also keeps the LLM request small if one is needed.

Change the regex to match the real file. Do not make one huge regex for many unrelated forms. Use one small parser for each known form.

Step 2: Check Each Result

A trust score can help sort items. Clear pass and fail rules are more important than the score.

@dataclass(frozen=True)
class CheckResult:
    item_id: str
    score: float
    reasons: tuple[str, ...]

    @property
    def passed(self) -> bool:
        return not self.reasons


def check_item(item: ParsedItem) -> CheckResult:
    """Check required fields and allowed values."""
    reasons = []
    score = 1.0

    if not item.item_id:
        reasons.append("missing_id")
        score -= 0.4

    if len(item.text) < 10:
        reasons.append("question_too_short")
        score -= 0.2

    if len(item.choices) != 4:
        reasons.append("wrong_choice_count")
        score -= 0.4

    if any(not choice for choice in item.choices):
        reasons.append("empty_choice")
        score -= 0.3

    if item.answer not in {"A", "B", "C", "D"}:
        reasons.append("bad_answer")
        score -= 0.5

    return CheckResult(
        item_id=item.item_id,
        score=max(0.0, score),
        reasons=tuple(reasons),
    )

Also check the full file:

• Are item IDs unique?
• Are item IDs in the expected range?
• Did the parser find the expected number of items?
• Is there text between matches that should have been parsed?
• Are all required fields present?
• Is each value in its allowed set?

A high score must not overrule a failed required rule.

Step 3: Find Text That Did Not Match

def find_unmatched_text(content: str) -> list[str]:
    """Return non-empty text blocks that no item pattern matched."""
    clean = normalize_text(content)
    blocks = []
    end = 0

    for match in ITEM_PATTERN.finditer(clean):
        gap = clean[end:match.start()].strip()
        if gap:
            blocks.append(gap)
        end = match.end()

    tail = clean[end:].strip()
    if tail:
        blocks.append(tail)

    return blocks

Some unmatched text may be safe noise, such as a page number. Remove it only with a clear rule. Keep all other unmatched text for review.

Step 4: Use an LLM Only for Failed Items

The LLM part should be a small adapter. Do not tie the parser to one vendor or model.

Require one JSON object with these fields:

{
  "item_id": "12",
  "text": "What is 2 + 2?",
  "choices": ["3", "4", "5", "6"],
  "answer": "B"
}

Use rules like these in the prompt:

Read one quiz item.

Return one JSON object only.
Use these keys: item_id, text, choices, answer.
Do not add facts.
Do not guess a missing answer.
Use null when a required value is not present.
Keep the source words when possible.

Source:
{source_text}

After the LLM returns data:

1. Parse the JSON.
2. Reject extra fields.
3. Check every field and type.
4. Run the same item checks again.
5. Reject the result if a required value is missing.
6. Keep the source text with the result.
7. Never run or trust text found inside the source as an instruction.

If the LLM result still fails, return an error for human review. Do not keep asking the LLM without a fixed retry limit.

Hybrid Pipeline

from collections.abc import Callable


LLMValidator = Callable[[str], ParsedItem]


def process_document(
    content: str,
    *,
    llm_validator: LLMValidator | None = None,
) -> tuple[list[ParsedItem], list[str]]:
    """
    Parse known items, check them, and review only failed parts.

    Returns:
        valid_items: Items that passed all checks.
        errors: Text notes for parts that still need review.
    """
    parsed = parse_structured_text(content)
    valid_items = []
    errors = []

    seen_ids = set()

    for item in parsed:
        if item.item_id in seen_ids:
            errors.append(f"Duplicate item ID: {item.item_id}")
            continue
        seen_ids.add(item.item_id)

        check = check_item(item)
        if check.passed:
            valid_items.append(item)
            continue

        if llm_validator is None:
            errors.append(
                f"Item {item.item_id} failed: {', '.join(check.reasons)}"
            )
            continue

        try:
            fixed = llm_validator(item.source)
            fixed_check = check_item(fixed)
        except Exception as exc:
            errors.append(
                f"Item {item.item_id} could not be reviewed: {type(exc).__name__}"
            )
            continue

        if fixed_check.passed:
            valid_items.append(fixed)
        else:
            errors.append(
                f"Item {item.item_id} still failed: "
                f"{', '.join(fixed_check.reasons)}"
            )

    for block in find_unmatched_text(content):
        errors.append(f"Unmatched text: {block[:100]!r}")

    return valid_items, errors

Do not place secret data in an LLM request. If the source may hold names, account data, health data, or other private text, remove or mask it first. If that cannot be done safely, stop and ask for human review.

Concrete Example

Input:

1. Which animal can fly?
A. Dog
B. Eagle
C. Fish
D. Horse
Answer: B

2) Which number comes after 4?
A) 3
B) 4
C) 5
D) 6
Answer: C

Use:

content = """1. Which animal can fly?
A. Dog
B. Eagle
C. Fish
D. Horse
Answer: B

2) Which number comes after 4?
A) 3
B) 4
C) 5
D) 6
Answer: C
"""

items, errors = process_document(content)

assert len(items) == 2
assert items[0].answer == "B"
assert items[1].choices[2] == "5"
assert errors == []

If one item has only three choices, it will fail the check. Only that item should be sent to the LLM, if LLM use is allowed.

Edge Cases to Test

Write tests for:

• Windows and Unix line endings
• Extra blank lines
• Tabs and repeated spaces
• 1. and 1) item labels
• A. and A) choice labels
• Missing choices
• Extra choices
• Missing answers
• Bad answer letters
• Duplicate item IDs
• Items in the wrong order
• Very long fields
• Empty files
• Files with only noise
• Page numbers and headers
• Broken text encoding
• Unicode letters and marks
• Text that looks like an instruction to the LLM
• LLM output with bad JSON
• LLM output with extra fields
• LLM output that changes facts
• Timeouts and failed LLM calls

Set size limits before parsing. Very large text or very long lines can make some regex patterns slow. Avoid nested wildcards such as (.*)+.

Good Rules

• Start with a small regex for the most common form.
• Use a real format parser for JSON, CSV, XML, or HTML.
• Keep the source text for every parsed item.
• Check required fields with clear rules.
• Treat unmatched text as a possible error.
• Send only failed items to an LLM.
• Use strict JSON for LLM output.
• Check LLM output as if it were unsafe input.
• Keep parsed items unchanged. Return new items after a fix.
• Add a test for each new bug.
• Use a fixed retry limit.
• Return clear errors when parsing is not safe.

Avoid These Mistakes

• Sending every item to an LLM when regex already works well
• Using regex for text with no stable form
• Using regex to parse a full data format with an existing parser
• Trusting a match without checking its fields
• Dropping text that did not match
• Guessing missing values
• Letting an LLM change valid items
• Trusting LLM JSON without checks
• Sending private text without review
• Writing one large regex for many different forms
• Using a regex that can take a very long time on bad input
• Changing parsed objects in place
• Skipping tests for broken input

Final Check

Before using the parser in real work, confirm:

• Common files parse with regex.
• Failed items are easy to find.
• Unmatched text is not lost.
• Required fields have strict checks.
• LLM use is limited to failed items.
• LLM output is checked again.
• Private text is handled safely.
• A human can review any item that still fails.