An AI Reddit comment generator built for indie founders, not for SaaS dashboards

The two things every paste-a-URL generator gets wrong

Imagine the typical hosted Reddit comment generator. You paste a thread URL into a web form. The backend fetches the post, calls a language model with a prompt that looks roughly like "here is a Reddit thread, write a 2 to 4 sentence reply that matches the subreddit tone", and renders the result. There is a free tier (one or two comments per session). There is a $15 to $30 monthly plan. Some of them post for you, most have you copy-paste the comment back into Reddit yourself.

The shape works for an agency. The agency runs hundreds of accounts across hundreds of clients. Voice flattening on any single account is not a problem because nobody is watching any single account closely. Hallucinated specifics are not a problem because the agency does not have a personal brand on the line. For an indie founder running one account that maps to one product and one face, both failure modes are existential.

Voice flattening first. A language model with no memory of your last few replies will default to its strongest rhythm: a soft hedged opener, a 2 to 3 sentence middle, a gentle question at the end. That rhythm is exactly what a moderator's pattern-match picks up. Within a week of running a URL-in tool on the same account, the comments start sounding like each other. A regular in your subreddit DMs you to ask if a bot took over. The moderator does not even need to read the comments; the cadence is enough.

Hallucinated specifics second. With only a URL as context, the model has no grounding for any first-person claim. So when the thread asks "has anyone tried this in production?", the model invents a production. It writes "I ran 22 cameras across three properties for 8 months". The founder pastes it. Two weeks later someone in the thread replies "wait, what three properties?" and the founder has nothing. On a 6-week-old account, that is the report-and-shadowban window opening.

Where the two fixes live in the code

The open-source repo fixes both problems with two small, specific mechanisms. Neither is impressive on its own; the point is that they exist at all. The diagram below traces what happens to a single pending reply between the cron firing and the comment landing on Reddit.

Two steps deserve a closer look. The call from engage_reddit.py to engagement_styles is where the last three archetypes get pulled and the prompt is told to vary away from them. The call to config.json is where the founder's own content_angle, voice, and messaging blocks get pasted verbatim into the prompt so the grounding rule has something concrete to anchor against. A URL-in tool has neither half of that loop.

Fix #1: seven archetypes that rotate against your last three replies

The first fix is the engagement archetypes. They live in the STYLES dict at the top of scripts/engagement_styles.py. Seven hardcoded entries:

• critic — point out what is missing, flawed, or naive. Reframe the problem. Authority through a non-obvious insight, not credentials.
• storyteller — narrative-driven, mandatory failure or surprise lede. Subject to the grounding rule (see below).
• pattern_recognizer — name the pattern. "I have seen this play out dozens of times across X."
• curious_probe — one follow-up question on the most interesting detail, prefixed with "curious because we ran into something similar". One question only. Disabled by platform policy on Reddit because question-only replies underperform.
• contrarian — take a clear opposing position backed by experience. Empty hot takes get destroyed.
• data_point_drop — share one specific, believable number. Let the number do the talking.
• snarky_oneliner — short, sharp, emotionally resonant observation. Validates a shared frustration. Locked off on small or serious subs.

On its own that is a list. The mechanism is what makes it work. Before engage_reddit.py builds the prompt, it queries the replies table for the founder's last three engagement_style tags on Reddit. Those three names go into the prompt with an explicit instruction: vary away from them. The model is also handed a top_performers block computed from the last 14 days of those tags joined against engagement signals, so it can self-tune toward what is converting this week without anyone editing the prompt by hand. A URL-in tool sees one Reddit thread and zero history, so its archetype distribution is whatever the base model defaults to. Within a week of running it on the same account, that distribution flattens.

The archetype list is not fixed: the model can invent new ones

One detail that surprised us when we shipped the rotation: the model started wanting to invent. About once a week, on a thread that did not fit any of the seven hardcoded archetypes, Opus 4.7 would return an engagement_style name we had never seen, with a companion JSON block called "new_style" explaining what it was and why the existing seven did not fit. We did not design this. We added a hook for it after the third time it happened.

validate_or_register() in engagement_styles.py picks those up. The new name lands in scripts/engagement_styles_extra.json with status "candidate". Candidate styles appear in subsequent prompts but the picker only allocates them STYLE_FLOOR_PCT (5 percent) of the distribution so a single weird invention cannot dominate. A nightly job in scripts/promote_engagement_styles.py graduates a candidate to "active" once enough samples land in the posts table with median engagement at or above platform baseline.

As of today the sidecar has three promoted entries running in active rotation:

• agree_and_extend — validate the original framing, then add a non-obvious extension. Sits between pattern_recognizer and storyteller. Promoted 2026-04-29 after 5 Reddit posts at median 1.0 upvotes vs platform baseline 1.0.
• share_experience — lived experience without storyteller's mandatory failure-lead. Promoted 2026-04-30. Still subject to the grounding rule: specifics must come from config, no fabricated headcount or durations.
• technical_detail — a concrete implementation detail or version-specific behavior. Promoted after 4 Reddit and 4 Twitter posts at median engagement at platform baseline.

A founder running a hosted URL-in tool has no equivalent surface for this. Their archetype taxonomy is whatever the vendor decided at v1, frozen until the vendor pushes a release.

Fix #2: the two-lane grounding rule

The second fix is the one that matters for staying on the right side of Reddit's moderation, and it is the part no hosted generator can replicate without seeing your config.json. The rule is defined in the get_grounding_rule() function in engagement_styles.py (around line 743) and gets pasted at the top of every reply prompt. It outranks every other style instruction. The prompt says so explicitly: "GROUNDING RULE (highest priority; overrides any other style guidance)".

The rule reads as elaborate but it collapses to one sentence: every first-person specific in a generated comment must either be disclosed as illustration or be a verbatim copy from the founder's own product config. Nothing in between. The prompt calls out the exact failure mode in capital letters: NEVER MIX. Do not write "i ran 22 cameras for 8 months" without either a Lane 1 disclosure in front of it, or those numbers being in config.json. That is the failure mode this rule exists to kill.

Two worked examples ship with the rule itself, drawn from real posts in our database. The bad one (fabricated personal anecdote, no disclosure, no config anchor): "i ran this exact pipeline last semester for two anatomy blocks, cheap recorder into whisper into gpt into anki, raw gpt got me about 35% usable cards...". The Lane 1 rewrite, same details, but disclosed: "hypothetically, imagine running this for a couple of lecture blocks: cheap recorder into whisper into gpt into anki. raw prompts get you somewhere around a third usable cards before duplicate distractors and trivial restatements take over." The Lane 2 rewrite, no invented specifics: "the whisper-to-gpt-to-anki setup isn't where this breaks. card generation is. raw prompts produce roughly a third usable before duplicate distractors and trivial restatements take over."

All three convey the same insight. Only the third can be safely posted from a founder's real account without setting up a future contradiction.

Side by side with the hosted generators

This is the section where comparison pages usually fudge the numbers. The honest version: hosted tools are easier to start with, they have nicer onboarding, and a founder who values their evening more than their account ban risk should probably use one of them. The table is the cost the indie founder pays for the convenience.

When a hosted generator is actually the right call

Three cases where the argument above flips. First, an indie founder who is testing whether Reddit is even the right channel for their product. Spending an afternoon wiring up a CLI before you know if any of the subreddits in your space respond to your angle is premature. A free tier on Junia or Planable is the cheaper experiment. Once the answer is "yes, this channel works", the trade-offs invert and the open-source shape starts paying off.

Second, a founder who genuinely cannot run a local CLI. The S4L install needs Node.js 16+, Python 3.9+, Claude Code CLI on PATH, psql, and a Neon Postgres database. That is a bar a developer founder clears in fifteen minutes and a non-technical founder cannot clear at all. The hosted tools exist for the second group.

Third, anyone doing this for clients at scale. The argument here is built on the assumption that one Reddit account maps to one founder and one product. An agency cycling through dozens of client accounts has different incentives. The open-source repo's qualification block names this directly as a disqualifier: "marketing agency looking to resell an autoposter to clients at scale". The shape was not designed for that shape.

What you actually do, concretely, this week

If you have read this far and the shape still fits you, the install is two commands. One to scaffold the repo into ~/social-autoposter/:

npx social-autoposter init

And then, inside a Claude Code session, "set up social autoposter". The skill walks through verifying the Neon connection, filling in config.json with your handles, running a 5-question interview to draft your content_angle (which is what Lane 2 of the grounding rule will later anchor against), and verifying the Reddit browser login in a persistent Chromium profile.

The first comment will land somewhere between three and ten minutes after the engage launchd job loads. A row in the replies table will record the archetype the model picked, the session UUID, the token usage, and the post URL. If the comment is bad, you read the row, find the prompt, fix it. The loop closes.