You’ve been there. Your post gets flagged. Your account gets restricted. And when you ask why, you get nothing — just a vague reference to “community guidelines” and a button that leads to a form that leads to silence.
We’ve all accepted this as normal. We shouldn’t.
The dirty secret of modern content moderation isn’t that AI gets it wrong sometimes. It’s that nobody — not the user, not the moderator, not even the engineer who built the system — can explain why a specific decision was made.
Every major platform has traded explainability for accuracy, and they’ve done it so quietly that we’ve forgotten there was ever another option.
There was. There is.
A deterministic, rule-based scoring engine doesn’t need to be a relic of the pre-AI past. When designed properly — combining weighted signals, contextual modifiers, pattern matching, token distance, and confidence scoring — it can produce results that are both accurate AND fully auditable. Every decision has a paper trail. Every flag has a reason you can point to.
Think about what that means in practice. A user gets flagged, they ask why, and you can actually tell them. Not “the model detected something” — but “this phrase matched a high-severity pattern, weighted at 0.8, modified by proximity to these three tokens, resulting in a confidence score above threshold.” Real reasoning. Real transparency.
The moment you can’t explain why content was removed is the moment you’ve stopped moderating and started censoring by lottery.
Now, I know what the ML crowd is thinking. Rule-based systems are brittle. They don’t generalize. They require constant maintenance. All true — if you’re building a naive keyword filter from 2008.
But a well-architected scoring engine isn’t a keyword filter. It’s a multi-signal fusion system. It weighs context. It considers relationships between tokens. It applies confidence thresholds that can be tuned per use case. And here’s the part that should make every CTO pay attention: when it’s wrong, you know exactly which signal failed and you can fix it in minutes, not weeks of retraining.
I’ve watched teams spend months retraining models because of a single false-positive pattern. A rule-based engine? You find the rule, adjust the weight, deploy. Done. The feedback loop is measured in minutes, not sprints.
Machine learning doesn’t fail because it’s inaccurate. It fails because when it IS inaccurate, you’re flying blind trying to fix it.
For sensitive contexts — healthcare, legal, child safety, political speech — the cost of an unexplained decision isn’t just a frustrated user. It’s a liability. It’s a lawsuit. It’s a congressional hearing where someone asks you why your platform censored a post about breast cancer awareness and your answer is “the neural network learned something we didn’t intend.”
That answer should keep you up at night.
The ts-profanity-filter project is building exactly this kind of engine — a generic, context-aware scoring system in TypeScript that combines weighted signals, modifiers, patterns, token distance, and confidence into explainable results. It’s open source. It’s looking for contributors. And it represents something the industry desperately needs: a counter-narrative to the assumption that opacity is the price of performance.
Here’s the uncomfortable truth nobody in big tech wants to say out loud: if your moderation system can’t tell a user why their content was removed, it’s not a moderation system — it’s an accountability firewall.
It protects the platform, not the person.
And we’ve been building these firewalls for so long that we’ve convinced ourselves there’s no other way. There is. It requires rejecting the assumption that black-box AI is the only path. It requires building systems where every decision is traceable, every weight is auditable, and every user gets an answer.
Accuracy without explainability isn’t intelligence. It’s just power without accountability. And we’ve seen where that leads.
FAQ
Q: Aren't rule-based systems less accurate than ML models for content moderation?
A: Not necessarily. A well-designed multi-signal scoring engine with contextual weighting and confidence thresholds can match or exceed naive ML approaches for many moderation tasks. The real advantage isn't raw accuracy — it's that when it's wrong, you know exactly which signal failed and can fix it in minutes instead of retraining for weeks.
Q: What does this mean for teams building moderation systems today?
A: For sensitive contexts where accountability matters — healthcare, legal, child safety, political speech — you should seriously consider a deterministic engine over opaque ML. You get audit trails, faster iteration, and the ability to actually answer users when they ask 'why was my content removed?'
Q: Is this just nostalgia for pre-AI moderation?
A: No. This isn't about going backwards — it's about rejecting the false binary between 'smart but opaque' and 'dumb but transparent.' A properly architected scoring engine with multi-signal fusion is neither. It's a third path that big tech has ignored because opacity is convenient for them.