ModTrials

• 

Inspiration

Moderation teams are under constant pressure to move fast: reduce spam, protect community quality, keep the queue manageable, and avoid burning out volunteers. But every stricter rule has a hidden cost. A rule that catches obvious spam can also catch good-faith posts from new users, researchers, builders, or community members who simply used the wrong wording.

Most moderation tools focus on action: remove, warn, ban, approve, route to queue, or ask the team to vote.

ModTrials focuses on the missing step before action:

Can this rule be trusted before it affects users?

That is the core idea. Moderation automation should not go straight from an idea to punishment. It should have a staging environment.

ModTrials gives subreddit moderators a way to test proposed rules on real community activity before those rules create queue load, false positives, or user-facing mistakes. Instead of asking moderators to guess whether a new rule is safe, ModTrials helps them collect evidence first.

What it does

ModTrials lets subreddit moderators run private shadow trials for moderation rules on real Reddit posts and comments.

A moderator can start from where they already work:

Post/comment menu -> ModTrials: trial privately

or with a bot-style command:

u/modtrials trial this --dm

ModTrials then privately delivers a counterfactual moderation result:

If this rule were live, this post would have been held for review. No user-facing action was taken.

The app records why the item matched, stores privacy-minimized evidence, and lets moderators label examples as good catches, false positives, gray-area cases, or rules that need rewriting.

The daily workflow is intentionally inline and native to Reddit. The dashboard is not the starting point. It is the evidence room: a place where moderators review accumulated trials, compare rules, and decide whether a rule is ready to launch.

The dashboard turns real trial evidence into practical launch signals:

• readiness score
• false-positive risk
• gray-area risk
• confidence level
• queue-load signal
• rule flight recorder
• rule comparison
• recommended launch mode: warning, repair-first, hold-for-review, do not auto-remove, or rewrite

ModTrials also includes privacy receipts. Private results explain what was stored and what was intentionally not stored.

For delivery, ModTrials tries to send the private result by DM first. If Reddit blocks the DM because of account delivery settings, ModTrials falls back to the subreddit's Modmail Inbox so the result still reaches the mod team through a normal moderator workflow.

ModTrials does not auto-ban, auto-remove, use AI, train models, or publicly accuse users.

How we built it

We built ModTrials as a Reddit Devvit app with a React dashboard, Hono server, Devvit Redis, Devvit Reddit API, menu actions, triggers, scheduler tasks, private messages, Modmail fallback, and custom posts.

The primary UX is native to Reddit. Moderators can run trials from post/comment menus or bot-style commands without leaving the subreddit. The dashboard is intentionally secondary: it is an audit and readiness surface, not a heavy control panel moderators must open for every action.

The rule engine is deterministic. It evaluates conditions such as:

• keyword sets
• exemption terms
• regex-style text patterns
• external links
• risky domains
• link-heavy posts with little original context
• short text
• flair checks
• account-age style checks

Trial events are stored in Devvit Redis with privacy minimization: no usernames, no full post/comment body, no raw title, and no raw URL. Redis keys are scoped by subreddit so one community cannot read or mutate another community's ModTrials rules or evidence.

We also added server-side moderator permission checks for all menu actions and dashboard API endpoints. If a non-moderator opens a dashboard post, they see a locked state and no moderation data is returned.

Challenges we ran into

The hardest product challenge was resisting the temptation to build another enforcement bot. A tool that automatically removes content may look powerful, but it can also create false positives, user frustration, and more work for moderators.

So we designed ModTrials to be non-destructive by default. It creates evidence, not punishments.

We also had to make the UX feel native. Early feedback made it clear that moderators do not want another dashboard they must remember to open. That pushed us toward an inline-first product: menu actions and private bot-style workflows for daily use, with the dashboard reserved for audit, comparison, and launch readiness.

Community feedback also shaped the rule engine. A simple keyword/domain matcher would not be enough to justify installation. We expanded ModTrials into richer deterministic rule recipes with regex-style patterns, exemption terms, link-heavy/context-light checks, risky domains, short-text checks, and baseline trial templates while still avoiding AI-based judgment.

On the Devvit side, we had to handle real runtime behavior. Reddit can rewrite user mentions into markdown links, comment submit/create triggers can both fire for the same command, and delete triggers provide different payload shapes from normal comment events. We added command de-duplication, markdown mention normalization, and deletion cleanup to make the workflow reliable.

Privacy was another major challenge. Moderators need useful evidence, but the app should not become a user-profiling database. ModTrials minimizes trial events before writing to Redis and includes a privacy receipt in private results.

We also learned that DM delivery is not guaranteed for every Reddit account. The app now falls back to Modmail Inbox when Reddit blocks a DM, with a clear toast explaining where the private result went.

Accomplishments that we're proud of

We built a real end-to-end Devvit moderation app, not a mock demo.

ModTrials can be installed on a subreddit, read real posts/comments, start private trials from native Reddit actions, process bot commands, deliver private results through DM or Modmail Inbox fallback, remove command comments after processing, store minimized evidence in Redis, clean up evidence when Reddit items are deleted, label outcomes, compare rule safety, and compute launch readiness.

We are especially proud that ModTrials occupies a clear product lane:

Other mod tools help teams act on content. ModTrials helps teams prove a rule is safe before it acts on users.

That makes it useful alongside Automod-style tools, queue tools, AI moderation tools, and collaborative review tools instead of competing with them directly.

For a moderator, the value is simple:

Before adding a stricter rule, click a real post and ask, "Would this rule have hurt this user?"

What we learned

We learned that moderator trust depends on restraint. The best tool is not always the one that takes the fastest action. Sometimes the highest-value tool is the one that prevents the wrong action.

We also learned that privacy and UX are connected. A moderation tool feels more trustworthy when it works inline, sends private results, avoids public accusations, and stores only the minimum evidence needed.

Product feedback from moderators was especially valuable. It helped us sharpen the app from "dashboard for rule trials" into "inline private rule testing, with a dashboard for evidence."

On the technical side, we learned how to work with Devvit menu actions, triggers, Redis storage, custom posts, private messages, Modmail, moderator permission checks, subreddit-scoped storage, and public review requirements.

What's next for ModTrials

Next, we want to make ModTrials a fuller rule safety lifecycle:

• stronger rule flight recorder reports
• side-by-side rule version comparison
• team-level review workflows
• repair-first launch recommendations
• weekly private rule health summaries
• safer handoff from trial mode to Automod-style enforcement
• import/export helpers for rule recipes
• clearer mod onboarding for communities that already use Automod heavily

Longer term, ModTrials can become the staging layer for subreddit governance changes: a place where moderation teams test policy before it becomes punishment.

Built With

• hono
• node.js
• react
• redis
• typescript
• vite
• vitest
• zod