Why This Dev Used 40 Lines of Regex Instead of AI to Fix Resume Bullets

In 2026, suggesting regex over AI for text rewriting sounds almost contrarian. Every job board now offers "AI-powered resume optimization." ChatGPT can rewrite your bullets in seconds. So why would a developer deliberately choose regular expressions?

Because most resume problems aren't creative problems—they're structural ones. And structure is exactly what regex handles best.

A recent Dev.to post demonstrated a resume bullet improver built entirely with regex pattern matching, proving that 40 lines of deterministic rules can outperform generative AI for a specific, well-defined task: enforcing the Verb · What · Impact formula that recruiters and ATS systems actually scan for.

Why Most Resume Bullets Fail (and Why AI Doesn't Always Fix Them)

The post identifies two fatal resume mistakes that survive even after AI rewrites:

Weak openers. Bullets that start with "Responsible for," "Worked on," or "Helped with" telegraph passivity. They describe attendance, not achievement. A regex-based rewriter can enforce strong action verbs ("Built," "Reduced," "Architected") by matching these weak patterns and rejecting them outright.

Missing metrics. "Improved database performance" means nothing without a number. Regex can detect the absence of quantifiable impact—no percentages, no dollar figures, no time savings—and flag it immediately.

AI resume tools often add fluff to meet word counts or introduce generic corporate speak ("leveraged synergies," "drove alignment"). A rule-based system simply refuses to process bullets that don't match the required structure. No fluff. No hallucinations. No $20/month subscription.

The Verb · What · Impact Formula (Enforced Programmatically)

The formula is straightforward:

[Action Verb] + [Specific Task/Technology] + [Measurable Outcome]

Good example:

Reduced API response time by 64% by implementing Redis caching for PostgreSQL queries

Bad example:

Worked on improving backend performance using various optimization techniques

The regex approach works because this formula is structurally verifiable:

  1. Verb check: Does the bullet start with a strong past-tense verb from a whitelist? (^(Built|Reduced|Architected|Migrated|Deployed|Automated|Increased|Eliminated)\b)

  2. Specificity check: Does it mention concrete technologies, frameworks, or systems? (Match against common tech keywords or require capitalized proper nouns)

  3. Impact check: Does it include a number followed by a unit? (\d+%|\$[\d,]+|\d+x|\d+\s*(hours|users|requests))

If any check fails, the regex rewriter can either reject the bullet or apply transformation rules—swapping weak verbs for stronger alternatives, prompting for missing metrics, or stripping vague qualifiers.

When Deterministic Rules Beat Generative Models

This approach highlights a broader principle in developer tooling: not every text problem needs a language model.

Regex-based rewriting offers:

  • Predictability: The same input always produces the same output. No variance between runs.
  • Transparency: You can see exactly which pattern triggered which change. AI rewrites are black boxes.
  • Speed: Pattern matching is near-instantaneous. No API latency, no rate limits.
  • Privacy: Your resume never leaves your machine. No data sent to OpenAI, Anthropic, or any third-party service.
  • Cost: Zero runtime cost. No tokens, no credits, no monthly fees.

For developers building tools—whether for resumes, commit message linting, or log parsing—this is a reminder that finite-state automation still has a place. If your problem space has clear rules (and resume bullets do), regex or similar rule engines may be the better architecture.

The Implementation (What 40 Lines Actually Buys You)

While the original Dev.to post doesn't provide full source code, the concept is straightforward to implement:

import re

WEAK_VERBS = r'^(Responsible for|Worked on|Helped with|Assisted in|Participated in)'
STRONG_VERBS = ['Built', 'Reduced', 'Increased', 'Migrated', 'Automated', 'Deployed']
IMPACT_PATTERN = r'\d+%|\$[\d,]+|\dx|\d+\s*(ms|seconds|hours|users|requests|GB)'

def score_bullet(bullet):
    score = 0
    if re.match(WEAK_VERBS, bullet, re.IGNORECASE):
        return 0  # Auto-fail
    if any(bullet.startswith(v) for v in STRONG_VERBS):
        score += 3
    if re.search(IMPACT_PATTERN, bullet):
        score += 3
    if len(bullet.split()) >= 10:  # Sufficient detail
        score += 1
    return score

A full 40-line version could add:

  • Auto-replacement of weak verbs with strong alternatives
  • Detection of tech stack mentions (React, Kubernetes, PostgreSQL)
  • Warnings for bullets under a score threshold
  • Batch processing of entire resume sections

The point isn't to replace human judgment—it's to enforce a quality baseline before you spend time on deeper edits.

Takeaway: Match the Tool to the Problem

The resume bullet improver isn't anti-AI. It's a reminder that structured problems reward structured solutions.

Use AI when you need creativity, context interpretation, or handling of edge cases outside your rule set. Use regex (or parsers, validators, linters) when you need consistency, speed, and transparency.

For developers writing resumes in 2026, this matters: a 40-line script you control will never add hallucinated metrics, never rewrite your Rust experience as Ruby, and never send your salary history to a third-party API.

Sometimes the oldest tool in your belt is still the right one. Especially when the job is pattern matching, not pattern guessing.