## 1

1. Taking Over Legacy Code: Nothing Scares You Like a 200-Character Regular Expression on One Line

Independent developers and small teams have probably all been through this: you take over an old project, flip open some validation logic, and there on your screen lies a single-line regular expression over a hundred characters long—no comments, no documentation, and the person who wrote it left the company three years ago.

When facing it, you usually have only three options:

1. Grind through it. Break it down segment by segment against MDN and regex testing sites. If you're unlucky enough to hit zero-width assertions, named groups, and a mix of greedy and lazy matching, one or two hours vanish just like that.
2. Work around it. Don't touch it—as long as it runs. But the moment a requirement comes in to change the matching rules, you're back paying down that debt, with even higher interest.
3. Rewrite it. The riskiest option—you're not even sure which edge cases the original regex matched, so rewriting is essentially blind modification.

My team previously worked on a user input validation module containing a nearly 200-character regex that validated a mix of phone numbers, emails, and national ID numbers. To confirm its boundary behavior, I manually constructed twenty-plus test cases and verified them one by one. It took nearly two hours, and I still wasn't sure I'd covered everything. Then similar things happened a few more times, each costing a couple of hours. A rough tally: on "deciphering other people's regexes" alone, the team burned several full working days per year.

The essence of the problem is: regular expressions are a language that is efficient to write and extremely expensive to read. The writer understands it in the moment; the reader pays multiples of that time. And AI happens to be excellent at driving down that "interpretation cost."

2. Four Things AI Can Do for You

Hand this scenario to a large language model (mainstream models like Claude, GPT-4o, and DeepSeek all handle it well), and it can reliably do four things:

1. Break down the structure segment by segment. Split the regex by groups, quantifiers, and assertions, explaining each piece in natural language—what it matches and what it doesn't.
2. Flag suspicious constructs. Things like catastrophic backtracking risks, unnecessary capturing groups, redundant escapes inside character classes—these are exactly the spots human eyes tend to skim past.
3. Generate positive and negative examples. A set of strings that should match and a set that shouldn't, ready to paste straight into unit tests.
4. Provide equivalent rewrites. Rewrite it in a more readable form (e.g., named groups, the x mode with comments, or simply splitting it into multiple pieces of code) while preserving behavior.

3. My Actual Workflow

Step 1: Feed the regex to the model along with context. Pasting just the regex itself yields mediocre results. Add the language it lives in (JavaScript/Python/Java regex dialects differ), a description of its purpose, and one known matching example—the explanation quality improves dramatically.

Step 2: Require structured output. I consistently ask the model to respond in the format "overall function → segment-by-segment breakdown → 5 positive examples → 5 negative examples → risk points → optional rewrite," so it can be archived directly into project documentation.

Step 3: Back-verify with the generated examples. I immediately run the model-generated positive and negative examples through a regex testing tool or unit tests. Don't skip this step—AI occasionally gets things wrong with full confidence, and testing is the final gate.

Step 4: Solidify the explanation as comments. Write the breakdown results directly back into code comments or documentation—one interpretation, and the whole team benefits.

With this workflow, that 200-character regex mentioned earlier took about 3 minutes from pasting it in to getting a complete breakdown, 12 test cases, and an annotated rewritten version (including my verification in the testing tool). Compared with roughly 2 hours of manual dissection before, that's over 90% time savings per instance. Assuming the team hits 20 similar scenarios a year, that's over 30 hours saved—nearly a full working week.

4. Before and After: Doing the Math

Labor costs are the visible part; there's also an invisible benefit: the courage to modify legacy code. Regexes you used to detour around now have a moat of test cases, dramatically lowering the decision cost of refactoring.

5. A Reusable Prompt Template

Save the snippet below as a code snippet, and whenever you hit an incomprehensible regex, just replace the placeholders:

你是一位资深正则表达式专家。请解析下面这段正则，并按以下格式输出：

【语言/方言】{填写：如 JavaScript / Python / Java}
【正则原文】{粘贴正则，或描述正则所在代码片段}
【已知用途】{填写：如校验用户输入的手机号}
【已知样例】{填写：一个确定能匹配的字符串，可选}

输出格式要求：
1. 整体功能：用一两句话概括它匹配什么；
2. 逐段拆解：把正则切分成逻辑片段，逐段解释含义，标注分组编号与命名分组；
3. 正例：给出5个应该匹配成功的字符串，并说明各自命中了哪部分规则；
4. 反例：给出5个应该匹配失败的字符串，并说明为什么失败；
5. 风险点：指出潜在问题，如灾难性回溯、贪婪匹配歧义、方言兼容性、可读性问题；
6. 可选改写：给出一个等价但更可读的版本（可用命名分组或拆成多段代码），并说明改动理由。

注意：只基于给定信息分析，不确定的地方明确标注“待确认”，不要臆测。

Two practical tips: first, the negative examples section is especially valuable—people get lazy when thinking up negative examples manually, and that's precisely where boundary bugs hide; second, the "mark as to-be-confirmed" constraint effectively reduces the model's confident nonsense.

6. A Few Reminders

• Be explicit about dialect differences. JS named groups are written differently from Python's, and lookahead support varies too. If you don't specify, the model will just pick a default.
• Run AI's analysis through tests. Running the generated examples costs almost nothing but catches the vast majority of incorrect explanations.
• Sanitize sensitive data first. Regexes sometimes embed business prefixes or internal numbering schemes—scrub those before pasting to a model.

Final Thoughts

Regexes are just the entry point. The same "AI breakdown + example generation + test verification" workflow can be fully reused for complex SQL, legacy configuration files, and third-party API message formats. This kind of work—expensive to read, reusable once written correctly—is exactly one of the most cost-effective AI application scenarios today.

If you haven't integrated AI capabilities yet, or want to freely switch between multiple models for tasks like this, try Thistoken's unified access service—one configuration, multiple models available: https://api.thistoken.ai/register

---

Ready to try it yourself? Sign up at https://api.thistoken.ai/register to get your API key and start building.