An n8n node bakes one prompt. S4L picks from seven, tiered by live upvote data.
Every template in the n8n social-media category assumes one voice per workflow. S4L's voice is a function of platform, past performance, and sample size, and it lives in a single file anyone can open. Here is what the picker does, why it matters, and why you cannot express it in one n8n node.
What "n8n social media automation" actually ships
The n8n community has 538 social-media automation templates. Open any of them and the shape is the same: a trigger (cron, RSS, webhook), a research step (Google Trends, Perplexity, scraped URL), an AI node with a system prompt, and a publishing node (X, LinkedIn, Instagram, Reddit via buffer or Blotato). The system prompt is a string. It is the same string on every execution.
That is fine for a content factory where you want one voice. It breaks the moment you want the voice to change with context. Posting on LinkedIn? Different tone. Replying to a comment instead of posting fresh? Different tone. The last six data_point_drop posts tanked? You want less of those, not more.
S4L handles all three of those in one file. Every pipeline in the repo (post_reddit, engage_reddit, run-twitter-cycle, engage-linkedin, post_github) imports from the same module and gets the same answer. The module is scripts/engagement_styles.py.
The seven styles, as a taxonomy
These are not categories invented for a blog post. They are the seven voices the drafter is allowed to use. Anything outside this set fails a runtime assertion. The note field on each style is an anti-pattern hint passed straight into the Claude prompt to keep the voice from collapsing into cliches.
Each style orbits the picker, not the other way around
The picker is what every pipeline asks, "given this platform and this moment, which of the seven am I allowed to use?" The answer depends on PLATFORM_POLICY bans, the avg_upvotes ranking, and the sample-size gate.
Per-platform bans live in one dict
PLATFORM_POLICY is the only place brand policy interacts with the style picker. No style can be used on a platform where it appears in the never list, regardless of how high it ranks by upvotes. Snarky one-liners cannot win their way onto LinkedIn; curious_probe cannot win its way onto Reddit.
“Minimum sample size before we trust a style's avg_upvotes for tiering. Below this, the style is treated as 'explore' (secondary).”
scripts/engagement_styles.py, inline comment above MIN_SAMPLE_SIZE at line 129
How the tiers are recomputed
On every run, _fetch_style_stats pulls avg_upvotes grouped by style for that platform, filters to styles with n >= MIN_SAMPLE_SIZE, and ranks the survivors into thirds. Anything below the threshold is demoted to explore, where it will get picked occasionally to accumulate samples but will not be a default.
n8n workflow vs S4L pipeline, same task
The same behavior ("post on Reddit with a voice that adapts to past upvotes and respects per-platform bans") expressed two ways. Toggle between them. One is a workflow diagram. One is a function call.
Cron trigger -> HTTP node (pull trending topic) -> Set node (serialize prompt string) -> Anthropic/OpenAI node (system prompt = the one you wrote at design time) -> Reddit publish node.
- One prompt string per workflow
- Different tone per platform means duplicating the workflow
- No feedback from published posts to future prompt
- Style change requires editing the workflow, not config
- No concept of sample-size gating
One real run, narrated
The terminal excerpt below shows the picker deciding which style to hand the drafter on a Reddit run. Notice the contrarian style being demoted to the explore tier because it only has three samples on this account. That is MIN_SAMPLE_SIZE doing its job.
The sequence, actor by actor
Four parties touch the style decision on every post. The database is not optional; it is the input that makes "dynamic tiers" a real function rather than marketing copy.
One Reddit post, from picker to publish
Side by side in a table
What the n8n template gives you, what the tiered picker gives you, feature by feature. Nothing here is theoretical; each row maps to a line of code in engagement_styles.py.
| Feature | Typical n8n template | S4L |
|---|---|---|
| Prompt rotation | One prompt string baked into the workflow node | Seven named styles, tiered per platform at runtime |
| Per-platform style policy | Same prompt sent to every platform you wire up | PLATFORM_POLICY.never bans styles per target (LinkedIn blocks snarky_oneliner, Reddit blocks curious_probe) |
| Performance feedback loop | No coupling between published posts and future prompts | _fetch_style_stats reads avg_upvotes from posts table, re-ranks tiers on every run |
| Small-sample protection | Any observed metric is treated as signal | MIN_SAMPLE_SIZE = 5 forces low-data styles into the explore tier, regardless of average |
| Style taxonomy as a contract | Tone lives inside the prompt string, not a typed set | VALID_STYLES and REPLY_STYLES are Python sets; picking anything outside them is a runtime error |
| Reply vs post style separation | One prompt handles both, or requires a second workflow | REPLY_STYLES = VALID_STYLES | {"recommendation"} keeps recommendation off posting entirely |
The steps a single draft actually goes through
If you follow one comment from trigger to publish, this is the path it walks. Notice that the database round-trip is not bolted on; it happens before the prompt is even assembled.
Pipeline imports engagement_styles
post_reddit.py, engage_reddit.py, post_github.py, run-twitter-cycle, and engage-linkedin all `from engagement_styles import ...`. Single source of truth for every pipeline.
get_dynamic_tiers(platform)
Reads PLATFORM_POLICY.never for hard bans; queries posts table for avg_upvotes grouped by engagement_style; partitions surviving styles into thirds.
MIN_SAMPLE_SIZE gate
Any style with n < 5 is routed to the explore tier regardless of its average. This is the line that separates 'signal' from 'two lucky posts'.
get_styles_prompt(tiers, platform)
Renders a plain-text prompt section that tells Claude which tier each style is in and what the tone hints (description + example + note) are. Claude picks one style from the offered set.
Claude spawn drafts comment
The spawn happens per post (not batched) so the context stays small and reproducible. The draft includes the thread text, the style block, and the content_rules.
Publish + INSERT into posts
After the browser posts the comment, db.py writes a posts row with thread_url, engagement_style, and upvotes=null. The next scrape fills upvotes; the next run's tier ranking sees it.
What the picker refuses to do
The absence matters as much as the presence. These are the shortcuts you will not find in the module, and the reason each one was rejected.
Deliberately absent
- No single 'pleaser' style. It ranked last on every account by avg_upvotes and was removed from the taxonomy entirely rather than kept in with a note.
- No manual override in config.json. Tier ranking is purely a function of posts-table data; operators cannot pin a style as dominant because they like it.
- No cross-platform averaging. avg_upvotes is computed per platform per style so Reddit's voice does not pollute LinkedIn's ranking.
- No time-decay on upvotes. A post from last year counts the same as one from last week; this is intentional, because decay would make the tier ranking too noisy for accounts that post monthly.
- No global style prompt. Every pipeline's prompt comes from get_styles_prompt(tiers, platform), which takes the just-computed tiers as an argument rather than reading a constant.
Where the picker actually lives in the repo
If you clone the repo, everything above is in one file. These are the symbols worth opening first.
scripts/engagement_styles.py
STYLES dict
0
posting styles, defined at line 15
REPLY_STYLES set
0
reply styles (VALID_STYLES + recommendation), line 92
MIN_SAMPLE_SIZE
0
sample threshold at line 129
Platforms in PLATFORM_POLICY
0
reddit, twitter, linkedin, github, moltbook
357 lines total. Imported by six pipelines. Changes to the taxonomy take effect on the next run without redeploying any workflow.
When an n8n template is still the right answer
Hard-coded prompts are genuinely good at a specific job: take a trending topic, write one post in one voice, publish to one place. If that is your content, n8n's social-media automation category is the fastest way to get there. You click through a template, paste a prompt, and you are shipping in an afternoon.
The failure mode is growth. Add a second platform with a different tone, add a feedback loop from engagement back to future drafts, add a sample-size gate, and the workflow diagram becomes a maintenance problem. That is where S4L's single-file picker starts to pull ahead; and it is also where most reviews of n8n social media automation stop short.
Want the tiered picker pointed at your accounts?
Fifteen-minute walkthrough of engagement_styles.py, live on your platform data, with the tier stats shown against a real posts table.
Book a call →Frequently asked questions
What exactly is wrong with n8n's social media automation templates?
Nothing is wrong with them for a single-shot 'write one post on a trend' use case. The limit appears once you want the tool's voice to adapt. n8n's AI nodes accept one prompt string. Changing voice per platform means duplicating the node, changing voice based on past performance means wiring a database lookup and re-serialising the prompt every run, and changing voice per subreddit means a switch node upstream of every AI call. It is doable, but it is a workflow rebuild. S4L puts the same logic into one Python module (scripts/engagement_styles.py) that every pipeline imports.
What are the seven engagement styles?
critic (reframes the problem), storyteller (first-person narrative with numbers), pattern_recognizer (names the phenomenon), curious_probe (one specific follow-up), contrarian (opposing position backed by evidence), data_point_drop (one believable metric), and snarky_oneliner (sharp one-sentence observation). All seven live in the STYLES dict at engagement_styles.py line 15. Reply pipelines add an eighth style called recommendation, via REPLY_STYLES = VALID_STYLES | {"recommendation"}. The styles are taken from what actually got upvotes on the accounts S4L runs, not from a generic writing framework.
How does the MIN_SAMPLE_SIZE gate work?
engagement_styles.py sets MIN_SAMPLE_SIZE = 5 at line 129. When the tier selector pulls avg_upvotes per style from the posts table, any style with fewer than five posts for that platform is routed to the explore tier instead of being ranked with the trusted ones. The reason is noise: a single 200-upvote post from a style that only has two samples would otherwise promote that style to dominant and skew the next month of drafting. Gating at five samples keeps the ranking honest until the account has actually sampled the style under several different threads.
Why are certain styles banned per platform?
PLATFORM_POLICY.never lists the styles that are refused on a given platform regardless of how well they rank. On LinkedIn, snarky_oneliner is banned because snark reads as unprofessional in a B2B feed and produces downside risk no upside rank could justify. On Reddit, curious_probe is banned because lone questions posted on a thread read as low-effort and disengaged in Reddit's culture. github and moltbook also ban snarky_oneliner for the same tone reason as LinkedIn. The bans are static (they encode brand policy) while tier rankings are dynamic (they encode performance).
Can I replicate this in n8n if I really want to?
Yes, but you will end up rebuilding what engagement_styles.py already does. You need a Postgres node that returns per-style avg_upvotes grouped by platform, a Function node that filters by n >= 5 and buckets into dominant / secondary / rare / explore, a Switch node that applies platform-specific bans, and an AI node whose system prompt is assembled from the selected style's description, example, and note. That is four nodes doing what one Python function does, and every platform you add is another branch on the Switch. The fragility shows up when you want to edit the taxonomy, because the 'source of truth' is now split between the Postgres table, the Function node code, and the Switch conditions.
Does S4L use n8n under the hood?
No. S4L's orchestration is plain Python (scripts/post_reddit.py, scripts/engage_reddit.py, scripts/post_github.py, and so on). Each pipeline spawns one Claude session per post or reply via the claude CLI rather than hitting the API from a workflow engine. The reason is context: a fresh Claude session per draft keeps the prompt small and avoids the shared-context contamination you get when one long-running n8n workflow serialises eighteen drafts in a row. The tradeoff is you do not get a GUI; you get a repo.
Why separate VALID_STYLES and REPLY_STYLES?
Posting pipelines (post_reddit, post_github, run-twitter-cycle) should never choose the recommendation style, because recommendation is inherently reactive: it only makes sense when responding to someone else's question or complaint. Keeping VALID_STYLES as the posting set and REPLY_STYLES = VALID_STYLES | {"recommendation"} as the reply set makes that distinction unrepresentable as a bug. If an engineer tries to use recommendation inside post_reddit.py, the style validator in that pipeline rejects the choice before a prompt is ever assembled.