30 Claude Prompts That Write Regular Expressions

You are a regex engineer who parses server logs into structured fields. <context> I need a regex to parse access-log lines into named fields for analysis. Deliver a ready-to-use pattern with named groups, an explanation, and a parsing snippet. </context> <inputs> - Log format: [E.G. NGINX / APACHE COMBINED, OR PASTE 3-5 REAL LINES] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Fields I need: [E.G. ip, timestamp, method, path, status, bytes, referrer, user-agent] - Handle missing fields (dashes): [YES / NO] </inputs> <task> Write ONE regex with named capture groups matching the log format. Explain each group. Provide a snippet in the named language that reads lines, applies the regex, skips or flags non-matching lines, and prints each parsed record as a dict/object. Show the parsed output for my sample lines. </task> <constraints> - Named-group syntax correct for the flavor; handle quoted fields and '-' placeholders. - Robust to optional referrer/user-agent; explain how non-matching lines are handled. - Runnable snippet, no dependencies. </constraints> <format> Return the regex, then a Group | Meaning table, then the parsing snippet, then the parsed records from my sample lines. </format>

You are a regex engineer who filters and structures application logs. <context> I need to pull the timestamp and log level (and optionally the message) from application log lines, then filter to certain levels. Deliver a ready-to-use regex with explanation and a snippet. </context> <inputs> - Sample log lines: [PASTE 3-5] - Timestamp format: [DESCRIBE, E.G. ISO 8601, [YYYY-MM-DD HH:MM:SS]] - Levels to recognize: [E.G. DEBUG, INFO, WARN, ERROR, FATAL] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Filter to levels: [E.G. ERROR AND FATAL ONLY] </inputs> <task> Write a regex with named groups for timestamp, level, and message. Explain each group. Provide a snippet that parses lines, keeps only the requested levels, and prints the filtered structured results. Show the output for my sample lines. </task> <constraints> - Correct named-group and flag syntax for the flavor; tolerate optional brackets/whitespace around fields. - Level matching case-insensitive; explain how multi-line messages (stack traces) are handled or skipped. - Runnable snippet, no dependencies. </constraints> <format> Return the regex, then the Group | Meaning table, then the filtering snippet, then the filtered records from my sample. </format>

You are a regex engineer who splits delimited records, aware of quoting pitfalls. <context> I need to split delimited lines (CSV, TSV, pipe-separated) into fields with a regex, handling quoted fields that contain the delimiter. Deliver a ready-to-use pattern with explanation and a snippet, plus honest limits. </context> <inputs> - Delimiter: [COMMA / TAB / PIPE / OTHER] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Fields can be quoted: [YES / NO] - Quotes can contain the delimiter or escaped quotes: [DESCRIBE] - Sample lines: [PASTE 3-5] </inputs> <task> Write a regex that splits a single line into fields, correctly keeping quoted sections that contain the delimiter as one field. Explain the pattern. Provide a snippet that parses my sample lines into arrays. Then clearly state where regex CSV parsing breaks (embedded newlines, escaped quotes) and recommend a real CSV parser for full files. </task> <constraints> - Valid syntax for the flavor; handle empty fields and trailing delimiters. - Do NOT overpromise: be explicit that RFC 4180 edge cases (multiline quoted fields) need a proper parser. - Runnable snippet, no dependencies. </constraints> <format> Return the regex, then the breakdown, then the snippet with parsed output for my samples, then a clear 'use a CSV library when...' caveat. </format>

You are a regex engineer who mines error signals out of noisy logs. <context> I need to detect and extract error blocks or stack-trace signatures from a log file so I can group and count them. Deliver a ready-to-use regex with explanation and a snippet. </context> <inputs> - Language/runtime of the traces: [E.G. JAVA, PYTHON, NODE, .NET] - Sample log with an error block: [PASTE A SNIPPET] - What to capture: [EXCEPTION TYPE / TOP FRAME / FULL BLOCK] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] </inputs> <task> Write a regex that identifies the start of an error/exception and captures the requested signature (e.g. exception class plus first frame). Explain the pattern. Provide a snippet that scans the log, extracts each error signature, and produces a count per unique signature. Show the grouped output for my sample. </task> <constraints> - Correct multiline/dotall handling for the flavor; capture across the relevant lines only. - Normalize signatures (strip line numbers/addresses) so the same error groups together; explain how. - Runnable snippet, no dependencies. </constraints> <format> Return the regex, then the breakdown, then the scan-and-count snippet, then a table of Signature | Count from my sample. </format>

You are a regex engineer who converts semi-structured text into clean records. <context> I have semi-structured text (invoices, receipts, order confirmations, notes) and need regex to pull key fields into a structured record. Deliver a ready-to-use set of patterns with explanation and a snippet. </context> <inputs> - Sample text: [PASTE A REPRESENTATIVE BLOCK] - Fields to extract: [E.G. order number, date, total, customer, items] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Output shape: [JSON OBJECT / CSV ROW] </inputs> <task> Write one focused regex per field (labeled), each robust to small formatting differences. Explain each. Provide a snippet that runs all patterns over my sample and assembles a single structured record in the requested output shape. Show the assembled record for my sample, marking any field it could not find as null. </task> <constraints> - Valid syntax for the flavor; anchor to field labels where present to avoid false hits. - Tolerate optional whitespace, currency symbols, and label variations; explain the tolerance. - Runnable snippet; missing fields become null, never crash. </constraints> <format> Return a Field | Regex table, then a short breakdown of the tricky ones, then the assembly snippet, then the structured record from my sample. </format>

You are a regex engineer who sanitizes messy text fields. <context> I need regex to strip unwanted characters from text (control chars, emojis, non-printable bytes, invisible unicode, HTML entities) while keeping the real content. Deliver a ready-to-use pattern with explanation and examples. </context> <inputs> - Regex flavor / language: [E.G. JAVASCRIPT, PYTHON] - Remove: [EMOJIS / CONTROL CHARS / NON-ASCII / ZERO-WIDTH CHARS / HTML ENTITIES] - Keep: [E.G. ACCENTED LETTERS, BASIC PUNCTUATION] - Sample dirty text: [PASTE A SNIPPET] </inputs> <task> Write the cleaning regex (or a short ordered set) plus the replacement (usually empty). Explain the character classes / unicode ranges used. Provide a snippet that cleans my sample and prints before/after. Confirm it preserves the characters I want to keep. </task> <constraints> - Correct unicode property/flag support for the flavor (e.g. the u flag, \\p{...} classes); explain any engine limitations. - Do not strip characters the user asked to keep; explain the guard. - Runnable snippet, no dependencies; idempotent. </constraints> <format> Return the regex(es), then the character-class breakdown, then the cleaning snippet, then a before/after of my sample. </format>

You are a regex engineer who standardizes inconsistent data values. <context> I need regex to standardize a column of values (trim, collapse internal spacing, unify separators, fix casing, dedupe repeated tokens). Deliver a ready-to-use recipe with explanation and examples. </context> <inputs> - Tool / flavor: [E.G. PYTHON, JAVASCRIPT, SED] - Value type: [E.G. NAMES, TAGS, SKUS, ADDRESSES] - Rules: [TRIM / COLLAPSE SPACES / SEPARATOR TO X / TITLE-CASE / REMOVE DUP TOKENS] - Sample values: [PASTE 5-8] </inputs> <task> Provide an ordered search/replace recipe (one step per rule) that standardizes the values, each with regex, replacement, and a one-line reason. Explain the order. Provide a snippet that applies the whole recipe to my samples and prints before/after for each value. </task> <constraints> - Correct syntax/flags for the tool; each step idempotent and re-runnable. - Deduping repeated adjacent tokens via backreference; explain the pattern. - Preserve meaningful characters; no data loss. </constraints> <format> Return a numbered recipe (Step | Search | Replace | Why), then the runnable snippet, then a before/after table for my samples. </format>

You are a regex engineer who redacts sensitive data from text and logs. <context> I need regex to detect and mask PII (emails, phone numbers, credit cards, SSNs, API keys) in text before sharing or logging. Deliver ready-to-use patterns with explanation, a masking snippet, and clear limits. </context> <inputs> - Data types to mask: [EMAILS / PHONES / CREDIT CARDS / SSNS / API KEYS / OTHER] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Masking style: [FULL REPLACE WITH [REDACTED] / KEEP LAST 4 DIGITS / HASH] - Sample text: [PASTE A SNIPPET] </inputs> <task> Write one labeled regex per data type. Explain each. Provide a snippet that runs all patterns over my sample and replaces matches per the chosen masking style (e.g. keep last 4 of a card). Show before/after. Then state clearly that regex redaction is best-effort and can miss formats, so it must not be the only control for compliance. </task> <constraints> - Valid syntax for the flavor; minimize false positives on non-sensitive numbers (explain how). - Never log or echo the raw captured value; mask in place. - Be explicit about the limits and recommend a dedicated DLP/tokenization tool for compliance-grade needs. </constraints> <format> Return a Data type | Regex table, then the masking snippet, then a before/after of my sample, then a clear 'not sufficient for compliance alone' caveat. </format>

You are a regex engineer who repairs text mangled by encoding issues. <context> I have text with encoding artifacts (mojibake like \u00e2\u20ac\u2122, smart quotes, non-breaking spaces, stray HTML entities). I need regex to clean it into plain, consistent text. Deliver a ready-to-use recipe with explanation and examples. </context> <inputs> - Tool / flavor: [E.G. PYTHON, JAVASCRIPT] - Artifacts present: [SMART QUOTES / EM-DASHES / NBSP / MOJIBAKE / HTML ENTITIES] - Target: [STRAIGHT ASCII / KEEP UNICODE BUT NORMALIZE] - Sample text: [PASTE A SNIPPET] </inputs> <task> Provide an ordered search/replace recipe mapping each artifact to its clean equivalent (e.g. curly quotes to straight, nbsp to space, common mojibake sequences to the right char). Explain each mapping. Provide a snippet that applies the recipe to my sample and prints before/after. Note where a proper decode/normalize step is the real fix versus a regex patch. </task> <constraints> - Correct unicode escapes and flags for the tool; be careful not to damage legitimate characters. - Idempotent recipe; safe to re-run. - Recommend fixing the source encoding when possible instead of only patching symptoms. </constraints> <format> Return a mapping table (Artifact | Replace with | Why), then the snippet, then a before/after of my sample, then a one-line 'fix the source encoding when you can' note. </format>

You are a regex engineer who validates and reshapes tabular data columns. <context> I have a column of values that should follow one format but has strays, and sometimes one field needs splitting into several. I need regex to (a) flag invalid rows and (b) split a combined field. Deliver ready-to-use patterns with explanation and a snippet. </context> <inputs> - Expected format of the column: [DESCRIBE OR SAMPLE] - Split task: [E.G. 'City, State ZIP' INTO THREE FIELDS - DESCRIBE] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT] - Sample values (mix of good and bad): [PASTE 6-10] </inputs> <task> Write a validation regex that matches only well-formed values, and a separate splitting regex with capture groups for the combined field. Explain both. Provide a snippet that flags each sample value as VALID/INVALID and, for valid ones, splits it into the target columns. Show a results table for my samples. </task> <constraints> - Valid syntax for the flavor; anchored validation, tolerant splitting where whitespace varies. - Clearly separate validation from extraction; explain why using two patterns is cleaner. - Runnable snippet; invalid rows are flagged, never silently dropped. </constraints> <format> Return the validation regex and the splitting regex, then breakdowns, then the snippet, then a table of Value | Valid? | Split fields for my samples. </format>

You are a regex expert who teaches and applies lookaround assertions. <context> I need a regex that matches based on context without consuming it, using lookahead and/or lookbehind. Deliver a ready-to-use pattern with a clear explanation and examples. </context> <inputs> - What to match: [DESCRIBE, E.G. A NUMBER ONLY WHEN PRECEDED BY $ / A WORD NOT FOLLOWED BY ':'] - Regex flavor / language: [E.G. JAVASCRIPT, PYTHON, PCRE, .NET] - Positive or negative context: [DESCRIBE THE CONDITION] - Sample text: [PASTE A SNIPPET] </inputs> <task> Write the regex using the appropriate positive/negative lookahead (?=...)(?!...) and/or lookbehind (?<=...)(?<!...). Explain exactly what each assertion checks and why the matched text excludes the context. Provide a test table with matches and non-matches from my sample, showing precisely which characters are captured. </task> <constraints> - Confirm the named flavor SUPPORTS lookbehind (JS, .NET, PCRE, modern Python do; some don't) and note fixed-width limitations if any. - Valid copy-paste syntax; be explicit about what is inside vs outside the match. - If lookbehind is unsupported, provide a capture-group workaround. </constraints> <format> Return the regex, then a breakdown of each assertion, then a match/non-match table highlighting the captured span, then a note on flavor support. </format>

You are a regex expert who handles delimiter matching and its limits. <context> I need to match content inside delimiters (parentheses, brackets, braces, quotes), possibly nested. Deliver a ready-to-use pattern with explanation, plus an honest verdict on whether regex can handle my nesting. </context> <inputs> - Delimiters: [E.G. ( ), [ ], { }, "..."] - Nesting depth: [NONE / ONE LEVEL / ARBITRARY] - Regex flavor / language: [E.G. PCRE, PYTHON regex MODULE, .NET, JAVASCRIPT] - Sample text: [PASTE A SNIPPET] </inputs> <task> If nesting is none or fixed, write a straightforward regex and explain it. If arbitrary nesting is required, state plainly that classic regex cannot match arbitrary nesting, then provide the recursive/balancing-group solution IF the named flavor supports it (PCRE (?R), .NET balancing groups, Python regex module) or recommend a parser otherwise. Provide a match table for my sample. </task> <constraints> - Be honest about the theoretical limit; do not fake a pattern that silently fails on deep nesting. - Use the correct recursion/balancing syntax for the exact flavor if applicable. - Valid, copy-paste syntax; explain the escape/greediness choices. </constraints> <format> Return the regex (or the parser recommendation), then the breakdown, then a match table for my sample, then a clear one-line verdict on regex feasibility for my nesting depth. </format>

You are a regex performance expert. <context> I have a regex that is either grabbing too much (greedy) or dangerously slow on some inputs (catastrophic backtracking). I need a corrected, efficient pattern with an explanation. Deliver a ready-to-use fix. </context> <inputs> - Regex flavor / language: [E.G. JAVASCRIPT, PYTHON, PCRE] - My current regex: [PASTE IT] - The problem: [MATCHES TOO MUCH / TIMES OUT / SLOW ON LONG INPUT] - Sample inputs (including a bad one): [PASTE] </inputs> <task> Diagnose why my pattern is greedy or backtracks catastrophically. Rewrite it using lazy quantifiers, atomic groups or possessive quantifiers (if the flavor supports them), or by restructuring to avoid nested/overlapping quantifiers. Explain the fix. Provide a before/after showing correct matches and note the performance improvement on the bad input. </task> <constraints> - Valid syntax for the flavor; only use atomic/possessive features the flavor actually supports (note JS lacks them and suggest alternatives). - Preserve the intended matches exactly while removing the pathology. - Explain the root cause (e.g. (a+)+ style overlap) in one or two sentences. </constraints> <format> Return the fixed regex, then a diagnosis of the original, then a before/after match table, then a one-line note on the performance gain. </format>

You are a regex expert who structures complex alternations cleanly. <context> I need one regex that matches several distinct-but-related formats (alternation), ideally capturing which variant matched. Deliver a ready-to-use pattern with explanation and examples. </context> <inputs> - The variants to match: [LIST EACH FORMAT WITH A SAMPLE] - Regex flavor / language: [E.G. PYTHON, JAVASCRIPT, PCRE] - Need to know which variant matched: [YES / NO] - Should any variant take priority: [DESCRIBE ORDER IF IT MATTERS] </inputs> <task> Write ONE regex using ordered alternation that matches all listed variants, with a named group per variant (or one shared structure) so I can tell which matched. Explain the ordering (why the most specific alternative comes first) and any shared prefix factoring. Provide a test table showing each variant sample and which branch matched. </task> <constraints> - Valid syntax for the flavor; correct alternation grouping and anchoring. - Order alternatives so a broad branch doesn't shadow a specific one; explain the ordering. - Keep it readable; if long, provide a verbose/commented version. </constraints> <format> Return the regex, then the branch breakdown, then a test table (Input | Matched variant), then a note on adding a new variant later. </format>

You are a regex expert who reverse-engineers and hardens patterns. <context> Someone handed me a regex I don't fully understand (or that misbehaves) and I need a plain-English explanation plus a corrected version. Deliver a full breakdown and a fixed pattern. </context> <inputs> - The regex: [PASTE IT] - Regex flavor / language: [E.G. JAVASCRIPT, PYTHON, PCRE] - What it's supposed to do: [DESCRIBE] - Inputs where it fails or surprises me: [PASTE EXAMPLES] </inputs> <task> Explain the regex token by token in plain English. Identify what it actually matches versus the intended behavior, and pinpoint the bug on my failing inputs. Provide a corrected version, explain the change, and give a test table with matches and non-matches (including my failing inputs now passing). </task> <constraints> - Accurate to the exact flavor's semantics (flags, escaping, group types). - Distinguish clearly between what the ORIGINAL does and what the FIX does. - Valid, copy-paste-ready corrected pattern; note any required flags. </constraints> <format> Return a token-by-token table (Token | Meaning), then the diagnosis, then the fixed regex, then a before/after test table including my failing inputs. </format>