@opendirectory.dev/skills 0.1.0

package/skills/reddit-icp-monitor/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: reddit-icp-monitor
+description: Watches subreddits for people describing the exact problem you solve, scores their relevance to your ICP, and drafts a helpful non-spammy reply for each high-signal post. Use when asked to monitor Reddit for ICP signals, find prospects on Reddit, surface pain point posts, draft helpful Reddit replies, or scan subreddits for buying signals. Trigger when a user says "monitor Reddit for my ICP", "find people on Reddit who need my product", "scan subreddits for pain points", "draft Reddit replies for prospects", or "check Reddit for buying signals".
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# Reddit ICP Monitor
+
+Watch subreddits for people describing the problem you solve. Score their relevance. Draft a helpful reply for each match.
+
+---
+
+**Critical rule:** Never invent post URLs, titles, or content. Every post in the output must come from a Reddit search result. Mark any section with no results as "No matches found." Never draft a reply to a post that was not returned by the search.
+
+**Anti-spam rule:** Drafted replies must never mention your product or company name unless the post explicitly asks for tool recommendations. Sound like a practitioner, not a marketer.
+
+---
+
+## Step 1: Setup Check
+
+```bash
+echo "GEMINI_API_KEY: ${GEMINI_API_KEY:+set}"
+echo "REDDIT_CLIENT_ID: ${REDDIT_CLIENT_ID:-not set, using public endpoints (10 RPM)}"
+```
+
+**If GEMINI_API_KEY is missing:**
+Stop. Tell the user: "GEMINI_API_KEY is required. Get it at aistudio.google.com. Add it to your .env file."
+
+**If Reddit credentials are missing:**
+Continue. Use Reddit's public JSON endpoints (no auth required, 10 RPM limit). For most monitoring sessions of 3-6 subreddit searches, this is sufficient.
+
+**If REDDIT_CLIENT_ID is set:**
+Use OAuth for 60 RPM. Fetch a token first:
+```bash
+TOKEN=$(curl -s -X POST \
+  -d "grant_type=password&username=$REDDIT_USERNAME&password=$REDDIT_PASSWORD" \
+  --user "$REDDIT_CLIENT_ID:$REDDIT_CLIENT_SECRET" \
+  -H "User-Agent: varnan-skills/1.0" \
+  https://www.reddit.com/api/v1/access_token \
+  | python3 -c "import sys,json; print(json.load(sys.stdin)['access_token'])")
+```
+Use `Authorization: Bearer $TOKEN` and `https://oauth.reddit.com` base URL for all subsequent requests.
+
+---
+
+## Step 2: Load ICP
+
+Check for an existing ICP file:
+```bash
+ls docs/icp.md 2>/dev/null && echo "icp found" || echo "icp missing"
+```
+
+**If docs/icp.md exists:** Read it. Extract:
+- `product`: one-sentence product description
+- `pain_points`: list of pain point phrases (exact buyer language)
+- `anti_keywords`: phrases that disqualify a post
+- `subreddits`: list of subreddits to search
+
+**If docs/icp.md does not exist:** Ask these 3 questions. Do not proceed until all 3 are answered:
+1. What does your product do? (one sentence)
+2. What subreddits does your ICP post in? (comma-separated, e.g. devops, startups, SaaS)
+3. What pain point phrases should trigger a match? (3-5 phrases in your buyer's own words, e.g. "onboarding takes forever", "can't see why users churn")
+
+After answers are collected, save to docs/icp.md in the canonical format from `references/icp-format.md`. Confirm: "ICP saved to docs/icp.md. It will be used automatically in future runs."
+
+Read `references/icp-format.md` for the canonical format and examples of good vs bad pain point phrases.
+
+---
+
+## Step 3: Search Reddit
+
+For each combination of subreddit and pain point phrase, run one search. Use public endpoints unless OAuth credentials are set.
+
+**Without OAuth (public endpoint):**
+```bash
+curl -s \
+  -H "User-Agent: varnan-skills/1.0" \
+  "https://www.reddit.com/r/{SUBREDDIT}/search.json?q={PHRASE}&sort=new&t=week&limit=25&restrict_sr=true" \
+  | python3 -c "
+import sys, json
+d = json.load(sys.stdin)
+posts = d.get('data', {}).get('children', [])
+for p in posts:
+    data = p['data']
+    print(json.dumps({
+        'id': data['id'],
+        'title': data['title'],
+        'body': data.get('selftext', '')[:600],
+        'url': 'https://reddit.com' + data['permalink'],
+        'score': data['score'],
+        'comments': data['num_comments'],
+        'subreddit': data['subreddit'],
+        'created_utc': data['created_utc']
+    }))
+"
+```
+
+**With OAuth:**
+Replace `https://www.reddit.com` with `https://oauth.reddit.com` and add `-H "Authorization: Bearer $TOKEN"`.
+
+**URL-encode the phrase** before inserting into the query string:
+```bash
+ENCODED=$(python3 -c "import urllib.parse, sys; print(urllib.parse.quote(sys.argv[1]))" "{PHRASE}")
+```
+
+**Time window defaults:**
+- Default: `t=week` (last 7 days)
+- User says "today" or "last 24 hours": `t=day`
+- User says "this month": `t=month`
+
+**After all searches:**
+- Collect all posts into one list
+- Deduplicate by post ID. If the same post matches multiple phrases, keep it once and note all matching phrases.
+- If a search returns 0 posts: note it and continue. Do not stop.
+
+State the total candidate count before scoring: "Found X candidate posts across Y subreddits."
+
+---
+
+## Step 4: Score Relevance with Gemini
+
+Write all candidate posts and the ICP context to a temp file, then score:
+
+```bash
+cat > /tmp/reddit-score-request.json << 'ENDJSON'
+{
+  "system_instruction": {
+    "parts": [{
+      "text": "You are a GTM analyst identifying Reddit posts where someone is experiencing the exact pain point that a specific product solves. For each post provided, output a JSON object with these fields: id (the post id), score (integer 1-5), reason (one sentence explaining the score). Scoring rubric: 5 = person clearly has the problem AND is actively seeking help or venting frustration about it; 4 = strong signal, problem is present but less explicit; 3 = possible match, uncertain; 2 = tangentially related but not the core pain; 1 = unrelated. Output only a JSON array of score objects. No commentary before or after the array."
+    }]
+  },
+  "contents": [{
+    "parts": [{
+      "text": "POSTS_AND_ICP_CONTEXT_HERE"
+    }]
+  }],
+  "generationConfig": {
+    "temperature": 0.2,
+    "maxOutputTokens": 2048
+  }
+}
+ENDJSON
+curl -s -X POST \
+  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @/tmp/reddit-score-request.json \
+  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['candidates'][0]['content']['parts'][0]['text'])"
+```
+
+Replace `POSTS_AND_ICP_CONTEXT_HERE` with:
+- The product description and pain point phrases from Step 2
+- Each candidate post: id, title, body snippet
+- Anti-keywords from the ICP (Gemini should score these lower)
+
+Keep only posts with score >= 4 for response drafting.
+
+State: "X posts scored 4 or 5. Drafting replies."
+
+If 0 posts score >= 4: output the zero-results message from Step 7 and stop. Do not draft empty replies.
+
+---
+
+## Step 5: Draft Replies with Gemini
+
+Read `references/reply-rules.md` before drafting. Determine the post type for each high-scoring post (Mode 1, 2, or 3) and pass the mode to Gemini.
+
+For each post scoring >= 4, draft a reply (maximum 5 replies per session):
+
+```bash
+cat > /tmp/reddit-reply-request.json << 'ENDJSON'
+{
+  "system_instruction": {
+    "parts": [{
+      "text": "You are a practitioner who has personally solved the exact problem being described in this Reddit post. Write a helpful reply that: (1) directly addresses what the person asked or is frustrated about, (2) shares a specific, useful insight from real experience, (3) does NOT mention any product, tool, or company by name unless the post explicitly asks for tool recommendations, (4) is 2-5 sentences, written in plain conversational prose with no headers or bullet lists, (5) optionally ends with a low-pressure invitation to continue the conversation. Do not use marketing language. Do not use these words: game-changer, best-in-class, streamline, transform, revolutionize, leverage, seamless, robust, comprehensive, innovative. Sound like a real person."
+    }]
+  },
+  "contents": [{
+    "parts": [{
+      "text": "POST_CONTENT_AND_MODE_HERE"
+    }]
+  }],
+  "generationConfig": {
+    "temperature": 0.7,
+    "maxOutputTokens": 512
+  }
+}
+ENDJSON
+curl -s -X POST \
+  "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key=$GEMINI_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d @/tmp/reddit-reply-request.json \
+  | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['candidates'][0]['content']['parts'][0]['text'])"
+```
+
+Replace `POST_CONTENT_AND_MODE_HERE` with:
+- The full post title and body
+- The reply mode (Mode 1: venting/frustration, Mode 2: how-do-you-handle-X, Mode 3: tool recommendation)
+- The product description (so Gemini knows what to avoid naming in Mode 1/2)
+- If Mode 3: Gemini may name the product AND must name one alternative
+
+---
+
+## Step 6: Self-QA
+
+Run every check and fix violations before presenting:
+
+- [ ] No product name in any Mode 1 or Mode 2 reply
+- [ ] No banned words in any reply: "game-changer", "best-in-class", "streamline", "transform", "revolutionize", "leverage", "seamless", "robust", "innovative"
+- [ ] Every reply is 2-5 sentences (count and state)
+- [ ] Each reply directly addresses the specific question or frustration in the post
+- [ ] All URLs in the output are real Reddit URLs from the search results (not constructed or guessed)
+- [ ] No more than 5 replies drafted in total
+- [ ] Mode 3 replies mention at least one alternative (not just the product)
+- [ ] If any subreddit returned 0 results across all keyword searches, flag it in the output
+
+Fix any violation before presenting.
+
+---
+
+## Step 7: Output and Save
+
+Present the full report:
+
+```
+## Reddit ICP Monitor — [YYYY-MM-DD]
+
+**Subreddits monitored:** r/[subreddit1], r/[subreddit2]
+**Time window:** Last 7 days
+**Keywords searched:** [phrase1], [phrase2], [phrase3]
+**Candidates found:** X posts
+**High-signal matches (score 4-5):** Y posts
+
+---
+
+### Match 1 — Score [N]/5
+**Post:** [title](url)
+**Subreddit:** r/[subreddit] | [N] upvotes | [N] comments
+**Signal quote:** "[relevant excerpt from post body]"
+**Matched keyword:** [phrase]
+**Post type:** Mode [1/2/3]
+
+**Drafted reply:**
+[reply text]
+
+**Reply word count:** N words
+
+---
+
+[repeat for each match]
+
+---
+
+**Subreddits with 0 results:** [list any that returned nothing]
+```
+
+**If 0 posts scored >= 4:**
+"No high-signal matches found in the last 7 days across [subreddits]. Keywords searched: [list]. Try widening the time window (run again and say 'last month') or broadening your pain point phrases in docs/icp.md."
+
+**Save to file:**
+```bash
+mkdir -p docs/reddit-intel
+OUTFILE="docs/reddit-intel/$(date +%Y-%m-%d).md"
+cat > "$OUTFILE" << 'EOF'
+REPORT_CONTENT_HERE
+EOF
+echo "Saved to $OUTFILE"
+```
+
+

package/skills/reddit-icp-monitor/evals/evals.json

@@ -0,0 +1,40 @@
+{
+  "skill_name": "reddit-icp-monitor",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Monitor Reddit for my ICP. My docs/icp.md is already set up with subreddits: devops, startups. Pain points: 'onboarding takes forever', 'new hire ramp time too long'. Product: Ramp, a sales onboarding platform.",
+      "expected_output": "Agent checks GEMINI_API_KEY (set). No Reddit credentials set; uses public JSON endpoints. Reads docs/icp.md, extracts subreddits and pain points. Runs 4 searches (2 subreddits x 2 phrases), URL-encodes each phrase. Deduplicates results by post ID. Writes candidate posts to /tmp/reddit-score-request.json, calls Gemini at temperature 0.2 for scoring. Keeps posts with score >= 4. Drafts replies for high-scoring posts using Gemini at temperature 0.7. Self-QA confirms no product name in Mode 1 or Mode 2 replies, no banned words, all replies 2-5 sentences. Saves report to docs/reddit-intel/YYYY-MM-DD.md.",
+      "files": [
+        "docs/icp.md"
+      ]
+    },
+    {
+      "id": 2,
+      "prompt": "Run the Reddit ICP monitor.",
+      "expected_output": "Agent checks GEMINI_API_KEY (set). Checks for docs/icp.md (not found). Asks all 3 questions in order before proceeding: (1) product description, (2) subreddits, (3) pain point phrases. Does not run any searches before all 3 questions are answered. After answers collected, saves to docs/icp.md in canonical YAML format (product, personas, pain_points, anti_keywords, subreddits). Confirms: 'ICP saved to docs/icp.md.' Proceeds with full search, score, draft cycle. Saves report to docs/reddit-intel/YYYY-MM-DD.md.",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Check Reddit for ICP signals from this week.",
+      "expected_output": "Agent detects GEMINI_API_KEY is missing from environment. Stops immediately at Step 1. Tells the user: 'GEMINI_API_KEY is required. Get it at aistudio.google.com. Add it to your .env file.' Does not run any Reddit searches or generate any content.",
+      "files": [],
+      "setup": "GEMINI_API_KEY not set in environment"
+    },
+    {
+      "id": 4,
+      "prompt": "Monitor Reddit for ICP signals. Subreddits: r/devops, r/startups. Pain points: 'kubernetes cluster management', 'helm chart complexity'.",
+      "expected_output": "Agent runs all searches across both subreddits and both keywords (4 total searches). All searches return 0 results. Agent does not error or produce empty drafted replies. Output: 'No high-signal matches found in the last 7 days across r/devops, r/startups. Keywords searched: kubernetes cluster management, helm chart complexity. Try widening the time window (run again and say last month) or broadening your pain point phrases in docs/icp.md.' Does not attempt to draft replies for zero candidates.",
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Monitor Reddit for my ICP. Mode 2 post found: 'How does your team handle documentation that always goes stale? Looking for process advice.' Product is described in docs/icp.md as DocSync, a docs-as-code platform.",
+      "expected_output": "Agent scores the post >= 4 (clear operational pain point matching the ICP). Classifies post as Mode 2 (how-do-you-handle-X). Drafts a reply describing a process or approach without naming DocSync. Self-QA step detects the word 'DocSync' in the drafted reply. Agent revises the reply to remove the product name. Presents the revised reply which describes the approach generically ('we treat docs as a release artifact, not a side task') without naming any product. Word count confirmed 2-5 sentences.",
+      "files": [
+        "docs/icp.md"
+      ]
+    }
+  ]
+}

package/skills/reddit-icp-monitor/references/icp-format.md

@@ -0,0 +1,131 @@
+# ICP Format
+
+Rules for defining a good ICP for Reddit monitoring and the canonical docs/icp.md format.
+
+---
+
+## What Makes a Good Pain Point Phrase
+
+Pain point phrases are the most important input. Weak phrases return noise. Strong phrases surface exactly the posts you want.
+
+**Write in first-person buyer language, not product marketing language.**
+
+Good phrases match what someone would actually type when frustrated:
+- "onboarding takes forever"
+- "can't figure out why users are churning"
+- "new hire ramp time is killing us"
+- "docs are always out of date"
+- "deployment takes hours"
+- "can't reproduce what's in production"
+
+Bad phrases use category language your ICP would never use:
+- "needs better developer productivity tooling"
+- "seeks churn reduction solution"
+- "looking for CI/CD pipeline optimization"
+- "wants improved observability platform"
+
+**3-6 phrases is the right range.** Too few and you miss signals. Too many and you flood the results with weak matches.
+
+---
+
+## What Makes a Good Subreddit Choice
+
+Choose subreddits where your ICP goes to ask questions, not where they discuss your product category.
+
+Good subreddits (where people describe problems):
+- r/devops — engineers asking "how do you handle X" and venting about ops problems
+- r/ExperiencedDevs — senior engineers sharing pain points
+- r/startups — founders discussing GTM, ops, and scaling problems
+- r/SaaS — SaaS founders and operators discussing growth problems
+- r/entrepreneurship — early-stage founders venting and asking for advice
+- r/sysadmin — ops teams discussing tooling and workflow pain
+
+Bad subreddits (noise, not signal):
+- r/programming — too broad, technical discussions not pain points
+- r/technology — consumer focus, not B2B
+- r/MachineLearning — research-focused, not operational pain
+- Your product's own subreddit — not monitoring your own community
+
+---
+
+## Anti-Keywords
+
+Anti-keywords reduce false positives. If a post contains an anti-keyword, Gemini scores it lower.
+
+Common anti-keyword categories:
+- Company size disqualifiers: "enterprise", "Fortune 500", "10,000 employees"
+- Platform disqualifiers: "SAP", "Oracle", "Salesforce Enterprise"
+- Competitor-specific: add your main competitor if their users are not your ICP
+- Geographic disqualifiers: "government", "regulated industry", "HIPAA-only" (if you don't serve those)
+
+---
+
+## Canonical docs/icp.md Format
+
+```yaml
+---
+product: "One sentence: what the product does and who it's for."
+personas:
+  - "Job title, company size, industry (e.g. VP Engineering, 50-200 person B2B SaaS)"
+  - "Job title, company size, industry (add more if needed)"
+---
+
+pain_points:
+  - "exact phrase your ICP uses when they have the problem"
+  - "another phrase — keep it first-person and conversational"
+  - "third phrase"
+  - "fourth phrase (optional)"
+  - "fifth phrase (optional)"
+
+anti_keywords:
+  - "enterprise"
+  - "government"
+  - "add more if needed"
+
+subreddits:
+  - devops
+  - ExperiencedDevs
+  - startups
+```
+
+**Rules:**
+- `product` must be one sentence. The agent passes this to Gemini for scoring context.
+- `pain_points` must be in quotes. Each is passed as a Reddit search query.
+- `subreddits` are bare names without the `r/` prefix.
+- The file is saved automatically after the first run if it does not exist.
+- Edit it directly to refine keywords based on what you find.
+
+---
+
+## Worked Example
+
+For a sales onboarding platform targeting VP Sales at B2B SaaS companies:
+
+```yaml
+---
+product: "Ramp helps B2B SaaS sales teams cut new hire time-to-first-deal by replacing ad hoc onboarding with structured playbooks and live deal coaching."
+personas:
+  - "VP Sales, 50-200 person B2B SaaS company"
+  - "Head of Revenue, Series B startup"
+---
+
+pain_points:
+  - "new rep ramp time too long"
+  - "sales onboarding is a mess"
+  - "new hires aren't hitting quota"
+  - "onboarding takes 90 days"
+  - "reps forget what they learned in training"
+
+anti_keywords:
+  - "enterprise"
+  - "government"
+  - "channel sales"
+
+subreddits:
+  - sales
+  - SaaS
+  - startups
+  - EntrepreneurRideAlong
+```
+
+Subreddits to avoid for this product: r/cscareerquestions (job seekers, not managers), r/sales (mostly individual contributors, not VPs).

package/skills/reddit-icp-monitor/references/reply-rules.md

@@ -0,0 +1,110 @@
+# Reply Rules
+
+Three modes for drafted replies. Hard rules that apply to all modes.
+
+---
+
+## The Three Post Types
+
+Every Reddit post that scores >= 4 falls into one of three modes. The mode determines what the reply can and cannot include.
+
+---
+
+### Mode 1 — Venting or Frustration Post
+
+The person is expressing frustration, not asking for help or recommendations. They want to be heard.
+
+**Signals:** Statements like "I'm so frustrated with X", "Why is Y so hard?", "Nobody talks about how broken Z is."
+
+**Reply approach:**
+- Start by validating the pain. Show you understand why it's hard.
+- Share one specific insight from your own experience that adds something useful.
+- Do NOT suggest solutions, tools, or products.
+- Do NOT ask "have you tried X?"
+- End with an optional empathetic close or invitation: "If it helps to know, this is a common ceiling at your scale."
+
+**Example:**
+Post: "Why is onboarding new engineers so painful? We hire 4 people a month and it takes 3 weeks before they touch anything real."
+
+Reply: "This is one of those problems that gets worse exactly as you're succeeding — 4 hires a month means your onboarding overhead compounds faster than your headcount. Most teams don't notice until a quarter where ramp time visibly affected bookings. The thing that usually helps isn't a tool, it's admitting the informal 'follow a senior dev' approach doesn't scale past 10 people."
+
+---
+
+### Mode 2 — "How do you handle X?" Post
+
+The person is asking how other teams or practitioners approach a problem. They want operational advice.
+
+**Signals:** Questions like "How does your team handle X?", "What does your process look like for Y?", "Anyone else dealing with Z — what did you do?"
+
+**Reply approach:**
+- Describe what you or your team actually does, in operational terms.
+- Include one concrete detail, metric, or example if you have one.
+- Mention tool categories generically if relevant ("we added a structured onboarding workflow") — not brand names.
+- Do NOT name your product.
+- End with a question if it invites further discussion: "What's your current setup?"
+
+**Example:**
+Post: "How do you all handle documentation that's always out of date? We update it, then 2 sprints later it's wrong again."
+
+Reply: "We treat docs as a release artifact, not a side task. Every PR that changes behavior has to include a docs update before it merges — it's a required check, not a request. It added maybe 10-15 minutes per PR but cut the 'where is the current behavior documented?' questions nearly to zero. The friction is higher upfront but the maintenance overhead dropped a lot."
+
+---
+
+### Mode 3 — "What tool/product solves X?" Post
+
+The person is explicitly asking for tool recommendations. This is the only mode where you can name the product.
+
+**Signals:** Questions like "What tool does X?", "Is there software for Y?", "Looking for a recommendation for Z", "What do you use for X?"
+
+**Reply approach:**
+- Name the product and what it does for this specific use case.
+- Be specific about WHY it fits their situation — not a generic feature list.
+- Name at least one alternative so the reply feels balanced and credible.
+- Keep it short. Do not write a product pitch.
+- Do NOT use marketing language. Describe it like you'd tell a friend.
+
+**Example:**
+Post: "Looking for a tool to track sales rep performance and ramp time. We're about 20 reps now and spreadsheets aren't cutting it."
+
+Reply: "We use Ramp for this — specifically for tracking time-to-first-deal per cohort and seeing where reps get stuck in the process. At 20 reps it starts paying off because you can see whether onboarding gaps are the issue or if it's territory/ICP fit. Alternatives worth looking at are Gong for call analysis and Clari if you want more of a forecasting layer. Depends on whether your bottleneck is rep behavior or pipeline visibility."
+
+---
+
+## Hard Rules (All Modes)
+
+These apply regardless of mode:
+
+**Never name the product in Mode 1 or Mode 2.** Not even a subtle reference. If the reply would only make sense if the reader knows your product, rewrite it.
+
+**Never the first commenter on a post under 1 hour old.** Early replies to fresh posts look automated.
+
+**No links in Mode 1 or Mode 2.** Links in non-recommendation replies look like spam.
+
+**Maximum 5 replies drafted per session.** Posting too many replies from the same ICP context signals a bot, not a practitioner.
+
+**No banned words in any mode:**
+game-changer, best-in-class, streamline, transform, revolutionize, leverage, seamless, robust, comprehensive, innovative, cutting-edge, world-class, disruptive, groundbreaking, paradigm
+
+**No engagement bait:**
+- "What do you think?"
+- "Drop a comment below"
+- "Let me know your thoughts"
+- "Curious what others are experiencing"
+
+**Sound human, not polished.** Contractions are fine. Incomplete sentences are fine. Perfect grammar is suspicious on Reddit.
+
+---
+
+## Identifying the Mode
+
+If the mode is not obvious from the post title, read the first paragraph of the body. The opening sentence usually signals intent:
+
+- "I can't believe how broken..." — Mode 1
+- "Ugh, why is it so hard to..." — Mode 1
+- "How does your team handle..." — Mode 2
+- "What's your process for..." — Mode 2
+- "Looking for a tool that..." — Mode 3
+- "Any recommendations for..." — Mode 3
+- "What do you use for..." — Mode 3
+
+When in doubt between Mode 1 and Mode 2, treat it as Mode 1 (no pitching, just empathy and insight).

package/skills/reddit-post-engine/.env.example

@@ -0,0 +1,13 @@
+# reddit-post-engine — Environment Variables
+# ============================================
+# Gemini is required. Composio is optional for direct posting.
+
+# Required: Google Gemini API key for post drafting
+# Get it: aistudio.google.com, Get API key
+GEMINI_API_KEY=your_gemini_api_key_here
+
+# Optional: Composio API key for direct posting to Reddit
+# Without this: the skill drafts posts for manual submission
+# Get it: app.composio.dev/settings
+# Setup: claude mcp add --transport http reddit-composio "https://mcp.composio.dev/reddit/YOUR_KEY"
+COMPOSIO_API_KEY=your_composio_api_key_here

package/skills/reddit-post-engine/README.md

@@ -0,0 +1,103 @@
+# reddit-post-engine
+
+<img width="1280" height="640" alt="reddit-post-engine" src="https://github.com/user-attachments/assets/2706f326-5fb9-46fc-851a-ec54ccf53f74" />
+
+
+Write and optionally post Reddit content that fits the target subreddit's culture. Fetches subreddit rules and top posts before drafting. Follows the 90/10 rule. Optionally posts via Composio Reddit MCP.
+
+## What It Does
+
+- Fetches the target subreddit's rules and top posts from Reddit's public API
+- Identifies the subreddit's tone and posting conventions
+- Drafts a title and body that match the community's style
+- Keeps product links out of the body (puts them in the first comment)
+- Optionally posts directly via Composio
+- Covers 7 common subreddits with specific playbooks
+
+## Requirements
+
+| Requirement | Purpose | How to Set Up |
+|------------|---------|--------------|
+| Gemini API key | Post drafting and tone matching | aistudio.google.com, Get API key |
+| Composio Reddit MCP (optional) | Direct posting | app.composio.dev |
+
+## Setup
+
+### 1. Configure environment variables
+
+```bash
+cp .env.example .env
+# Add GEMINI_API_KEY (required)
+# Add COMPOSIO_API_KEY if you want direct posting
+```
+
+### 2. Connect Reddit via Composio (optional)
+
+Direct posting requires a Composio account connected to Reddit OAuth:
+
+1. Get your Composio API key at app.composio.dev/settings
+2. Connect Reddit at app.composio.dev/app/reddit
+3. Add the MCP server to Claude Code:
+
+```bash
+claude mcp add --transport http reddit-composio \
+  "https://mcp.composio.dev/reddit/YOUR_COMPOSIO_API_KEY"
+```
+
+4. Verify: `claude mcp list` should show `reddit-composio`
+
+Without Composio, the skill drafts posts for manual copy-paste submission.
+
+## How to Use
+
+Draft a post for a specific subreddit:
+```
+"Help me post my project on r/SideProject"
+"Write a Reddit post for r/devops about my Kubernetes tool"
+"Draft something for r/startups: we hit $1k MRR"
+```
+
+With direct posting:
+```
+"Post my project to r/SideProject via Composio"
+```
+
+Multi-subreddit drafts:
+```
+"Draft posts for r/SideProject and r/indiehackers for my launch"
+```
+
+## Subreddit Playbook Summary
+
+| Subreddit | Tone | What Works |
+|-----------|------|------------|
+| r/devops | Technical, direct | Problem + solution + specific numbers |
+| r/SideProject | Personal, builder | Build story + honest state + link in comment |
+| r/startups | Business-focused | Lessons learned + metrics |
+| r/programming | Technical, skeptical | Novel approach + code examples |
+| r/ExperiencedDevs | Senior-level | Nuanced tradeoffs, no hand-holding |
+| r/indiehackers | Transparent | Revenue numbers, real story |
+| r/webdev | Friendly | What you built + how it works |
+
+## The 90/10 Rule
+
+Reddit detects promotional patterns. For your posts to land well, 90% of your Reddit activity should be genuine community contribution: answering questions, discussing topics, sharing interesting links. At most 10% should be posts about your own work.
+
+This skill drafts high-quality posts, but the underlying account reputation matters. New accounts with no history posting self-promotional content often get filtered.
+
+## Project Structure
+
+```
+reddit-post-engine/
+├── SKILL.md
+├── README.md
+├── .env.example
+├── evals/
+│   └── evals.json
+└── references/
+    └── subreddit-playbook.md
+```
+
+## License
+
+MIT