regex-builder

name	regex-builder
description	Construct, test, explain, and debug regular expressions with clear documentation and edge case handling
layer	utility
category	text-processing
triggers	["regex for","regular expression","match pattern","explain this regex","regex help","validate format","parse this string"]
inputs	["Description of what to match (natural language)","Example strings that should match","Example strings that should NOT match","Target language/engine (JS, Python, Go, PCRE)"]
outputs	["Regex pattern with explanation","Commented/documented version","Test cases","Edge cases and known limitations","Alternative approaches if regex is not ideal"]
linksTo	["json-transformer","code-explainer","testing-patterns"]
linkedFrom	["shell-scripting","security-scanner"]
preferredNextSkills	["testing-patterns"]
fallbackSkills	["code-explainer"]
riskLevel	low
memoryReadPolicy	selective
memoryWritePolicy	selective
sideEffects	[]

Regex Builder Skill

Purpose

Regular expressions are powerful but notoriously hard to read and debug. This skill constructs correct, well-documented regex patterns from natural language descriptions, explains existing patterns in plain English, and always provides test cases to verify correctness.

Key Concepts

When to Use Regex (and When Not To)

Use regex for:

• Validating string formats (email, phone, date)
• Extracting structured parts from text
• Search and replace with patterns
• Log file parsing
• Simple tokenization

Do NOT use regex for:

• Parsing HTML/XML (use a DOM parser)
• Parsing JSON (use JSON.parse)
• Complex nested structures (use a proper parser/grammar)
• When a simple string.includes() / string.startsWith() suffices

Engine Differences

Feature	JavaScript	Python	Go	PCRE
Lookahead (?=...)	Yes	Yes	No	Yes
Lookbehind (?<=...)	Yes (ES2018+)	Yes	No	Yes
Named groups (?<name>...)	Yes	(?P<name>...)	(?P<name>...)	Both
Unicode \p{L}	Yes (/u flag)	Yes (regex module)	Yes	Yes
Atomic groups	No	No	No	Yes
Possessive quantifiers	No	No	No	Yes
Backreferences	Yes	Yes	No	Yes

Regex Building Blocks

ANCHORS
  ^       Start of string (or line with /m)
  $       End of string (or line with /m)
  \b      Word boundary
  \B      Not a word boundary

CHARACTER CLASSES
  .       Any character (except newline unless /s)
  \d      Digit [0-9]
  \D      Non-digit
  \w      Word character [a-zA-Z0-9_]
  \W      Non-word character
  \s      Whitespace [\t\n\r\f\v ]
  \S      Non-whitespace
  [abc]   Character set (a, b, or c)
  [^abc]  Negated set (not a, b, or c)
  [a-z]   Range

QUANTIFIERS
  *       0 or more (greedy)
  +       1 or more (greedy)
  ?       0 or 1 (greedy)
  {n}     Exactly n
  {n,}    n or more
  {n,m}   Between n and m
  *?      0 or more (lazy)
  +?      1 or more (lazy)

GROUPS
  (...)       Capturing group
  (?:...)     Non-capturing group
  (?<name>...)  Named capturing group
  (?=...)     Positive lookahead
  (?!...)     Negative lookahead
  (?<=...)    Positive lookbehind
  (?<!...)    Negative lookbehind
  |           Alternation (OR)

FLAGS
  /g      Global (all matches)
  /i      Case insensitive
  /m      Multiline (^ and $ match line boundaries)
  /s      Dotall (. matches newline)
  /u      Unicode mode