Skip to main content
skill CX Codex

regex-vs-llm-structured-text — Claude Code skill: parsing text

The regex-vs-llm-structured-text Claude Code skill helps choose an extraction method for structured text. It starts with regex for repeated patterns and sends uncertain results to an LLM for review.

MIT 6,200 installs ★ 308,413 updated 2026-10-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add affaan-m/ECC --skill regex-vs-llm-structured-text -a claude-code
Open on GitHub

What regex-vs-llm-structured-text does

The skill lays out a hybrid parsing flow: regex extracts fields, a confidence score flags questionable results, and an LLM checks only those items. The examples cover quizzes, forms, invoices, receipts, and tables with recurring layouts.

It includes a Python parser, confidence-scoring functions, and a validation pipeline. For free-form text with highly variable structure, the guidance switches to using an LLM directly. Its validation example calls Claude Haiku through a messages client; LLM requests are reserved for items below the confidence threshold.

What it helps with

  • extract questions and answers from repeated text blocks
  • parse fields from forms, invoices, or receipts with regex
  • send only uncertain extractions to an LLM for review
  • choose regex or an LLM for text with variable structure

Example prompts for the agent

  • Show me a regex approach for extracting questions and answers from repeated text.
  • Add confidence scoring and send questionable extracted items to an LLM for review.
  • Compare regex and LLM parsing for a form whose layout varies.

How to install regex-vs-llm-structured-text

1Skills CLI (Vercel)

npx skills add affaan-m/ECC --skill regex-vs-llm-structured-text -a claude-code

2Manually: put the files in place

~/.claude/skills/regex-vs-llm-structured-text/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/regex-vs-llm-structured-text/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about regex-vs-llm-structured-text

How do I install regex-vs-llm-structured-text in Claude Code?

Run npx skills add affaan-m/ECC --skill regex-vs-llm-structured-text -a claude-code. The skill file is at ~/.claude/skills/regex-vs-llm-structured-text/SKILL.md.

What does regex-vs-llm-structured-text do?

It lays out a parsing approach that uses regex for recurring structures, scores extraction confidence, and sends low-confidence items to an LLM for validation.

When does the skill recommend using an LLM instead of regex?

For free-form text with highly variable structure, it recommends using an LLM directly. Regex is the suggested starting point for repeated formats.

Source text

SKILL.md · MIT
---
name: regex-vs-llm-structured-text
description: Decision framework for parsing structured text (quizzes, forms, invoices, receipts, tables) with a hybrid regex-first pipeline — regex extraction handles 95%+ cheaply, a confidence scorer flags low-confidence items, and an LLM validator fixes only the edge cases. Use when choosing between regex and LLM for text extraction, building a cheap document parser, or optimizing extraction cost and accuracy.
metadata:
  origin: ECC
---

# Regex vs LLM for Structured Text Parsing

A practical decision framework for parsing structured text (quizzes, forms, invoices, documents). The key insight: regex handles 95-98% of cases cheaply and deterministically. Reserve expensive LLM calls for the remaining edge cases.

## When to Activate

- Parsing structured text with repeating patterns (questions, forms, tables)
- Deciding between regex and LLM for text extraction
- Building hybrid pipelines that combine both approaches
- Optimizing cost/accuracy tradeoffs in text processing

## Decision Framework

```
Is the text format consistent and repeating?
├── Yes (>90% follows a pattern) → Start with Regex
│   ├── Regex handles 95%+ → Done, no LLM needed
│   └── Regex handles <95% → Add LLM for edge cases only
└── No (free-form, highly variable) → Use LLM directly
```

## Architecture Pattern

```
Source Text
    │
    ▼
[Regex Parser] ─── Extracts structure (95-98% accuracy)
    │
    ▼
[Text Cleaner] ─── Removes noise (markers, page numbers, artifacts)
    │
    ▼
[Confidence Scorer] ─── Flags low-confidence extractions
    │
    ├── High confidence (≥0.95) → Direct output
    │
    └── Low confidence (<0.95) → [LLM Validator] → Output
```

## Implementation

### 1. Regex Parser (Handles the Majority)

```python
import re
from dataclasses import dataclass

@dataclass(frozen=True)
class ParsedItem:
    id: str
    text: str
    choices: tuple[str, ...]
    answer: str
    confidence: float = 1.0

def parse_structured_text(content: str) -> list[ParsedItem]:
    """Parse structured text using regex patterns."""
    pattern = re.compile(
        r"(?P<id>\d+)\.\s*(?P<text>.+?)\n"
        r"(?P<choices>(?:[A-D]\..+?\n)+)"
        r"Answer:\s*(?P<answer>[A-D])",
        re.MULTILINE | re.DOTALL,
    )
    items = []
    for match in pattern.finditer(content):
        choices = tuple(
            c.strip() for c in re.findall(r"[A-D]\.\s*(.+)", match.group("choices"))
        )
        items.append(ParsedItem(
            id=match.group("id"),
            text=match.group("text").strip(),
            choices=choices,
            answer=match.group("answer"),
        ))
    return items
```

### 2. Confidence Scoring

Flag items that may need LLM review:

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

def score_confidence(item: ParsedItem) -> ConfidenceFlag:
    """Score extraction confidence and flag issues."""
    reasons = []
    score = 1.0

    if len(item.choices) < 3:
        reasons.append("few_choices")
        score -= 0.3

    if not item.answer:
        reasons.append("missing_answer")
        score -= 0.5

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

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

def identify_low_confidence(
    items: list[ParsedItem],
    threshold: float = 0.95,
) -> list[ConfidenceFlag]:
    """Return items below confidence threshold."""
    flags = [score_confidence(item) for item in items]
    return [f for f in flags if f.score < threshold]
```

### 3. LLM Validator (Edge Cases Only)

```python
def validate_with_llm(
    item: ParsedItem,
    original_text: str,
    client,
) -> ParsedItem:
    """Use LLM to fix low-confidence extractions."""
    response = client.messages.create(
        model="claude-haiku-4-5-20251001",  # Cheapest model for validation
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": (
                f"Extract the question, choices, and answer from this text.\n\n"
                f"Text: {original_text}\n\n"
                f"Current extraction: {item}\n\n"
                f"Return corrected JSON if needed, or 'CORRECT' if accurate."
            ),
        }],
    )
    # Parse LLM response and return corrected item...
    return corrected_item
```

### 4. Hybrid Pipeline

```python
def process_document(
    content: str,
    *,
    llm_client=None,
    confidence_threshold: float = 0.95,
) -> list[ParsedItem]:
    """Full pipeline: regex -> confidence check -> LLM for edge cases."""
    # Step 1: Regex extraction (handles 95-98%)
    items = parse_structured_text(content)

    # Step 2: Confidence scoring
    low_confidence = identify_low_confidence(items, confidence_threshold)

    if not low_confidence or llm_client is None:
        return items

    # Step 3: LLM validation (only for flagged items)
    low_conf_ids = {f.item_id for f in low_confidence}
    result = []
    for item in items:
        if item.id in low_conf_ids:
            result.append(validate_with_llm(item, content, llm_client))
        else:
            result.append(item)

    return result
```

## Real-World Metrics

From a production quiz parsing pipeline (410 items):

| Metric | Value |
|--------|-------|
| Regex success rate | 98.0% |
| Low confidence items | 8 (2.0%) |
| LLM calls needed | ~5 |
| Cost savings vs all-LLM | ~95% |
| Test coverage | 93% |

## Best Practices

- **Start with regex** — even imperfect regex gives you a baseline to improve
- **Use confidence scoring** to programmatically identify what needs LLM help
- **Use the cheapest LLM** for validation (Haiku-class models are sufficient)
- **Never mutate** parsed items — return new instances from cleaning/validation steps
- **TDD works well** for parsers — write tests for known patterns first, then edge cases
- **Log metrics** (regex success rate, LLM call count) to track pipeline health

## Anti-Patterns to Avoid

- Sending all text to an LLM when regex handles 95%+ of cases (expensive and slow)
- Using regex for free-form, highly variable text (LLM is better here)
- Skipping confidence scoring and hoping regex "just works"
- Mutating parsed objects during cleaning/validation steps
- Not testing edge cases (malformed input, missing fields, encoding issues)

## When to Use

- Quiz/exam question parsing
- Form data extraction
- Invoice/receipt processing
- Document structure parsing (headers, sections, tables)
- Any structured text with repeating patterns where cost matters

© affaan-m · MIT · affaan-m/ECC

Similar skills

All skills for AI and ML →

From the same set150

The whole set →
autonomous-loops The autonomous-loops skill covers autonomous development loops, from sequential claude -p pipelines to multi-agent DAG orchestration. Use it for CI/CD workflows and long-running tasks. CX Codex +1 6,300installs data-scraper-agent The data-scraper-agent skill walks you through building an agent that scrapes public sources on a schedule, enriches results with Gemini Flash, and stores them in Notion, Sheets or Supabase. CX Codex +1 6,300installs compose-multiplatform-patterns compose-multiplatform-patterns is a skill that guides shared UI design for Compose Multiplatform and Jetpack Compose in KMP projects, covering state, navigation, theming, and platform-specific UI. CX Codex +1 6,300installs hipaa-compliance The skill runs in Claude Code and other platforms, handling HIPAA compliance tasks and PHI security workflows in software. CX Codex +1 6,200installs click-path-audit click-path-audit — a skill for Claude Code and Codex that audits user-facing touchpoints. Traces sequential state mutations to uncover silent side effects and conflicting resets across UI handlers. CX Codex +1 6,200installs homelab-wireguard-vpn The homelab-wireguard-vpn Claude Code skill guides WireGuard setup for remote access to a home network. It covers server and client configuration, key generation, and the choice between split and full tunnel routing. CX Codex +1 6,200installs healthcare-emr-patterns healthcare-emr-patterns is a Claude Code skill that defines EMR and EHR development patterns focused on patient safety, encounter workflows, and medication checks. CX Codex +1 6,200installs skill-comply skill-comply is a Claude Code skill that tests whether agents follow skills, rules, and agent definitions. Run it after changing an instruction file or as part of recurring compliance checks. CX Codex +1 6,200installs

Project sponsors

Companies that keep this analytics open