Reddit Community Analysis: r/commandline

1. Data Sources & Methodology

• 299 unique posts after deduplication across 4 time periods (all-time, year, month, week), 15 raw JSON files (top_week only went 3 pages deep due to subreddit volume)
• Date collected: April 10, 2026
• Subreddit subscribers: 120,355
• Score range: 0 to 1,227
• Median score: 155 (of the subset that made any "top" list)
• Mean score: ~220
• Top 10 threshold: 679
• Top 25 threshold: 461
• Top 50 threshold: 330
• Top 100 threshold: 186

Period overlap: A handful of evergreen posts appear in all 4 periods (ProteinView, lazyjira, late.sh, Gloomberb). ~45 posts are "all+year" evergreen canon. ~50 posts are "all-only" historical relics from 2016–2022. The current "week" bucket is brutally bimodal — either a few hundred upvotes or zero.

This is a content strategy guide, not a sociological study. The dataset skews toward top performers, but for r/commandline the "top" performers are quite modest compared to larger subs — a 1,200-upvote post is the all-time #1.

Cross-subreddit calibration: r/commandline is a low-ceiling, high-density niche. It peaks at ~1,227 — lower than r/selfhosted (~9,564), r/opensource (~2,259), r/ClaudeAI (~8,084), r/macapps (~2,029), and most comparable technical subs. With only 120K subscribers and a strict no-GUI / no-generative-AI-projects / quality-gated policy, the score ceiling is ~1,200 for all-time and ~800 for any recent post. If you need 3,000+ upvotes of visibility, you cannot get it here. What r/commandline offers instead is an extraordinarily high-quality reception for well-made terminal-native tools, with commenters who will actually try, compile, and contribute to your project. It is a relationship and credibility subreddit, not a visibility subreddit.

2. Subreddit Character

r/commandline is a 120K-strong workshop for keyboard-native tool-makers who believe the terminal is a craft, not a fallback. It is not a consumer forum. It is not a launch platform in the r/macapps sense. It is a community of people who build TUIs and CLI utilities, upvote other people's TUIs and CLI utilities, and argue fiercely about AI slop because the craft feels threatened by it.

Who's here: developers (heavily Rust, Go, C, Python, some Zig), dotfile enthusiasts, Linux ricers, self-hosters, and a meaningful population of university students building their first open-source project. Technical level is medium-to-high; commenters routinely ask about Kitty graphics protocol, ratatui vs. Bubble Tea, ncurses quirks, ANSI color parity.

Product launches: welcome but gated. Unlike r/macapps where the sub IS a launch platform, here launches are welcome if and only if (a) the tool is TUI/CLI native, (b) the post shows a screenshot or screen recording of it running, (c) the code is open on GitHub, (d) AI-assisted code is explicitly disclosed, and (e) the project is interesting enough to clear the "shared projects must be interesting" bar. Tools that are "just another TODO/timer/music player" with nothing unique get ignored or downvoted. "ascii_moon" scoring 705 is fine because it's charming and novel; "Tock: yet another time tracker" scored 219 because it was well-executed and visual but shows the ceiling for the "yet another X" format.

Humor works when it's terminal-culture humor: "cat" (a picture of an actual cat on the terminal, score 979), "Generate random bonsai trees" (1,227), tty pond (679), "Does this look cool?" (472), "I made a tool that plays FAHHH every time you mistype" (188). These are NOT reaction memes — they're visual jokes that require the terminal as canvas. Text-only jokes don't do well. Image macros don't do well. The humor must be made of characters.

Key cultural values, ranked:

1. Anti-AI-slop is now the dominant ideology. Rule 4 ("AI Code Policy") requires explicit disclosure. The top recent meta-posts are all about vibe-coding enforcement: "A call for support: The community needs to be much more proactive in reporting vibe coded projects" (51, ratio 0.83), "Has the slop problem been taken care of in this sub yet?" (32, ratio 0.63 — controversial because some want a total ban). Authors now preemptively add disclaimers like "this is not ai slop and I never use ai on reddit" (tennis/gurgeous, 467) or "I used Claude Code but I've been staring at it for 3 months" (siggy, 206).
2. Keyboard-first, zero mouse. Vim keybindings are a love language here. "a vim-style X for the terminal" is a recurring title formula with reliable performance.
3. Minimalism and lack of dependencies. Pure Bash is celebrated ("YouTube search and play in 20 lines of bash", 272). Rust single-static-binary is celebrated. Node/Electron is suspect.
4. Unix philosophy and composability. "In praise of the Unix toolkit" (37) and similar philosophical posts get organic upvotes. Piping-friendly tools get praised; monolithic TUIs that refuse to play with others get questioned.
5. Open-source only. No paid tools appear in the top 100. No freemium. No subscriptions. Even mentions of paid dependencies trigger rule 7 (affiliation disclosure) or get flagged.
6. Aesthetic craft. ASCII art, Nerd Font glyphs, gradient colors, cover art rendering, Kitty graphics protocol previews. The community rewards "looks good" almost as much as "works well".

Enforcement mechanisms (from Rule 1–7 in sidebar):

• Rule 2 — Relevance: No GUI-only tools. Submissions get removed for this.
• Rule 3 — No low quality / spam / indirect links: >3 posts per day is spam; no URL shorteners.
• Rule 4 — AI Code Policy: AI-generated post TITLES and TEXT are strictly prohibited; AI-generated projects must be disclosed with the literal string This software's code is partially AI-generated.
• Rule 5 — Shared projects must be interesting: "Another todo app" can get removed under mod discretion.
• Rule 6 — No generative AI projects: Projects that wrap LLMs are not allowed unless they're foundational tools like Ollama/GGML. This removes an enormous surface area that plays well elsewhere.
• Rule 7 — Affiliation disclosure.
• Meta: As of 2026 the mods installed the "Read The Rules App" requiring users to formally agree to rules before their first post.

How this differs from adjacent subs: r/selfhosted is hosting-centric and rewards dashboards + drama; r/opensource rewards manifestos; r/programming rewards articles; r/unixporn rewards rices. r/commandline rewards one thing: a working terminal-native tool with a short GIF that makes people say "oh that's cute, I'm gonna install that". Nothing else consistently scores.

3. The All-Time Leaderboard

Median of full dataset: ~155. Top-25 threshold: 461. Top-10 threshold: 679.

Ironic/notable: "Drop ur fav" (426, ratio 0.94) is a single image with text "what have you replaced cd with" — a community-seeking discussion masquerading as a shitpost, high engagement (249 comments). The flair "TUI program" is used almost identically to "Terminal User Interface" — mods evolved the flair scheme in 2024.

4. Content Type Dominance at Scale

Flair usage is patchy — ~55% of top-50 posts have NO flair (the flair system was underused before 2024). Here's the distribution across the full dataset:

The most surprising finding: Flair selection barely matters because the mod-enforced flair system is young. What matters is whether the post has a good GIF/video in the first 3 seconds. The flair "Terminal User Interface" has become the default new-era tag but its avg score (~230) is LOWER than the old unflaired era (~270) because it also captures the current flood of weekly zero-score launches.

5. Content Archetypes That Work

Ranked by score ceiling from your reading of ALL posts.

Archetype 1: "The Charming Useless Thing"

Score range: 400–1,227 Examples: cbonsai (1,227), cat-on-a-terminal (979), tty pond with frogs (679), ascii_moon (705), wipeClean ascii screen cleaner (533), cwalk colorful random-walk pipes (143), gostty Ghostty animation (198), Terminal screensaver 3D cube (294).

The pattern: A tool that does almost nothing useful but is aesthetically perfect in the terminal canvas — usually an animated GIF of ASCII art doing something cute. The tool must be CLI-installable (go/cargo/brew/pip). The title must be short, matter-of-fact, often lowercase. The comment thread is short and positive ("this is adorable"). It goes to the front page of r/commandline and stays in the all-time canon forever.

Why it matters for distribution: This is the only archetype that hits 4-digit scores. If you have any aesthetic/whimsical side project — even a 200-line weekend hack — package it as "a charming useless thing" first, then mention the practical applications. Do not lead with "productivity". Lead with the delight.

Archetype 2: "The Polished TUI Launch"

Score range: 300–848 Examples: Sampler (848), Reddix (826), gitlogue (808), regex-tui (593), dawn markdown editor (536), cmdpxl (503), Bookokrat PDF reader (487), rovr file manager (400), qo JSON/CSV SQL TUI (398), JiraTUI (389), lazyjira (351), termaid (389), tennis CSV tables (467).

The pattern: Full-featured TUI that replaces something you do in a GUI (Reddit, Jira, Spotify, file management, regex). Must show a screen recording. Must be on GitHub with an install-in-one-command (brew/cargo/go install). Title follows format: "ToolName — what it does" or "I built X — a TUI for Y". Comments ask for specific features (vim mode? theming? remote support?) and bugs. The ceiling is ~800; most land 200-500.

Why it matters: This is the bread-and-butter archetype. If you're shipping a new terminal tool, this is the format. Note the ceiling — do not expect 3,000+ upvotes from a TUI launch. Expect 300-700 if it's polished and novel.

Archetype 3: "The Lazygit-For-X Formula"

Score range: 150–400 Examples: lazyjira (351), LazySSH (365), lazytail (188), lazycut (134). Also: "X for your terminal" framing (Serie - rich git commit graph, Binsider for binaries, Netwatch for network, macpow for Apple Silicon power).

The pattern: Explicit reference to lazygit/lazydocker/k9s in the title. This signals "keyboard-driven, panels, vim-ish" and taps into existing lazy* tool goodwill. Works extremely well for infra/DevOps tooling. Comments often ask "how does this compare to [existing tool]?"

Why it matters: If your tool fits the lazygit mold (managing some system with panels and keybindings), explicitly name the inspiration. The community treats "lazy*" as a genre with established expectations and will measure you against it favorably.

Archetype 4: "The Unix Philosophy Showcase"

Score range: 100–488 Examples: "10 CLI tools that made the biggest impact" (286), "22 years on Linux, I finally switched to modern CLI tools" (454), Cool but obscure unix tools (345), "Using fzf for everything" (231), "What's the most useful trick you learned by accident?" (239 with 264 comments — the #1 comment generator), "In praise of the Unix toolkit" (37), "Two tiny terminal workflows that improved my dev flow" (31).

The pattern: First-person narrative about rediscovering/switching to command-line tools. Long-form TEXT post with specific tool names and reasoning. Generates massive comment threads (often 100-250+) because everyone wants to share their own setup.

Why it matters for distribution: These are stealth promotion vehicles. If you can list your tool as #6 in a "10 tools that changed my workflow" post (honest, genuine writeup of your actual daily drivers), you get vastly more goodwill than a direct launch. Caveat: the community sniffs out shilling. Your tool has to deserve its spot.

Archetype 5: "The Visual Cheatsheet / Infographic"

Score range: 150–900 Examples: Linux cheat sheet on PCB (904), Etymology infographic (664), Bash cheatsheet (488), Tar cheatsheet (443), Command line coasters (389), ncurses disk usage explainer (293), "Interactive cheatsheets for Neovim/tmux/git" (39).

The pattern: A beautifully designed reference card as an IMAGE or GALLERY post. Often printed on physical objects (PCBs, coasters, posters) for extra novelty. Titles are usually questions ("Do you like it?"). Not promoting a tool at all — pure educational content with zero self-interest. Universally upvoted.

Why it matters: If your product has a teaching angle (your CLI uses jq-like syntax, your tool has a useful cheatsheet), ship the cheatsheet as a standalone post FIRST, then let the tool come up in comments. This is a separate post archetype and shouldn't be blended into a launch post.

Archetype 6: "The Discussion Prompt"

Score range: 50–450 Examples: "After 22 years on Linux, I finally switched to modern CLI tools" (454, 248 comments), "What's the most useful trick you learned by accident" (239, 264 comments), "Drop ur fav" (426, 249 comments), "I just discovered lazygit. What terminal programs can you not live without?" (195, 82 comments), "Do you maintain some repository of commands you don't usually remember?" (21, 50 comments), "Hit me with it, folks - Why Nushell?" (16, 46 comments).

The pattern: First-person story or open-ended question in TEXT format. Low image, high engagement — these aren't visual showcases. Scores are moderate (200-450 peak) but comment counts are the highest in the subreddit, often eclipsing the top-10 posts.

Why it matters for distribution: If your goal is RELATIONSHIPS (building community awareness, getting beta testers, seeding future collaborators), discussion prompts beat every other archetype by comment volume. Price: low visibility ceiling and no screenshot-in-the-scroll recognition.

Archetype 7: "The NSFW/Taboo Terminal Tool" (cautionary)

Score range: 150–280, ratios 0.85–0.88 Examples: "Why use browser to view adult content when it can be done through terminal" (173, ratio 0.88), "I built a terminal-based PornHub browser inspired by ani-cli" (157, ratio 0.85).

The pattern: Takes the ani-cli formula (fzf + yt-dlp + mpv) and applies it to adult content. Gets upvoted as a lowkey clever hack but the ratios reveal significant split opinion. The reason to name this: a surprising number of the top-200 posts follow the ani-cli formula for ANYTHING (YouTube: ytsurf 306, ytfzf, reddit-tui 350), and the "adult" variants clearly work in terms of upvotes even if they generate controversy.

Why it matters: If your tool fits "fzf + yt-dlp + mpv + $SOURCE" formula, you can stand on the shoulders of ani-cli goodwill. Keep the title neutral and don't oversell. Expect controversy but net-positive reception.

No giveaways exist in r/commandline. Unlike r/macapps, there are zero giveaway posts in the dataset. The community's values (open-source by default, anti-commerce) make giveaways culturally nonsensical — code is already free. This archetype cannot be used here.

6. Format Analysis

The overwhelming fact: ~85% of top-25 posts are visual (IMAGE+GIF+VIDEO+GALLERY). TEXT posts break into the top tier only when they're either narrative nostalgia ("22 years on Linux") or discussion prompts. Pure link posts essentially don't exist in the top tier.

GIF vs static IMAGE: About half of the "IMAGE" posts in the top-25 are actually GIFs (the URLs end in .gif but Reddit tags them as image). GIFs dramatically outperform static screenshots for "show it in motion" tools. A static screenshot of a TUI is 3x less likely to hit the top-25 than a GIF or video of the same tool.

What Format to Use For What

• Tool/app launches → Animated GIF embedded as i.redd.it image is the gold standard. Uploaded to Reddit directly (not Giphy, not Imgur). Show the tool doing the thing that makes it interesting in under 10 seconds, looped. Alternative: v.redd.it video for longer demos (30-90 sec).
• Workflow/process posts → Gallery (multi-screenshot walkthrough) or video demo. Example: "Using fzf for everything" (231) uses gallery.
• Questions/discussions → Pure TEXT. Do not add images. Commenters won't engage with image-heavy discussion posts.
• Humor/memes → GIF only. A static meme doesn't fit here the way it does in r/ProgrammerHumor. The joke has to BE the terminal doing something.
• Cheatsheets/infographics → Single high-res IMAGE (for the infographic) or GALLERY (for multi-page cheatsheets). Physical objects with cheatsheets printed on them add 2-3x novelty multiplier.
• Architecture/philosophy → TEXT. Do not try to make it visual.

What Makes a Good Demo Video (for r/commandline specifically)

From studying the top 15 video posts (Sampler, gitlogue, Doit, Spotify CLI, tty pond, cmdpxl, Fig, LazySSH, Calcure, etc.):

1. Length: 8–30 seconds is optimal. Videos longer than 90 seconds drop off hard. The highest-scoring video posts show a single flow from open → action → result.
2. Screen recording only. Zero face-cams, zero voiceovers, zero music. The community finds YouTube-tutorial style cringe. Pure terminal capture — asciinema, VHS, or native screen recording — is the idiom.
3. Show the problem first, then the tool. Reddix opens with "browsing Reddit in a terminal" assumption stated; gitlogue opens with a commit log appearing and resolving into a diff.
4. Use a good font and color scheme. Catppuccin, Tokyo Night, or a custom theme with clear contrast. Monochrome demos score lower.
5. Let the GIF loop seamlessly. The 500+ score GIFs all loop back to their starting state so the demo re-watches naturally. The best ones (cbonsai, cmdpxl) are genuinely mesmerizing on replay.

Gallery count

Top-performing gallery posts typically use 3-6 images: Astroterm (769), Linux cheatsheet PCB (904), Tetrs (342), Terminal Game Engine (300). More than 8 images in a gallery hurts engagement. 2 images is too few. The sweet spot is exactly 4–5 side-by-side screenshots showing different UI states.

7. Flair/Category Strategy

Flairs on r/commandline are barely enforced and mostly a 2024+ development. Before that, the vast majority of top posts are unflaired. This makes flair-by-flair analysis noisy.

Raw performance ranking (average score, where sample size allows):

1. bash (~300 avg) — Rare but well-received. Use if your tool is a pure shell script.
2. TUI program / TUI Showcase (~280 avg) — Good but the preferred new-era tag is "Terminal User Interface".
3. (no flair) (~270 avg) — Slightly inflated by historical top posts; the mods increasingly push you to pick one.
4. Terminal User Interface (~230 avg) — The default modern flair, diluted by current weekly churn.
5. Other Software / Other Software Showcase (~170 avg) — Niche use; for non-TUI terminal toys (game engines, animation libs).
6. Command Line Interface / CLI Showcase (~130 avg) — Often used for non-visual utilities that can't leverage the visual format.
7. Discussion (~170 avg) — Use only for actual discussion prompts. Do not tag a launch with Discussion.
8. Terminals (~60 avg) — Low-performing; mostly used for terminal emulator related meta-posts.

Distribution utility ranking (for a product launch perspective):

1. Terminal User Interface — The only flair you should realistically use for a TUI launch in 2026. It's the recognized, mod-approved tag.
2. Command Line Interface — Use only if you have no visual UI at all (pipe-friendly, scriptable). Expect lower average score but comment value is similar.
3. bash — Strong signal of "pure shell" — use if true. Triggers nostalgia for POSIX purists.
4. Discussion — Only for legitimate discussion/question posts. Will get your launch removed if used deceptively.

Title-prefix tags common in r/commandline

Less common here than in r/macapps. Conventions seen in the dataset:

• [OC] — "Original Content". Used sometimes (Doit, Termtyper); signals "I made this". Minor positive effect.
• [TUI] — Redundant if you have the flair, but seen in titles like "[TUI] tmmpr - terminal mind mapper". No measurable uplift.
• [TRex v0.1.0], [Updated], v2.1 WIP — Version tags used for updates. Modest; "I posted this before, here's v1.0" updates scored 25-50% lower than initial launches on average (gurgeous tennis update 8 vs initial 467).
• (Rust), (Go), (C++) — Language parenthesized in title. Mildly positive — Rust especially acts as a quality signal.

Pricing model hierarchy (abbreviated for this sub)

There essentially isn't one — 100% of the top 100 posts are free and open-source. There is no paid/freemium representation at all. Posting a paid tool here would be cultural suicide. If you must mention pricing, the allowed ladder is:

1. Free + MIT/Apache/GPL open source on GitHub — ✅ Required floor.
2. Free + "source available" (non-commercial license) — ⚠️ Tolerated but questioned.
3. Free binary, closed source — ⚠️ Expect comments asking "where's the code?".
4. Paid tool — ❌ Don't post. Post it on r/macapps or r/selfhosted instead.
5. Freemium / SaaS / "Premium tier" — ❌ Don't post. Will be reported under Rule 3 (low-quality) and Rule 7 (affiliation).

8. Title Engineering

Deconstruction of the top 10 titles

1. "Generate random bonsai trees with cbonsai" (1,227) — Plain description, tool name first position. Technique: curious delight trigger ("random bonsai trees" is unexpected in a CLI context).
2. "cat" (979) — Literal single-word title. Technique: playful subversion (people expect the Unix cat command; they get an actual cat).
3. "I created a Linux Cheat sheet on a real PCB. Do you like it?" (904) — Physical object + seeking validation. Technique: novelty object + humility.
4. "Sampler - a highly configurable dashboard in your terminal" (848) — Name-dash-description. Technique: standard SaaS-adjacent naming convention.
5. "Reddix – the fully featured terminal Reddit client for power users" (826) — Name + "fully featured" + "for power users". Technique: audience naming (targets the tribe explicitly).
6. "A terminal tool that replays Git commits with animated diffs" (808) — Functional description, no product name. Technique: behavior-first (the surprising thing it does comes first).
7. "Astroterm: a planetarium for your terminal!" (769) — Name-colon-metaphor. Technique: one-word analogy (the entire concept fits in "planetarium").
8. "I made a fun little terminal app that shows the moon phase in ASCII art!" (705) — Humble first-person + "fun little" + specific function. Technique: aggressive humility.
9. "I made a tty pond that gets visited by curious frogs!" (679) — First-person + evocative imagery. Technique: storybook framing.
10. "[OC] Doit - A todo manager that you didn't ask for, but needed !" (676) — Self-deprecating humor tag. Technique: acknowledging the genre saturation.

Title formulas that work

Formula 1: "Name — what it does in 5 words"

• "Reddix – the fully featured terminal Reddit client" (826)
• "Sampler - a highly configurable dashboard" (848)
• "regex-tui - A simple TUI to visualize regular expressions" (593)
• "dawn - A distraction-free writing environment" (536)

Formula 2: "I made/built X that does Y" (first-person humble)

• "I made a fun little terminal app that shows the moon phase" (705)
• "I made a tty pond" (679)
• "I built LazySSH" (365)
• "I built qo – a TUI to query JSON/CSV with SQL" (398) Use "I made" when the tool is charming/small. Use "I built" when the tool is substantial.

Formula 3: "X for your terminal"

• "Astroterm: a planetarium for your terminal" (769)
• "Serie - A rich git commit graph in your terminal" (471)
• "fastfetch for Git repositories" (254)
• "Track your stocks without leaving your terminal with ticker" (377) This formula implicitly promises "the thing you already know, but now you don't have to leave". Very reliable mid-range performer.

Formula 4: "lazy-X / X-TUI" (direct genre tag)

• "lazyjira, terminal UI for Jira, like lazygit but for issue tracking" (351)
• "LazySSH: A terminal-based SSH manager" (365)
• "JiraTUI" (389)
• "WorkTUImer" (207)

Formula 5: "Functional description, no product name" (tool-first)

• "A terminal tool that replays Git commits with animated diffs" (808)
• "3D model renderer that runs entirely in the terminal" (393)
• "IDE-style autocomplete for your terminal" (496) Works when the behavior itself is the hook and the name would be gibberish.

Formula 6: "Self-aware genre saturation joke"

• "Doit - A todo manager that you didn't ask for, but needed!" (676)
• "Silly little program for silly people" (229)
• "I built a terminal music player with album browsing..." (192) Acknowledging that there are already 50 todo managers gets goodwill. Pretending yours is the first does not.

Title anti-patterns (community-specific)

• Do not mention AI in the title without disclosing. "I built [app] with Claude" in the title signals vibe-coding before the reader sees the tool. The disclosure goes in the body text — the title should focus on what the tool DOES. Rule 4 explicitly prohibits AI-generated titles.
• Do not mention star counts or growth metrics. Zero top-50 posts brag about stars/downloads. "lazyjira: thank you. 136 stars, first contributor" (160) scored 45% lower than the initial lazyjira launch (351) — the community prefers the craft to the metrics.
• Do not use "blazingly fast" unless it's ironic. The phrase has become a meme of Rust-language marketing; "zsh-patina - A blazingly fast Zsh syntax highlighter" (55) scored in the bottom half of Rust tool launches despite a legitimate technical story.
• Do not use "Revolutionary / Game-changer / Ultimate / Best". Zero top-100 posts use these. They trip the "vibe-coded LLM-generated post" sniff test.
• Do not use all-caps or heavy emoji. Example: "🚀 Ultimate TUI for X 🔥" will underperform. One or two emojis is tolerated; 3+ is a red flag.
• Avoid "simple" unless genuinely accurate. "A simple X" in current-era posts correlates with low scores; the community wants depth. Exception: "A simple 20-line bash script" works because brevity is the feature.
• Avoid star-seeking titles entirely. "Please star my repository; I need some stars" scored 0 with ratio 0.13 — the lowest in the entire dataset.

9. Engagement Patterns

Comment-to-upvote (C/U) ratios by archetype (from sampling the full dataset):

Conditional recommendation:

• Goal = VISIBILITY → Polished TUI launch archetype (charming useless thing if you have one). Expect 400-800 upvotes with <50 comments.
• Goal = RELATIONSHIPS / discussion / beta testers → Discussion archetype (first-person workflow story or open question). Expect 150-400 upvotes with 100-260+ comments — most of whom will be named developers sharing their own stack.
• Goal = CREDIBILITY as a toolmaker → Both: launch the TUI, then a month later post a workflow discussion that mentions your tool alongside others.

Highest-discussion topics in the dataset (by comment count)

1. "What's the most useful command-line trick you learned by accident?" (239 score, 264 comments) — #1 comment count.
2. "After 22 years on Linux, I finally switched to more modern CLI tools" (454 score, 248 comments).
3. "Drop ur fav" (426 score, 249 comments).
4. "I hate curl so much i made my own HTTP client" (271 score, 121 comments) — controversy-driven.
5. "Added full-featured PDF support to my terminal ebook reader" (487 score, 122 comments) — rare high-engagement launch because PDF-in-terminal is polarizing.
6. "Why use browser to view adult content when it can be done through terminal" (173 score, 125 comments) — taboo discussion.
7. "Okay, a secure p2p terminal calling" (461 score, 63 comments) — long selftext telling a 30-year build story.
8. "rovr - A post-modern terminal file manager" (400 score, 97 comments) — rich file manager drew contested comparisons.
9. "Terminal compatibility matrix" (308 score, 91 comments) — community argues about protocol support.
10. "I just discovered lazygit. What terminal programs can you not live without?" (195, 82 comments).

Pattern: High-comment posts are either genuinely open discussions OR polished launches that touch a polarizing area (PDF-in-terminal, NSFW, curl hate, new file manager genre).

10. What Gets Downvoted

The lowest-ratio posts in the dataset (below 0.85 threshold):

Ratio tiers

• Above 0.94: Universally well-received. Virtually all top-50 posts sit here (0.97-1.00).
• 0.85-0.94: Net positive but with friction. Often has one controversy element: AI assistance disclosure, Electron dependency, "yet another X" fatigue, or taboo topic.
• Below 0.85: Controversial or community-hostile. Usually: star-begging, undisclosed AI, generative-AI projects hitting Rule 6, or meta-complaints about the sub itself.

Anti-patterns (each with name + example + score/ratio)

1. The Star Beggar — "Please star my repository; I need some stars" (0, ratio 0.13). Explicitly asking for stars is the fastest way to zero. The community sees stars as an outcome, not a goal.

2. The LLM Prose Giveaway — Bangen v2 rewrite post (0, ratio 0.10). Features bullet-heavy, emoji-headered, "🚀 What's new" structure, "Here's a real example" framing — the exact shape of an LLM-generated README. Even if the tool is legit, the prose telegraphs vibe-coding and gets dragged.

3. The Rule-6 Violation — "Opperator, like Claude Code but for generalist AI agents" (139, ratio 0.86), "claude-sessions" (0, ratio 0.14). Projects that wrap LLMs are forbidden. The community downvotes first, mods remove second. Exception: tools that happen to have an AI side feature (lazytail's MCP integration) are fine if that's not the point.

4. The Yet-Another-X Without a Hook — "A TUI monitor manager for Hyprland" (65, ratio 0.93), many weekly timer/music-player/todo launches scoring 10-80. The tool must have one unique angle ("retro MS-DOS aesthetic", "vim-modal Spotify", "dissolves git branches in Thanos style"). Without a hook, even polished tools get ignored.

5. The Undisclosed AI Slop — "Void - A terminal native text editor written in Python" (160, ratio 0.86) received harsh comments until the author added an EDIT acknowledging AI use. Same post, with upfront disclosure, would have sat at 250+.

6. The Star-Count Follow-up — "lazyjira: thank you. 136 stars, first contributor" (160, ratio 0.95). Even when well-received, follow-up "look how many stars" posts underperform the initial launch by 40-60%. The community dislikes metric bragging as content.

7. The Taboo Without Justification — "I built a terminal-based PornHub browser" (157, ratio 0.85). Not hated, but clearly split. The post performs because of technical novelty (the ani-cli formula), not despite the taboo.

Blacklists / hall of shame / astroturf enforcement

r/commandline does NOT have a public blacklist (unlike r/macapps). Enforcement is:

1. Rule 4 disclosure enforcement by mods: undisclosed AI projects get posts removed.
2. Community-driven reporting: The "A call for support" post (51) explicitly rallies users to report vibe-coded tools. This is an emerging citizen enforcement layer.
3. Shadow bans via the Read The Rules App (installed 2026): New users who haven't formally agreed to rules have their posts auto-removed.
4. Mod discretion on Rule 5 ("shared projects must be interesting") — "yet another X" tools can be removed at mod call, though this is rarely exercised.

11. The Distribution Playbook

Phase 1: Pre-launch (2-6 weeks before posting)

1. Read 100+ top posts from the last year. Understand the TUI-craft aesthetic and the vocabulary (ratatui, Bubble Tea, OpenTUI, lazygit-genre, etc.).
2. Build something terminal-native first, a product second. The sub doesn't reward business fundamentals; it rewards craft. If your tool is a wrapper around a commercial service, it will struggle.
3. Ship to GitHub with a README that has a GIF at the top. The README GIF and the Reddit GIF can be the same file. No GIF = no launch.
4. Install via one command in at least 2 ways. cargo install, brew install, go install, pipx install, or npm install -g. More is better. Having only "git clone and build from source" is a red flag.
5. Add AI disclosure upfront if you used AI. Literal string: This software's code is partially AI-generated. Put it at the bottom of the README and the Reddit post. The community respects honest disclosure and punishes stealth.
6. Participate in the sub first. Upvote, leave genuine comments on other launches, answer questions in "what tool should I use" threads. Go from zero to 100+ karma over a few weeks. Cold accounts get auto-removed by Read The Rules App.
7. Have a clean screen-recording setup ready. VHS (charmbracelet/vhs) is the accepted toolchain. Use a theme like Catppuccin or Tokyo Night. Recording at 1200x800 @ 20fps keeps the GIF under 10MB.

Phase 2: Launch day

1. Title formula: Toolname — short functional description. Under 80 characters. If your tool is charming, add an exclamation. Example: "astroterm: a planetarium for your terminal!".
2. Format: Upload the GIF directly to Reddit as an i.redd.it image post. Do not use Imgur or Giphy. Do not use an external link. Do not use gfycat.
3. Flair: "Terminal User Interface" for TUIs, "Command Line Interface" for non-visual tools, "bash" for pure shell scripts, "Other Software" for libraries/engines.
4. Body text structure (5 sections, ~200 words total):
   • Problem (1 sentence): what you were annoyed by.
   • Solution (2-3 sentences): what the tool does differently.
   • Features (3-5 bullets, keyboard-first emphasized).
   • Install (code block with one-liner).
   • Repo link + AI disclosure if applicable + tech stack (Rust/Go/Python/C/Zig — language matters to this community).
5. Timing: The top posts appear to skew toward 1300-1800 UTC (morning US / afternoon EU). No hard data in the dataset on hour-of-day. Avoid US late-evening posts — the sub is more active when European and US-East audiences overlap.
6. Don't post more than once per project per month. Rule 3 says >3 posts/day is spam; practically, repeated posts about the same project within 30 days get called out.

Phase 3: First 24-48 hours

Engagement strategy:

• Reply to every comment in the first 6 hours, especially questions. Fast, technical responses compound goodwill.
• Upvote critical comments you agree with and thank the commenter. Do not delete negative feedback.
• If someone finds a bug, fix it and report back in the thread within 24 hours. "Fixed in v0.2.1, thanks for catching this" comments reliably score +5-15.
• If someone accuses you of vibe-coding, respond calmly with specifics: which parts were AI-assisted, which weren't, what you learned. Do not get defensive. Example successful defense: siggy (206), Bookokrat (487), Ekphos (181).

Community-specific comment strategy — pre-written templates for the 4-5 most common questions:

• "Is this vibe-coded / did you use AI?" → "[X% was AI-assisted for Y]. I wrote the architecture and core logic myself — you can see the commit history at [link]. The AI helped most with [boilerplate/tests/docs]." Always link the commit history.
• "How does this compare to [existing tool X]?" → Honest comparison table, name the existing tool's strengths, then your specific differentiator. Do not dismiss the existing tool. Lazyjira's response to "why not jira-cli?" won the author first contributors.
• "Does it support Kitty graphics / sixel / image protocol?" → "Currently supports X. Y is on the roadmap. [If you know the answer, link to a GitHub issue]." Never say "no" without a GitHub issue link.
• "Is this Nerd Font required?" → The correct answer is "it has a --no-nerdfont flag or a plain-ASCII fallback". Nerd Font-only tools get friction.
• "Why not [language X]?" → Brief honest answer. This community is language-friendly — Rust, Go, C, C++, Python, Zig, Bash all welcome. Don't get defensive about Python or Node choices; just name the tradeoff.

Phase 4: Ongoing presence

1. Update posts only when there's a meaningful release. Rule of thumb: every 3-6 months, for v0.x → v1.0 type jumps, a new demo GIF, or a significant feature. Don't re-post for bug fixes.
2. Update posts should lead with "what's new" not "remember my tool". Example pattern: "eilmeldung v1.0.0 released" (148) — leading with the version and a new feature list. Do not lead with "thanks for the love".
3. Be in the comments of other launches. Every time someone posts a lazyjira-adjacent tool, if your tool is in the space, comment something useful. Do NOT say "check out my tool" — let your history speak.
4. Maintain a public roadmap and changelog on GitHub. The community rewards visible, continuous development.
5. Write a single philosophical / workflow post per year. Pattern like "22 years on Linux, I finally switched to modern CLI tools" (454) or "10 CLI Tools That Made the Biggest Impact" (286) — list your tool alongside 8-9 others you genuinely use. Highest stealth distribution vehicle in the sub.

Stealth distribution tactics

• Answer "what terminal tool do you use for X?" questions in-thread with your tool plus 2-3 alternatives. Example threads: "I just discovered lazygit" (195), "Using fzf for everything" (231), "What's the most useful command-line trick" (264 comments).
• Contribute to an adjacent popular tool first (ratatui, Bubble Tea, VHS, lazygit) to build toolmaker credibility before launching your own.
• Post a workflow or cheatsheet tangential to your tool a week before the launch. The cheatsheet itself can score 200-400; the follow-up launch benefits from recognition.
• Cross-post carefully. Appropriate crossposts: r/rust, r/golang, r/neovim (if vim-integration), r/unixporn (if aesthetic), r/selfhosted (if server-side), r/programming. NOT r/macapps (wrong audience), NOT r/productivity (wrong frame).
• Answer philosophical questions — Unix philosophy, anti-AI posts — genuinely. This builds meta-credibility that cashes in when you launch.

Score-tier calibration

Tell yourself honestly what score your content type will realistically achieve:

• Charming useless visual thing with great GIF: realistic ceiling 500-1,200. Aim for top-25.
• Polished TUI tool with demo video: realistic ceiling 300-800. Target 400+.
• CLI tool without visual UI: realistic ceiling 150-350. 200 is a solid result.
• Library or framework (for TUI developers): realistic ceiling 50-200. Small but engaged audience.
• Discussion / workflow post: realistic ceiling 200-450 but 100-260 comments. Relationship play, not visibility play.
• Text-only launch without visual: realistic ceiling 30-150. Only works for bash one-liners or philosophical nostalgia.
• Tool launch without GitHub link: ~0. Don't do this.

If you need more than 1,200 upvotes of reach from a single post, r/commandline cannot deliver it. Crosspost to r/selfhosted, r/programming, or r/opensource where the ceiling is 2x-8x higher.

Post-publication measurement

4-hour check-in: If your post has <30 upvotes and <10 comments at the 4-hour mark, it is not going to recover. Options:

• Diagnose: Does it have a clear demo in the first 3 seconds? Is the title too long? Is the flair wrong? Was there an AI disclosure issue?
• Do NOT delete and repost. Let it sit. Treat it as free research.
• Respond to any comments that did come in — even the critical ones — as genuinely as possible. This builds a paper trail for future posts.

Ratio thresholds:

• Ratio 0.97+, any score: Well-received. You're good.
• Ratio 0.88-0.96: Net positive but contentious. Read the comments for what friction means.
• Ratio below 0.85: Something is wrong. Usually: rule violation (Rule 4 or Rule 6), star-begging, or framing problem. Learn and adjust before next launch.

48-hour final read: If the post clears 200 upvotes and 20+ comments with >0.95 ratio, you've successfully landed in the polished-TUI archetype tier. Bookmark it, link it in your GitHub README, and use it as a reference for your next launch.

12. Applying This to Any Project

Quick-reference checklist

Before you hit "Post":

1. ☐ Is there a GIF or video in the post (directly uploaded to Reddit, not linked externally)?
2. ☐ Does the title follow one of the 6 title formulas (Name—description, I made X, X for your terminal, etc.)?
3. ☐ Is there a GitHub link with README and install instructions in the body?
4. ☐ Is there an install one-liner in a code block?
5. ☐ If AI was used, is it disclosed with the literal Rule 4 string?
6. ☐ Is the flair set to Terminal User Interface / Command Line Interface / bash / Other Software?
7. ☐ Is the tool actually terminal-native (not a CLI wrapper around a web app)?
8. ☐ Does the tool have ONE unique angle (not just another todo/timer/music player)?
9. ☐ Are you available to respond to comments for the next 6 hours?
10. ☐ Have you participated in the sub recently (not a cold account)?
11. ☐ Is the body text under 300 words?
12. ☐ Have you pre-written replies to the 5 most likely questions?

Scenario-based launch guides

Scenario A: Your product is free/open-source (the default case)

• Optimal formula: Standard launch with Terminal User Interface flair, Name—description title, animated GIF, 200-word body, AI disclosure if applicable, install one-liner. Aim for Formula 1 or Formula 3 title.
• Expected score: 200-600 for a polished tool, 500-1000 if it has charm.
• Key risk: "Yet another X" fatigue. Mitigate by naming a specific twist in the title (vim-modal, git-native, retro aesthetic, etc.).

Scenario B: Your product uses one-time/lifetime pricing

• Launch formula: Don't launch on r/commandline. The community is anti-commercial by default. Post on r/macapps, r/selfhosted, r/productivity instead.
• Exception: If your tool has a free and fully-functional open-source version, you can post THAT here and mention the paid Pro tier only in response to direct questions. The main post must read as "free open-source tool".
• Key risk: Rule 7 (affiliation disclosure) if you even hint at a commercial angle without disclosure.

Scenario C: Your product uses subscription pricing

• Don't post. Period. No subscription products appear in the top 299 posts. The culture will actively punish you.
• Alternative: r/saas, r/startups, r/macapps, r/microsaas.

Scenario D: Your product was built with AI (fully or partially)

• Launch formula: Disclose upfront in the post body with the literal Rule 4 string This software's code is partially AI-generated. In the body text, explain the split: what was you vs. the AI. Point to commit history for verification. Lead the post with the tool and its demo — don't lead with the AI angle.
• Optimal title: Same as Scenario A. Do not put AI in the title.
• Expected score: 150-400 (about 30% lower than a non-AI post of the same craft quality).
• Key risk: If the disclosure feels perfunctory, comments will accuse you of slop. Have your defensive comment templates ready. Examples of successful AI-assisted launches: Bookokrat (487), siggy (206), termaid (389), Ekphos (181), lazytail (188).

Scenario E: Your product wraps a web/SaaS service

• Launch formula: Follow the ani-cli pattern — fzf + a CLI backend + mpv or similar playback. Title: "X: [service] on your terminal" or "X — terminal client for [service]". Examples: reddit-tui (350), ytsurf (306), Jira TUIs, gmail-tui.
• Expected score: 200-500.
• Key risk: Authentication UX questions. Have a clean OAuth or token flow ready. If you store any credentials, explain where and how in the body.

Cross-posting guidance

Reframing the same content for different subreddits:

• On r/commandline: "Name — terminal client for X. Keyboard-driven, vim keybindings, Rust/Go binary. GIF."
• On r/selfhosted: "I self-host X and got tired of the web UI, so I built a terminal client. Runs on my home server over SSH." Emphasize the self-hosting angle.
• On r/programming: "Building a TUI in [Language]: here's what I learned." Make it technical storytelling, not a launch.
• On r/rust / r/golang: Lead with the language choice and the concurrency/memory story. Include code snippets. Tool is a case study.
• On r/unixporn: Pure aesthetic showcase. GIF + theme + screenshot in ricing context. Minimal body text.
• On r/neovim: Only if there's an integration. "I built X that works with my neovim setup via Y."
• On r/opensource: License + philosophy angle. "MIT-licensed, alternative to [paid tool]."
• Do NOT cross-post to r/macapps (wrong audience, will confuse them).
• Do NOT cross-post to r/productivity (will read as spam — productivity commenters don't install from GitHub).

Each crosspost should be rewritten, not copy-pasted. Different subs have different norms, and the Reddit algorithm penalizes identical cross-posts.

Final note on r/commandline specifically: This is a community where the reward curve is compressed but the floor is high. You won't hit 5,000 upvotes, but a well-crafted launch with a great GIF will reliably land 300-600 upvotes, 20-50 genuine comments, a handful of GitHub issues from users who actually installed it, and sometimes — rarely but memorably — a first contributor who files a PR before your post even falls off the front page. That is worth more than any vanity metric this sub could offer.