Regex Master
Overview
The Regex Master skill covers building correct, readable, and efficient regular expressions for common text processing tasks. It explains character classes, quantifiers, groups, alternation, anchors, and lookahead/lookbehind assertions. It includes a quick-reference library of battle-tested patterns for emails, URLs, dates, phone numbers, IP addresses, and log lines. Every regex is explained token by token so you understand what it does rather than just copying it.
When to Use
- Validating user input (email, phone, postal code, URL)
- Extracting structured data from unstructured text (logs, documents, HTML attributes)
- Search-and-replace with patterns in code editors or scripts
- Parsing delimited or fixed-format text files
- Filtering or transforming data with
grep, sed, awk, Python, or JavaScript
When NOT to Use
- Parsing HTML or XML (use a DOM parser: BeautifulSoup, DOMParser — regex is unreliable for nested structures)
- Parsing programming languages or complex grammars (use a proper parser/AST)
- Matching natural language semantics (use NLP tools)
- When a simple string split or indexOf is sufficient — don't reach for regex when a simpler tool works
Quick Reference
Building Blocks
| Token |
Meaning |
Example |
Matches |
. |
Any character except newline |
a.c |
abc, a1c, a-c |
\d |
Digit [0-9] |
\d+ |
42, 007 |
\w |
Word char [a-zA-Z0-9_] |
\w+ |
hello, foo_2 |
\s |
Whitespace |
\s+ |
space, tab, newline |
\D |
Non-digit |
\D |
a, -, |
\W |
Non-word char |
\W |
!, @, |
\S |
Non-whitespace |
\S+ |
hello, 42 |
^ |
Start of string/line |
^Hello |
Hello world |
$ |
End of string/line |
world$ |
Hello world |
\b |
Word boundary |
\bcat\b |
the cat sat (not catch) |
[abc] |
Character class |
[aeiou] |
any vowel |
[^abc] |
Negated class |
[^0-9] |
any non-digit |
[a-z] |
Range |
[a-zA-Z] |
any letter |
Quantifiers
| Quantifier |
Meaning |
Greedy? |
* |
0 or more |
Yes |
+ |
1 or more |
Yes |
? |
0 or 1 (optional) |
Yes |
{n} |
Exactly n |
Yes |
{n,m} |
Between n and m |
Yes |
{n,} |
n or more |
Yes |
*? |
0 or more |
No (lazy) |
+? |
1 or more |
No (lazy) |
Groups & References
| Syntax |
Meaning |
(abc) |
Capturing group |
(?:abc) |
Non-capturing group |
(?P<name>abc) |
Named capturing group (Python) |
(?<name>abc) |
Named capturing group (JS/PCRE) |
\1, $1 |
Back-reference to group 1 |
a|b |
Alternation: a or b |
Lookaround
| Syntax |
Meaning |
(?=abc) |
Positive lookahead: followed by abc |
(?!abc) |
Negative lookahead: NOT followed by abc |
(?<=abc) |
Positive lookbehind: preceded by abc |
(?<!abc) |
Negative lookbehind: NOT preceded by abc |
Flags
| Flag |
Effect |
i / re.IGNORECASE |
Case-insensitive |
m / re.MULTILINE |
^/$ match line boundaries |
s / re.DOTALL |
. matches newlines |
g |
Global — find all matches (JS) |
x / re.VERBOSE |
Allow whitespace/comments in pattern |
Common Patterns Library
| Pattern |
Regex |
| Email (simple) |
^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$ |
| URL |
https?://[\w.-]+(?:/[\w./?=#&%-]*)? |
| IPv4 |
\b(?:\d{1,3}\.){3}\d{1,3}\b |
| Date (YYYY-MM-DD) |
\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01]) |
| Time (HH:MM:SS) |
(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d |
| US Phone |
\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4} |
| ZIP code (US) |
\d{5}(?:-\d{4})? |
| Credit card |
\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b |
| Hex color |
#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})\b |
| UUID |
[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12} |
| Semantic version |
\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)? |
| HTML tag (simple) |
<([a-z][a-z0-9]*)\b[^>]*>(.*?)</\1> |
| Slug |
^[a-z0-9]+(?:-[a-z0-9]+)*$ |
Instructions
Define what to match precisely in plain English first
- What does a valid match look like? (examples)
- What should NOT match? (counter-examples)
- Where in the string must it appear? (anywhere, start, full string)
Build the regex incrementally
- Start with the simplest pattern that matches one known good example.
- Add character classes, quantifiers, and anchors one at a time.
- Test after each addition against both positive and negative examples.
Anchor appropriately
- Use
^...$ for full-string validation (email, phone, slug).
- Omit anchors for searching within a larger text.
- Use
\b for word-boundary matching to avoid partial matches.
Choose capturing vs. non-capturing groups
- Use
(?:...) for grouping without capturing when you don't need the group's value.
- Use named groups
(?P<year>\d{4}) for readability and reliable extraction.
Handle edge cases explicitly
- Optional parts:
(?:\.com)? — the ? makes the group optional.
- Unicode: use
re.UNICODE flag or \p{L} (PCRE2) for non-ASCII letters.
- Newlines: use the
s / DOTALL flag if . should match newlines.
Test thoroughly
- Test against: typical valid input, edge-of-valid input, invalid input that looks similar.
- Use online tools: regex101.com (with detailed explanation), regexr.com.
Document the regex
- Always add a comment explaining what the regex matches.
- Use verbose mode (
re.VERBOSE in Python) to add inline comments for complex patterns.
Examples
Example 1: Validate an email address
Input: "Write a regex to validate email addresses."
Output:
import re
# Email validation regex
# Allows: local part with letters, digits, dots, plus, hyphen
# Requires: @ symbol
# Domain: letters, digits, hyphens
# TLD: 2+ letters
EMAIL_REGEX = re.compile(
r'^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$',
re.IGNORECASE
)
# Verbose version explaining each token:
EMAIL_REGEX_VERBOSE = re.compile(r'''
^ # Start of string
[\w.+-]+ # Local part: word chars, dots, plus, hyphen (1 or more)
@ # Literal @ symbol
[\w-]+ # Domain name: word chars and hyphens (1 or more)
\. # Literal dot (escaped)
[a-zA-Z]{2,} # TLD: 2 or more letters
$ # End of string
''', re.VERBOSE | re.IGNORECASE)
def validate_email(email: str) -> bool:
return bool(EMAIL_REGEX.match(email))
# Tests
assert validate_email("alice@example.com") == True
assert validate_email("alice.smith+tag@sub.domain.org") == True
assert validate_email("alice@example.c") == False # TLD too short
assert validate_email("@example.com") == False # Missing local part
assert validate_email("alice@.com") == False # Missing domain
assert validate_email("alice example.com") == False # Missing @
What it matches / rejects:
✅ alice@example.com
✅ alice.smith+filter@sub.domain.co.uk
✅ user123@my-company.io
❌ alice@example.c (TLD must be 2+ chars)
❌ alice @example.com (spaces not allowed)
❌ alice@@example.com (double @)
❌ @example.com (empty local part)
Note: RFC 5321 email validation is extremely complex. This regex covers ~99% of real-world valid addresses. For production, combine with a verification email.
Example 2: Extract data from log lines
Input: Parse Apache Combined Log Format lines:
192.168.1.1 - frank [10/Oct/2024:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326 "http://example.com/" "Mozilla/5.0"
Output:
import re
from datetime import datetime
LOG_PATTERN = re.compile(r'''
^
(?P<ip>\d{1,3}(?:\.\d{1,3}){3}) # Client IP address
\s-\s # Separator " - "
(?P<user>\S+) # Remote user (- if none)
\s
\[(?P<timestamp>[^\]]+)\] # Timestamp in brackets
\s
"(?P<method>[A-Z]+) # HTTP method
\s(?P<path>[^\s"]+) # Request path
\s(?P<protocol>HTTP/[\d.]+)" # Protocol
\s
(?P<status>\d{3}) # HTTP status code
\s
(?P<size>\d+|-) # Response size (or - if none)
(?:\s"(?P<referer>[^"]*)")? # Optional referer
(?:\s"(?P<user_agent>[^"]*)")? # Optional user agent
$
''', re.VERBOSE)
def parse_log_line(line: str) -> dict | None:
match = LOG_PATTERN.match(line.strip())
if not match:
return None
data = match.groupdict()
data['status'] = int(data['status'])
data['size'] = int(data['size']) if data['size'] != '-' else 0
return data
# Test
line = '192.168.1.1 - frank [10/Oct/2024:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326 "http://example.com/" "Mozilla/5.0"'
result = parse_log_line(line)
print(result)
# {
# 'ip': '192.168.1.1', 'user': 'frank',
# 'timestamp': '10/Oct/2024:13:55:36 -0700',
# 'method': 'GET', 'path': '/index.html',
# 'protocol': 'HTTP/1.1', 'status': 200,
# 'size': 2326, 'referer': 'http://example.com/',
# 'user_agent': 'Mozilla/5.0'
# }
JavaScript equivalent for the same pattern:
const LOG_PATTERN = /^(\d{1,3}(?:\.\d{1,3}){3}) - (\S+) \[([^\]]+)\] "([A-Z]+) ([^\s"]+) (HTTP\/[\d.]+)" (\d{3}) (\d+|-)(?: "([^"]*)")?(?: "([^"]*)")?$/;
function parseLogLine(line) {
const m = line.match(LOG_PATTERN);
if (!m) return null;
const [, ip, user, timestamp, method, path, protocol, status, size, referer, userAgent] = m;
return { ip, user, timestamp, method, path, protocol, status: +status, size: size === '-' ? 0 : +size, referer, userAgent };
}
Best Practices
- Build complex regex with named groups and verbose mode for readability
- Never use regex for HTML/XML parsing — use a DOM parser
- Test with regex101.com for interactive debugging and explanation
- Prefer specific character classes (
[a-z]) over . + filter to avoid surprise matches
- Use lazy quantifiers (
+?, *?) when you need the shortest match, not the longest
- Compile regex patterns once and reuse (
re.compile()) in performance-critical code
Common Mistakes
- Using
.* (greedy) when you want the shortest match — use .*? (lazy)
- Forgetting to escape
. — unescaped . matches any character
- Using
^/$ when multiline mode is needed (they match string boundaries by default, not line boundaries)
- Catastrophic backtracking with nested quantifiers like
(a+)+ on long non-matching input
- Not anchoring validation patterns —
\d+ matches the digits in abc123def
- Using capturing groups
() when non-capturing (?:) is sufficient — wastes memory
Tips & Tricks
- regex101.com shows a detailed token-by-token explanation and live testing
re.fullmatch() in Python is safer than re.match() for validation — no partial matches
- In JavaScript, prefer named groups:
/(?<year>\d{4})-(?<month>\d{2})/ — access via match.groups.year
- Use
sed -E or grep -P for extended/PCRE regex on the command line
- Atomic groups
(?>...) (PCRE) prevent backtracking — useful for catastrophic backtracking prevention
Related Skills
1---2name: regex-master3description: "Use this skill when building, explaining, or debugging regular expressions for pattern matching, validation, or text extraction. Trigger phrases: 'write a regex', 'match this pattern', 'validate this format', 'extract from text'. Not for natural language parsing or full grammar parsing (use a parser instead)."4version: 1.0.05author: community6tags: [coding, regex, pattern-matching, text-processing]7license: MIT8metadata:9 source: https://skillmd.com/skills/xcrrr/regex-master10---1112# Regex Master1314## Overview15The Regex Master skill covers building correct, readable, and efficient regular expressions for common text processing tasks. It explains character classes, quantifiers, groups, alternation, anchors, and lookahead/lookbehind assertions. It includes a quick-reference library of battle-tested patterns for emails, URLs, dates, phone numbers, IP addresses, and log lines. Every regex is explained token by token so you understand what it does rather than just copying it.1617## When to Use18- Validating user input (email, phone, postal code, URL)19- Extracting structured data from unstructured text (logs, documents, HTML attributes)20- Search-and-replace with patterns in code editors or scripts21- Parsing delimited or fixed-format text files22- Filtering or transforming data with `grep`, `sed`, `awk`, Python, or JavaScript2324## When NOT to Use25- Parsing HTML or XML (use a DOM parser: BeautifulSoup, DOMParser — regex is unreliable for nested structures)26- Parsing programming languages or complex grammars (use a proper parser/AST)27- Matching natural language semantics (use NLP tools)28- When a simple string split or indexOf is sufficient — don't reach for regex when a simpler tool works2930## Quick Reference3132### Building Blocks33| Token | Meaning | Example | Matches |34|-------|---------|---------|---------|35| `.` | Any character except newline | `a.c` | `abc`, `a1c`, `a-c` |36| `\d` | Digit `[0-9]` | `\d+` | `42`, `007` |37| `\w` | Word char `[a-zA-Z0-9_]` | `\w+` | `hello`, `foo_2` |38| `\s` | Whitespace | `\s+` | space, tab, newline |39| `\D` | Non-digit | `\D` | `a`, `-`, ` ` |40| `\W` | Non-word char | `\W` | `!`, `@`, ` ` |41| `\S` | Non-whitespace | `\S+` | `hello`, `42` |42| `^` | Start of string/line | `^Hello` | `Hello world` |43| `$` | End of string/line | `world$` | `Hello world` |44| `\b` | Word boundary | `\bcat\b` | `the cat sat` (not `catch`) |45| `[abc]` | Character class | `[aeiou]` | any vowel |46| `[^abc]` | Negated class | `[^0-9]` | any non-digit |47| `[a-z]` | Range | `[a-zA-Z]` | any letter |4849### Quantifiers50| Quantifier | Meaning | Greedy? |51|-----------|---------|---------|52| `*` | 0 or more | Yes |53| `+` | 1 or more | Yes |54| `?` | 0 or 1 (optional) | Yes |55| `{n}` | Exactly n | Yes |56| `{n,m}` | Between n and m | Yes |57| `{n,}` | n or more | Yes |58| `*?` | 0 or more | No (lazy) |59| `+?` | 1 or more | No (lazy) |6061### Groups & References62| Syntax | Meaning |63|--------|---------|64| `(abc)` | Capturing group |65| `(?:abc)` | Non-capturing group |66| `(?P<name>abc)` | Named capturing group (Python) |67| `(?<name>abc)` | Named capturing group (JS/PCRE) |68| `\1`, `$1` | Back-reference to group 1 |69| `a\|b` | Alternation: a or b |7071### Lookaround72| Syntax | Meaning |73|--------|---------|74| `(?=abc)` | Positive lookahead: followed by abc |75| `(?!abc)` | Negative lookahead: NOT followed by abc |76| `(?<=abc)` | Positive lookbehind: preceded by abc |77| `(?<!abc)` | Negative lookbehind: NOT preceded by abc |7879### Flags80| Flag | Effect |81|------|--------|82| `i` / `re.IGNORECASE` | Case-insensitive |83| `m` / `re.MULTILINE` | `^`/`$` match line boundaries |84| `s` / `re.DOTALL` | `.` matches newlines |85| `g` | Global — find all matches (JS) |86| `x` / `re.VERBOSE` | Allow whitespace/comments in pattern |8788### Common Patterns Library89| Pattern | Regex |90|---------|-------|91| Email (simple) | `^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$` |92| URL | `https?://[\w.-]+(?:/[\w./?=#&%-]*)?` |93| IPv4 | `\b(?:\d{1,3}\.){3}\d{1,3}\b` |94| Date (YYYY-MM-DD) | `\d{4}-(?:0[1-9]\|1[0-2])-(?:0[1-9]\|[12]\d\|3[01])` |95| Time (HH:MM:SS) | `(?:[01]\d\|2[0-3]):[0-5]\d:[0-5]\d` |96| US Phone | `\+?1?\s?\(?\d{3}\)?[\s.-]?\d{3}[\s.-]?\d{4}` |97| ZIP code (US) | `\d{5}(?:-\d{4})?` |98| Credit card | `\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b` |99| Hex color | `#(?:[0-9a-fA-F]{3}\|[0-9a-fA-F]{6})\b` |100| UUID | `[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}` |101| Semantic version | `\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?` |102| HTML tag (simple) | `<([a-z][a-z0-9]*)\b[^>]*>(.*?)</\1>` |103| Slug | `^[a-z0-9]+(?:-[a-z0-9]+)*$` |104105## Instructions1061071. **Define what to match precisely in plain English first**108 - What does a valid match look like? (examples)109 - What should NOT match? (counter-examples)110 - Where in the string must it appear? (anywhere, start, full string)1111122. **Build the regex incrementally**113 - Start with the simplest pattern that matches one known good example.114 - Add character classes, quantifiers, and anchors one at a time.115 - Test after each addition against both positive and negative examples.1161173. **Anchor appropriately**118 - Use `^...$` for full-string validation (email, phone, slug).119 - Omit anchors for searching within a larger text.120 - Use `\b` for word-boundary matching to avoid partial matches.1211224. **Choose capturing vs. non-capturing groups**123 - Use `(?:...)` for grouping without capturing when you don't need the group's value.124 - Use named groups `(?P<year>\d{4})` for readability and reliable extraction.1251265. **Handle edge cases explicitly**127 - Optional parts: `(?:\.com)?` — the `?` makes the group optional.128 - Unicode: use `re.UNICODE` flag or `\p{L}` (PCRE2) for non-ASCII letters.129 - Newlines: use the `s` / `DOTALL` flag if `.` should match newlines.1301316. **Test thoroughly**132 - Test against: typical valid input, edge-of-valid input, invalid input that looks similar.133 - Use online tools: regex101.com (with detailed explanation), regexr.com.1341357. **Document the regex**136 - Always add a comment explaining what the regex matches.137 - Use verbose mode (`re.VERBOSE` in Python) to add inline comments for complex patterns.138139## Examples140141### Example 1: Validate an email address142143**Input:** "Write a regex to validate email addresses."144145**Output:**146147```python148import re149150# Email validation regex151# Allows: local part with letters, digits, dots, plus, hyphen152# Requires: @ symbol153# Domain: letters, digits, hyphens154# TLD: 2+ letters155EMAIL_REGEX = re.compile(156 r'^[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}$',157 re.IGNORECASE158)159160# Verbose version explaining each token:161EMAIL_REGEX_VERBOSE = re.compile(r'''162 ^ # Start of string163 [\w.+-]+ # Local part: word chars, dots, plus, hyphen (1 or more)164 @ # Literal @ symbol165 [\w-]+ # Domain name: word chars and hyphens (1 or more)166 \. # Literal dot (escaped)167 [a-zA-Z]{2,} # TLD: 2 or more letters168 $ # End of string169''', re.VERBOSE | re.IGNORECASE)170171def validate_email(email: str) -> bool:172 return bool(EMAIL_REGEX.match(email))173174# Tests175assert validate_email("alice@example.com") == True176assert validate_email("alice.smith+tag@sub.domain.org") == True177assert validate_email("alice@example.c") == False # TLD too short178assert validate_email("@example.com") == False # Missing local part179assert validate_email("alice@.com") == False # Missing domain180assert validate_email("alice example.com") == False # Missing @181```182183**What it matches / rejects:**184```185✅ alice@example.com186✅ alice.smith+filter@sub.domain.co.uk187✅ user123@my-company.io188❌ alice@example.c (TLD must be 2+ chars)189❌ alice @example.com (spaces not allowed)190❌ alice@@example.com (double @)191❌ @example.com (empty local part)192```193194> **Note:** RFC 5321 email validation is extremely complex. This regex covers ~99% of real-world valid addresses. For production, combine with a verification email.195196---197198### Example 2: Extract data from log lines199200**Input:** Parse Apache Combined Log Format lines:201```202192.168.1.1 - frank [10/Oct/2024:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326 "http://example.com/" "Mozilla/5.0"203```204205**Output:**206207```python208import re209from datetime import datetime210211LOG_PATTERN = re.compile(r'''212 ^213 (?P<ip>\d{1,3}(?:\.\d{1,3}){3}) # Client IP address214 \s-\s # Separator " - "215 (?P<user>\S+) # Remote user (- if none)216 \s217 \[(?P<timestamp>[^\]]+)\] # Timestamp in brackets218 \s219 "(?P<method>[A-Z]+) # HTTP method220 \s(?P<path>[^\s"]+) # Request path221 \s(?P<protocol>HTTP/[\d.]+)" # Protocol222 \s223 (?P<status>\d{3}) # HTTP status code224 \s225 (?P<size>\d+|-) # Response size (or - if none)226 (?:\s"(?P<referer>[^"]*)")? # Optional referer227 (?:\s"(?P<user_agent>[^"]*)")? # Optional user agent228 $229''', re.VERBOSE)230231def parse_log_line(line: str) -> dict | None:232 match = LOG_PATTERN.match(line.strip())233 if not match:234 return None235 data = match.groupdict()236 data['status'] = int(data['status'])237 data['size'] = int(data['size']) if data['size'] != '-' else 0238 return data239240# Test241line = '192.168.1.1 - frank [10/Oct/2024:13:55:36 -0700] "GET /index.html HTTP/1.1" 200 2326 "http://example.com/" "Mozilla/5.0"'242result = parse_log_line(line)243print(result)244# {245# 'ip': '192.168.1.1', 'user': 'frank',246# 'timestamp': '10/Oct/2024:13:55:36 -0700',247# 'method': 'GET', 'path': '/index.html',248# 'protocol': 'HTTP/1.1', 'status': 200,249# 'size': 2326, 'referer': 'http://example.com/',250# 'user_agent': 'Mozilla/5.0'251# }252```253254JavaScript equivalent for the same pattern:255```javascript256const LOG_PATTERN = /^(\d{1,3}(?:\.\d{1,3}){3}) - (\S+) \[([^\]]+)\] "([A-Z]+) ([^\s"]+) (HTTP\/[\d.]+)" (\d{3}) (\d+|-)(?: "([^"]*)")?(?: "([^"]*)")?$/;257258function parseLogLine(line) {259 const m = line.match(LOG_PATTERN);260 if (!m) return null;261 const [, ip, user, timestamp, method, path, protocol, status, size, referer, userAgent] = m;262 return { ip, user, timestamp, method, path, protocol, status: +status, size: size === '-' ? 0 : +size, referer, userAgent };263}264```265266## Best Practices267- Build complex regex with named groups and verbose mode for readability268- Never use regex for HTML/XML parsing — use a DOM parser269- Test with regex101.com for interactive debugging and explanation270- Prefer specific character classes (`[a-z]`) over `.` + filter to avoid surprise matches271- Use lazy quantifiers (`+?`, `*?`) when you need the shortest match, not the longest272- Compile regex patterns once and reuse (`re.compile()`) in performance-critical code273274## Common Mistakes275- Using `.*` (greedy) when you want the shortest match — use `.*?` (lazy)276- Forgetting to escape `.` — unescaped `.` matches any character277- Using `^`/`$` when multiline mode is needed (they match string boundaries by default, not line boundaries)278- Catastrophic backtracking with nested quantifiers like `(a+)+` on long non-matching input279- Not anchoring validation patterns — `\d+` matches the digits in `abc123def`280- Using capturing groups `()` when non-capturing `(?:)` is sufficient — wastes memory281282## Tips & Tricks283- regex101.com shows a detailed token-by-token explanation and live testing284- `re.fullmatch()` in Python is safer than `re.match()` for validation — no partial matches285- In JavaScript, prefer named groups: `/(?<year>\d{4})-(?<month>\d{2})/` — access via `match.groups.year`286- Use `sed -E` or `grep -P` for extended/PCRE regex on the command line287- Atomic groups `(?>...)` (PCRE) prevent backtracking — useful for catastrophic backtracking prevention288289## Related Skills290- [sql-expert](../sql-expert/SKILL.md)291- [security-auditor](../security-auditor/SKILL.md)292- [test-writer](../test-writer/SKILL.md)