← Build log

The 80/20 Rule: Why We Chose Regex Over AI for Text Formatting

ProductStrategySoftwareEngineeringCustomerTrustParetoRule

Published: May 2025
Author: Jeremy Geiger
Tags: #ProductStrategy #SoftwareEngineering #CustomerTrust #ParetoRule

The Temptation of AI Everything

In 2024, there’s an almost magnetic pull to solve every problem with AI. LLMs are incredibly powerful, and the temptation to throw them at every challenge is real. When we were designing VoiceCatcher’s intelligent text formatting system, the “obvious” solution seemed to be: just use an AI model to clean up the transcribed text.

But sometimes the most obvious solution isn’t the right one.

The Pareto Principle in Action

The Pareto Principle (80/20 rule) suggests that 80% of effects come from 20% of causes. In software engineering, this often translates to: 80% of user value comes from 20% of the features.

When we analyzed what users actually needed from text formatting, the results were surprisingly simple:

The Real 80% of User Needs:

  • Capitalize sentence beginnings ("today i want to" → "Today I want to")
  • Fix the “I” pronoun ("i think" → "I think")
  • Add bullet points for lists ("also we need to" → "• we need to")
  • Remove filler words ("um, so, like" → clean text)
  • Basic punctuation (periods at sentence ends)

These aren’t complex AI problems. They’re pattern matching problems that software engineering solved decades ago.

Regex: The Humble Powerhouse

Here’s what 80% of our formatting looks like:

// Capitalize sentence beginnings
.replace(/(^|[.!?]\s*)([a-z])/g, (match, punctuation, letter) =>
  punctuation + letter.toUpperCase())

// Fix "I" pronoun
.replace(/\bi\b/g, 'I')

// Detect bullet points from speech patterns
if (/^(also|additionally|we need to|make sure to)/i.test(sentence)) {
  return `• ${cleanSentence}`;
}

// Remove filler words
.replace(/\b(um|uh|er|ah)\s+/gi, '')

That’s it. No model downloads, no API calls, no 2-second processing delays, no unpredictable outputs. Just fast, reliable, predictable text processing.

Why This Matters for Customer Trust

Here’s the strategic insight that changed everything: Customer trust isn’t built by impressive technology—it’s built by reliable, predictable experiences.

The AI Approach Problems:

  • Unpredictable: AI might format perfectly 95% of the time, but that 5% creates user anxiety
  • Slow: Model inference adds latency to the user’s workflow
  • Black Box: Users can’t understand why their text changed
  • Failure Modes: When AI fails, it fails in unexpected ways

The Regex Approach Benefits:

  • Predictable: Same input always produces same output
  • Fast: Millisecond processing, no workflow interruption
  • Transparent: Users can see exactly what rules applied
  • Debuggable: When something’s wrong, we can fix the specific rule

Customer Trust as North Star

Throughout this decision process, we kept coming back to one question: What builds user trust?

The answer wasn’t “the most advanced AI.” It was:

  1. Reliability: Features that work the same way every time
  2. Transparency: Users understand what’s happening to their text
  3. Control: Users can enable/disable specific formatting rules
  4. Safety: Original text is always preserved and accessible

A user told us: “I don’t care if it’s powered by AI or magic pixie dust. I just need to trust that my words won’t get mangled.”

That’s wisdom.

The Software Engineering Fundamentals

There’s something beautiful about solving problems with the right tool, not the newest tool. Software engineering has already solved these text processing challenges:

  • Regular expressions for pattern matching (1956)
  • String manipulation algorithms for text processing (1960s)
  • State machines for parsing structured input (1940s)

These aren’t “old” technologies—they’re proven technologies. They’ve been battle-tested for decades, optimized by thousands of engineers, and they work reliably across billions of use cases.

The Strategic Insight

The real breakthrough wasn’t technical—it was strategic: Focus on the 20% of features that deliver 80% of user value, and implement them with proven, reliable technology.

This approach:

  • Accelerated development by 3-4 weeks (no AI model integration)
  • Improved reliability with predictable, debuggable logic
  • Enhanced user trust through transparent, controllable formatting
  • Simplified maintenance with straightforward code patterns

When AI Makes Sense (And When It Doesn’t)

This isn’t an anti-AI post. AI is powerful for problems that genuinely require intelligence:

Good AI Use Cases:

  • Complex natural language understanding
  • Context-aware content generation
  • Ambiguous intent interpretation
  • Creative problem solving

Questionable AI Use Cases:

  • Simple pattern matching
  • Deterministic text transformations
  • Rule-based formatting
  • Predictable data processing

The Bigger Lesson

The technology industry has a tendency to chase the shiny new thing. But the best products are often built by choosing the right tool for each job, not the newest tool.

Customer trust is built through consistency, reliability, and transparency. Sometimes that means AI, sometimes it means regex, and sometimes it means a carefully designed user interface that puts control back in the user’s hands.

For VoiceCatcher’s Future

This decision set a precedent for how we approach product development:

  1. Start with user needs, not technology capabilities
  2. Apply the Pareto Principle to focus on high-impact, simple solutions
  3. Choose proven technologies for predictable problems
  4. Keep customer trust as the primary success metric
  5. Use AI strategically, not automatically

The result? We shipped intelligent text formatting in 4 weeks instead of 10, with higher reliability and user satisfaction than any AI-powered solution could have delivered.

Sometimes the best engineering decision is the boring one.

About VoiceCatcher: A local voice-to-text application that prioritizes flow state protection and user trust through thoughtful engineering decisions. Built by a solo developer who believes great software comes from understanding users, not just understanding technology.

What’s your experience with choosing proven vs. cutting-edge solutions? I’d love to hear about your own 80/20 engineering decisions.