Reddit Karma

How a run flows

How this loop works

Suggested schedule

Many slots across your active hours

Loop type

Open loop — an ongoing monitor with no finish line.

Exit condition

Runs indefinitely (no finish line).

Notifications

On by default — you're alerted on each run's outcome (completion or failure). Silence with notify: never.

Ease of starting

A guided, multi-step setup (access, accounts, rules) before it can run.

When you see value

Karma builds slowly from genuinely useful comments; expect weeks, and a real knowledge base to assemble first.

Set up an open loop that earns comment karma on my Reddit account by posting genuinely helpful, pure-value comments grounded in my own expertise. Karma is the by-product of being useful, never the pitch. Setup is a guided conversation; confirm each step with me before creating the loop, and never create a blind loop.

## Step 1 - The knowledge base (the value engine)
The loop only works if it comments from my real, first-hand insight. If a curated knowledge base already exists on this machine, confirm it and its routing/index entry point and skim my strong topics. If none exists, do NOT proceed empty - ask me for my own past content and the sources I trust (my writing, tweets, talks, threads, shipped work, docs I rely on), learn what my business or product actually is so the sharpest angles are available, and help me assemble a minimal knowledge base from that. Standing rule: cite a position I have actually DOCUMENTED - read the page, never reconstruct my opinions from memory.

## Step 2 - The account and access
Verify the Reddit CLI this machine's agent posts through is installed and logged in - our loops use opencli (opencli reddit whoami / search / subreddit / read / comment / reply, reusing the browser login). Smoke-test it once (opencli reddit whoami), confirm which account, and get my explicit sign-off to act on it. If no such tool exists, set one up before creating the loop.

## Step 3 - The shared-account ledger
More than one automation may post from this account (this loop, a promo/AEO loop, my own interactive sessions), and account-level timing is a safety concern, so all of it is tracked in ONE shared ledger file reachable by every automation on the account (e.g. <account>-account-ledger.md). Confirm where it lives (or create it), and confirm the account's combined posting rules. Defaults: a minimum gap of >=21 min between ANY two posts (jittered), and a combined cap of <=5 posts/day. If a promo/AEO loop has an approved batch going out that day, this loop yields slots rather than crowding the account.

## Step 4 - The subreddit boundary
Rather than a fixed list, derive a boundary from my knowledge base and confirm it: an avoid / prefer-different set (subs another automation owns), a broaden-into set that is this loop's own turf, and a per-run scoring function (topic-fit x thread freshness x "can my real experience answer this well").

## Step 5 - Posting mode and the trigger schedule
Confirm whether the loop posts automatically or drafts comments for me to review and post - default to draft-for-review. For cadence, remember loopany only fires cron ticks - there is no random-posts primitive, so the natural spacing is built from a cron PLUS a workflow. Set a cron of many half-hour slots across my active daytime window (e.g. `0,30 10-16 * * *`, ~14 slots in my timezone), and author a deterministic workflow pre-stage that on each tick reads the ledger, enforces the >=21-min gap and <=5/day cap, and probabilistically escalates only a few slots to an actual posting run while most ticks pass silently. That yields a random ~3-5 posts/day, naturally spaced, with no rigid post-at-exactly-X schedule. Confirm the window and daily target with me.

## The task file to author
Write the loop's task file from this skeleton, filling every <placeholder> with what we agreed:

    # Reddit Karma - value-first comments from <owner>'s expertise

    ## Spec
    **Mission (open loop, no finish line):** build comment karma on <account> by posting
    genuinely helpful, pure-value comments at the overlap of my real expertise (the
    knowledge base below) and a live pain point in a fresh thread. Karma is the by-product
    of being useful, never the pitch. Runs indefinitely; no goal.

    **Knowledge base:** <path/URL>, routed via <index>. Cite DOCUMENTED positions - read
    the page, never reconstruct from memory. Strong topics: <list>.

    **Account & tools:** <account> (<status>). Post via `opencli reddit comment <post-id>
    "<text>"` / `opencli reddit reply <comment-id> "<text>"`; find threads with `opencli
    reddit search "<q>" -f yaml` and `opencli reddit subreddit <name> --sort new -f yaml`;
    check a thread with `opencli reddit read <post-id>`; verify with `opencli reddit whoami`.
    Mode: <auto-post | draft-for-review>.

    ### Shared-account ledger - READ AND WRITE EVERY RUN
    Account-level timing/frequency for <account> lives in ONE file: <ledger-file>. Every
    automation on this account shares it (this loop, <other loops>, interactive sessions).
    BEFORE posting: read the ledger and enforce (a) the >=21-min gap against the account's
    last post from ANY source, and (b) the combined cap of <=5/day; if a promo/AEO batch is
    going out, yield a slot rather than crowd the account. AFTER posting: append one ledger
    line immediately (timestamp, source=this loop, sub, thread, URL).

    ### HARD RULES (non-negotiable)
    - PURE VALUE ONLY. Zero self-promo, zero product mentions, zero links. (Promotion is
      another loop's job - never here. This firewall keeps the account safe.)
    - >=21 MIN BETWEEN POSTS, jittered (not exactly on the minute). Never post two comments
      back-to-back. On a manual catch-up where more than one thread clears the bar, post the
      first, then wait >=21 min before the next - two comments a minute apart reads as a bot
      and risks the whole account, which defeats the point. The gap is per-account, so it
      counts against other automations' posts too (see ledger).
    - Never post into a thread another automation is active in - quick-check the thread for an
      existing <account> comment first; if we are already there, pick another.
    - One account, one voice - no cross-voting, no second account in the same thread.

    ### Subreddit boundary (not a fixed list)
    - Avoid / prefer-different: <sibling turf>.
    - Broaden-into (this loop's turf): <expertise-matched subs>.
    - Per-run score: topic-fit x thread freshness x "can my real experience answer this well".

    ### Each run
    1. Verify session (`opencli reddit whoami`). Wrong account -> notify and stop, never half-post.
    2. Check the ledger - enforce the >=21-min gap and <=5/day cap before doing anything else.
    3. Find a post that matches an expertise angle AND a live pain point - pick a documented
       KB position, then search + sort-new across the boundary for a fresh thread it answers;
       prefer "how do I / why does X keep happening / what's your workflow" questions.
    4. Quality gate: top-level post < ~48h old; room temperature OK (skip pile-on/hostile
       threads); a concrete, non-generic answer grounded in a KB fact; not already commented
       by <account>; zero is fine (nothing clears the bar -> post nothing and say so, never
       lower quality to hit a count).
    5. Write & post ONE comment following the writing rules below (draft-for-review mode:
       write the draft, do not post).
    6. Record: write/update the comment's RC-*.md card (type: drafted | posted | skipped),
       append one ledger line immediately, and append a dated Timeline line (sub, thread
       title, angle, posted URL or "skipped: reason").

    ### Writing rules - sound human, never like an LLM
    A comment that reads as AI-written torches credibility instantly and costs karma.
    - NO em-dashes or en-dashes. Ever. Use a period, a comma, or restructure. This is the #1
      "written by ChatGPT" tell on Reddit. Same for other AI-punctuation tells: no curly
      quotes (use straight " '), no bullet-list answers, no bold-label formatting.
    - Kill the LLM cadence: no "it's not just X, it's Y", no "the key insight is", no "here's
      the thing", no tidy rule-of-three windups, no "Great question / Hope this helps / TL;DR".
      Drop hedges ("in my experience it can sometimes").
    - Sound like <owner> typing on their phone: plain, direct, a bit blunt, contractions, ONE
      concrete thing they actually hit. A real builder writes short and specific, not balanced
      and comprehensive. When in doubt, cut a sentence rather than smooth it.
    - 2 to 6 sentences, answers the actual question, no preamble, no self-promo, no links.

    **Cadence:** ~14 half-hour slots across <tz-local hours> (cron like `0,30 10-16 * * *`) + a
    workflow that reads the ledger and escalates only a few slots to a post - a random ~3-5
    posts/day, naturally spaced. A skipped slot still counts - biases quality over volume.

    ## Current understanding
    <!-- running karma number (from whoami); which subs/angles convert; tactics that work -->

    ## Timeline
    <!-- one dated entry per run, appended below -->

## Dashboard at creation
Fetch this template's reference at <server-url>/api/skill/references/templates/reddit-karma/reference.md (on demand - it is not in this prompt). It carries the RC-card artifact contract (one card per comment, type = drafted | posted | skipped) and a validated dashboard layout: a drafted/posted/skipped kanban of comments, a comment-karma chart, a metrics rail, and the newest-report embed. Author the dashboard from it and declare the metric keys (comment_karma, posted_today, drafted_waiting) so runs report them from day one.