@opendirectory.dev/skills 0.1.0

package/skills/tweet-thread-from-blog/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: tweet-thread-from-blog
+description: Converts a blog post URL or article into a Twitter/X thread with a strong hook, one insight per tweet, and a CTA. Optionally posts the full thread to X via Composio using a reply chain. Use when asked to turn a blog post into a tweet thread, repurpose an article for Twitter, create a thread from a blog, write a Twitter thread about a topic, or share a blog post as a thread. Trigger when a user mentions Twitter thread, X thread, tweet thread, or wants to repurpose blog content for X/Twitter.
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# Tweet Thread from Blog
+
+Convert a blog post or article into a 7-10 tweet thread. One insight per tweet. Strong hook. CTA in the final tweet. Optionally post the thread directly to X via Composio.
+
+## Writing Style
+
+Apply these rules to every tweet you write:
+
+- Active voice only
+- Conversational, like a person typed it on their phone
+- Contractions required: don't, it's, won't, can't, I've
+- Short sentences, one idea per tweet
+- No em dashes — use a period or comma instead
+- No semicolons
+- No markdown or asterisks
+- No hashtags anywhere in the thread
+
+Banned words — do not use any of these:
+incredible, amazing, leveraging, synergize, game-changing, game changer, let's dive in, buckle up, it's worth noting, delve, harness, unlock, groundbreaking, cutting-edge, remarkable, paradigm, revolutionize, disruptive, transformative, thrilled, excited to share, powerful, innovative, comprehensive, actionable, crucial, vital, pivotal, elucidate, utilize, can, may, just, that, very, really, literally, actually, certainly, probably, basically, could, maybe
+
+If a draft tweet contains any banned word, rewrite it before presenting.
+
+## CRITICAL RULE
+
+Do not invent specifics. Every claim, stat, and example in the thread must come from the blog post. Never fabricate data, quotes, or outcomes.
+
+---
+
+## Step 1: Check Setup
+
+Confirm input is present. The user must provide one of:
+- A blog post URL
+- Pasted article text
+
+If no input is present, ask: "What blog post or article should I turn into a thread? Share a URL or paste the content."
+
+COMPOSIO_API_KEY is only needed for direct posting to X. Output-only mode works without it.
+
+---
+
+## Step 2: Fetch and Extract Content
+
+**If input is a URL:**
+Use WebFetch or Chrome DevTools MCP to fetch the page. Extract:
+- Title
+- Author name
+- Publish date
+- All body text
+- Key statistics and data points
+- Numbered lists or steps
+- Subheadings
+- Any quotes
+
+**If input is pasted text:**
+Read it directly.
+
+After fetching, identify:
+- The single most surprising or counterintuitive insight
+- 6-9 supporting insights, data points, or steps
+- Any specific numbers, percentages, or concrete results
+- The core argument or main takeaway
+
+QA checkpoint: State the core thesis and list the top insights you will use. Confirm every insight comes directly from the source. Do not proceed if you cannot verify a claim.
+
+---
+
+## Step 3: Choose Thread Style
+
+Four styles. Auto-detect from content signals. Respect explicit user override.
+
+| Style | When to Use | Signals |
+|-------|-------------|---------|
+| Data/Insight | Evidence-based article with stats or research findings | Numbers, percentages, study results, data points |
+| How-To | Tutorial, guide, or step-by-step article | Numbered lists, step headers, "how to" in title |
+| Story/Journey | Personal experience, build log, lessons learned | First-person narrative, "I learned", "we built" |
+| Hot Take | Opinion piece, contrarian argument | "Why X is wrong", "Stop doing X", counterintuitive claim |
+
+Decision logic:
+- Article has specific stats or data: Data/Insight
+- Article is structured as steps or tips: How-To
+- Article is first-person narrative: Story/Journey
+- Article argues against a common belief: Hot Take
+
+State the chosen style and reason. If ambiguous, pick one and note it.
+
+---
+
+## Step 4: Read Format Rules
+
+Read `references/thread-format.md` in full before writing any tweet. Internalize:
+- Hook tweet rules (tweet 1 must stop the scroll)
+- One-insight-per-tweet rule
+- Character limit (280 per tweet, count carefully)
+- Thread numbering format (1/8, 2/8, etc.)
+- CTA tweet rules (final tweet only)
+- No hashtags
+- No em dashes
+- Banned word list
+
+Read `references/output-template.md` and select the template matching the chosen style.
+
+---
+
+## Step 5: Generate the Thread
+
+Produce three things:
+
+**(A) The full thread (7-10 tweets)**
+
+Each tweet:
+- Under 280 characters including the tweet number ("1/8 " = 4 characters)
+- Contains exactly one insight, step, or idea
+- Sounds like a human typed it
+- No URLs in tweets 1 through N-1
+- No hashtags
+
+**(B) The CTA tweet (final tweet)**
+- Summarizes the key takeaway in one sentence
+- Ends with one action: "Read the full post in the replies." or "What's your take?" or "Follow for more like this."
+- Includes the source URL if one was provided
+
+**(C) One alternative hook tweet**
+- Uses a different format from the primary hook
+- If primary used a stat, offer a question-based hook
+- If primary used a bold claim, offer a before/after hook
+
+---
+
+## Step 6: Self-QA
+
+Run every check before presenting. Fix violations first.
+
+- [ ] Tweet 1 creates a curiosity gap or leads with the most surprising insight
+- [ ] Every tweet is under 280 characters (count including tweet number)
+- [ ] Each tweet contains exactly one idea
+- [ ] No tweet starts with "I" (exception: Story/Journey style)
+- [ ] No banned words in any tweet
+- [ ] No em dashes in any tweet
+- [ ] No hashtags in any tweet
+- [ ] No URLs except in the final CTA tweet
+- [ ] No invented data. Every stat and example traces to the source.
+- [ ] Thread reads naturally in sequence
+- [ ] Total tweet count is between 7 and 10
+
+State total tweet count and confirm every tweet is under 280 characters before presenting.
+
+---
+
+## Step 7: Post via Composio or Output
+
+**Check for COMPOSIO_API_KEY.**
+
+If set:
+"Thread ready. Confirm to post to X via Composio, or say 'output only' to get the text."
+
+On confirmation:
+1. Post tweet 1 using action `TWITTER_CREATION_OF_A_POST` with `text` set to tweet 1 content
+2. Capture the returned tweet ID
+3. Post tweet 2 with `reply_in_reply_to_tweet_id` = tweet 1 ID, capture its ID
+4. Continue for each tweet in sequence, each replying to the previous tweet's ID
+5. Wait 1 second between posts to avoid rate limiting
+6. After all tweets post: "Thread posted. Tweets 1-N are live."
+
+If not set:
+Present each tweet in a numbered list inside a code block. Add:
+
+"To enable direct posting, add COMPOSIO_API_KEY to your .env file. See README.md for Composio setup."
+
+

package/skills/tweet-thread-from-blog/evals/evals.json

@@ -0,0 +1,35 @@
+{
+  "skill_name": "tweet-thread-from-blog",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Turn this into a tweet thread: https://vercel.com/blog/how-we-optimized-package-imports-in-next-js",
+      "expected_output": "Agent fetches the blog post. Detects Data/Insight style (engineering post with specific performance numbers). Reads references/thread-format.md and references/output-template.md. Extracts the most surprising stat or finding as the hook. Produces 7-10 tweets, each under 280 characters including the tweet number. Every tweet contains exactly one idea. No invented data — all stats and examples trace to the source article. No hashtags in any tweet. No em dashes in any tweet. No banned words. CTA in the final tweet with source URL. Alternative hook provided. Total tweet count stated with confirmation that all tweets are under 280 chars.",
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "Create a Twitter thread from this tutorial: https://www.digitalocean.com/community/tutorials/how-to-set-up-ssh-keys-on-ubuntu-20-04",
+      "expected_output": "Agent fetches the tutorial. Detects How-To style (step-by-step guide with numbered steps). Selects Template 2 (How-To) from output-template.md. Hook states the outcome or what most people miss. Each step from the guide gets its own tweet. Step tweets are concrete and actionable, not generic. Common mistake or key warning included. Result tweet explains what the reader achieves. CTA in final tweet. All tweets under 280 characters. No hashtags. No banned words. No invented steps.",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Make a thread from this: [pasted first-person article about building a SaaS product over 4 months, including specific revenue numbers and a failed pivot]",
+      "expected_output": "Agent reads the pasted content directly — no Chrome needed. Detects Story/Journey style (first-person narrative, build log, specific outcomes). Selects Template 3. Hook captures the end result or key turning point, does not start with 'I'. Setup tweet establishes the problem. Decision tweet covers the pivot attempt. What happened tweet includes specific outcome data from the article. Lesson tweet is concrete, not generic. Advice tweet speaks directly to the reader. Takeaway tweet is for the reader, not the author. CTA in final tweet. All tweets under 280 chars. No invented revenue figures.",
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "Write a thread from this opinion piece arguing that code reviews slow teams down more than they help",
+      "expected_output": "Agent reads the article. Detects Hot Take style (contrarian position, 'Why X is wrong' argument structure). Selects Template 4. Tweet 1 states the contrarian claim directly and concisely. Tweet 2 explains the common assumption. Tweet 3 presents evidence from the article. Tweet 4 states the implication. Tweet 5 steelmans the opposing view. Tweet 6 holds the position. Tweet 7 acknowledges edge cases where the claim breaks down. Final tweet CTA asks for disagreement specifically. No softening language. No hashtags. No banned words. All tweets under 280 chars.",
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Turn this data-heavy performance benchmarking article into a thread but make it How-To style: [URL to article with performance statistics and methodology sections]",
+      "expected_output": "Agent fetches and reads the article. Auto-detection would select Data/Insight based on content. User explicitly requested How-To style — agent respects the override without debate. Applies Template 2 (How-To) to structure the content. Restructures the data and findings into actionable steps the reader can follow. Hook states what the reader achieves by following the steps. Body tweets are step-based, not data-based. Agent notes the style override was applied. All tweets under 280 chars. No hashtags. No invented steps beyond what the article covers.",
+      "files": []
+    }
+  ]
+}

package/skills/tweet-thread-from-blog/references/output-template.md

@@ -0,0 +1,193 @@
+# Output Templates
+
+One template per thread style. Replace every [BRACKETED SLOT] with content extracted from the source. Never leave bracket text in the final output. If a step or insight is not in the source, skip that tweet rather than inventing content.
+
+Adjust N to the actual tweet count (7-10) before numbering.
+
+---
+
+## Template 1: Data/Insight
+
+Use for evidence-based articles with stats, research findings, or data points.
+
+```
+1/N [HOOK — the most surprising stat or finding from the article]
+
+2/N [CONTEXT — what most people assume or the common approach]
+
+3/N [FIRST DATA POINT — specific number or finding]
+
+4/N [SECOND DATA POINT — specific number or finding]
+
+5/N [THIRD DATA POINT OR IMPLICATION — what this means in practice]
+
+6/N [COUNTERPOINT — the objection or nuance worth acknowledging]
+
+7/N [TAKEAWAY — the single most useful thing to remember]
+
+8/N [CTA — what to do next, source link if provided]
+```
+
+Worked example (API performance profiling article):
+
+```
+1/8 Most developers are optimising the wrong bottleneck. They profile query speed. The real problem is payload size.
+
+2/8 Standard advice: add indexes, cache queries, tune your ORM. All fine. None of it addresses what's actually slow in 60% of cases.
+
+3/8 We ran a trace on our most-used endpoint. 800ms response time. Query: 12ms. Serialization: 788ms. We were sending 4MB of data per request.
+
+4/8 Switched to field selection. Users request only the fields they need. Average payload dropped from 4MB to 180KB.
+
+5/8 Response time: 800ms to 90ms. No query changes. No cache layer. No infrastructure cost.
+
+6/8 This doesn't apply if your queries are actually slow. Profile first. Don't assume.
+
+7/8 The bottleneck is almost always what you're sending, not how fast you're finding it.
+
+8/8 Full post in the replies. If this was useful, retweet tweet 1.
+```
+
+---
+
+## Template 2: How-To
+
+Use for tutorials, guides, and step-by-step articles.
+
+```
+1/N [HOOK — the result the reader achieves, or what most people miss]
+
+2/N [WHY THIS MATTERS — the cost of not doing it, or who this is for]
+
+3/N [STEP 1 — one action, one line]
+
+4/N [STEP 2 — one action, one line]
+
+5/N [STEP 3 — one action, one line]
+
+6/N [STEP 4 OR KEY MISTAKE — common error at this stage]
+
+7/N [RESULT — what happens when you follow the steps]
+
+8/N [CTA]
+```
+
+Worked example (SSH key authentication setup):
+
+```
+1/8 You don't need a password to SSH into a server. Here's how to set it up in 10 minutes.
+
+2/8 Password SSH leaves you open to brute force. Key auth locks that door. Most devs know this and still haven't done it.
+
+3/8 Step 1: Generate your key pair. Run: ssh-keygen -t ed25519 -C your@email.com. Save to ~/.ssh/id_ed25519.
+
+4/8 Step 2: Copy the public key to your server. Run: ssh-copy-id user@server-address. It adds your key to authorized_keys automatically.
+
+5/8 Step 3: Test the connection. Run: ssh user@server-address. No password prompt means it worked.
+
+6/8 Common mistake: forgetting to restrict permissions. Run chmod 700 ~/.ssh and chmod 600 ~/.ssh/authorized_keys on the server.
+
+7/8 Once this is set up, you never type that password again. Every other tool — rsync, SCP, Git over SSH — inherits the key auth.
+
+8/8 Full step-by-step in the replies. Works on Linux, macOS, and WSL.
+```
+
+---
+
+## Template 3: Story/Journey
+
+Use for personal experience articles, build logs, and lessons-learned posts.
+
+```
+1/N [HOOK — the end result or the key moment that changed things. Does not start with "I".]
+
+2/N [SETUP — where you started, the problem]
+
+3/N [DECISION — what you tried or changed]
+
+4/N [WHAT HAPPENED — the unexpected result or outcome]
+
+5/N [WHAT YOU LEARNED — the lesson]
+
+6/N [WHAT YOU'D DO DIFFERENTLY — the advice for others]
+
+7/N [TAKEAWAY — for the reader, not just you]
+
+8/N [CTA]
+```
+
+Worked example (indie hacker launch story):
+
+```
+1/8 After 6 months of building in silence, we shipped. First paying customer came 4 hours later. Here's what went right and what nearly didn't.
+
+2/8 We built a tool for devs to monitor API latency across providers. Nothing fancy. The problem was real — we had it ourselves.
+
+3/8 3 months in, we almost pivoted. Users kept asking for Slack alerts. We said no. Stayed focused on the core latency chart.
+
+4/8 Launch day: posted on HN Show. Got 230 upvotes. 140 signups in 24 hours. 3 converted to paid on day 1.
+
+5/8 The Slack alerts users asked for? We shipped them in month 4. They became our top retention driver. We just needed to earn the right to build them.
+
+6/8 Ship the dumb simple version first. Not because it's faster. Because it tells you what actually matters.
+
+7/8 Feature requests are noise until you have users. Users tell you which noise is signal.
+
+8/8 Full build log in the replies. What would you have done differently?
+```
+
+---
+
+## Template 4: Hot Take
+
+Use for opinion pieces, contrarian arguments, and counterintuitive claims.
+
+```
+1/N [THE CLAIM — the contrarian position stated directly]
+
+2/N [THE ASSUMPTION — what most people believe and why]
+
+3/N [THE EVIDENCE — what you actually observed or data that supports the claim]
+
+4/N [THE IMPLICATION — what changes if the claim is true]
+
+5/N [THE COUNTERARGUMENT — steelman the other side]
+
+6/N [THE REBUTTAL — why you still hold the position]
+
+7/N [THE NUANCE — when are you wrong? edge cases?]
+
+8/N [CTA — ask for disagreement: "Tell me why I'm wrong."]
+```
+
+Worked example (standups are waste):
+
+```
+1/8 Daily standups don't solve coordination problems. They create them.
+
+2/8 The logic: if everyone knows what everyone else is doing, blockers surface faster. Reasonable assumption. Wrong conclusion.
+
+3/8 We tracked 3 months of standups. Average useful information exchanged per person: 12 seconds. Average time lost to context switching: 23 minutes per attendee.
+
+4/8 If standups are your coordination layer, async is your alternative. But most teams treat async as standups with a time delay.
+
+5/8 The counterargument: standups build team cohesion. True. But you can build cohesion cheaper with better rituals.
+
+6/8 The real function of standups is making managers feel informed. That's a legitimate need. It's not a coordination mechanism.
+
+7/8 This breaks down for teams that are genuinely blocked on each other daily. Short-cycle integration work, for instance. Know your context.
+
+8/8 Tell me why I'm wrong. Full piece in the replies.
+```
+
+---
+
+## Fill-in Rules
+
+1. Replace every [BRACKETED SLOT] with content from the source material
+2. Never leave bracket text in the output
+3. Count characters for every tweet including the "N/N " prefix
+4. Apply Writing Style rules: no em dashes, no semicolons, no banned words, no hashtags
+5. If a step or point is not in the source, skip that tweet rather than inventing content
+6. Adjust N to the actual tweet count (7-10)
+7. The CTA tweet always goes last, always contains the source URL if one was provided

package/skills/tweet-thread-from-blog/references/thread-format.md

@@ -0,0 +1,107 @@
+# Thread Format Reference
+
+Rules and conventions for writing Twitter/X threads. Read this in full before generating any thread.
+
+---
+
+## Section 1: Why Format Matters
+
+Tweet 1 is all that appears in the feed. Everything depends on the hook.
+
+Threads with 8-12 tweets outperform shorter threads by roughly 47% on engagement (Buffer/Sprout Social data). One idea per tweet makes each tweet independently shareable. Completion rate drops through the middle tweets and spikes again on the final tweet.
+
+---
+
+## Section 2: Hook Tweet Rules (Tweet 1)
+
+The hook must:
+- Lead with the most surprising, counterintuitive, or valuable insight from the source
+- Create a curiosity gap — the reader wants to know the rest
+- Stand alone as a compelling statement
+
+Hook formats that work:
+
+| Format | Example |
+|--------|---------|
+| Specific stat | "Most developers waste 40% of their debugging time on the wrong layer." |
+| Bold claim | "The advice every senior engineer gives is wrong." |
+| Question | "What would you do if your prod DB went down and your backup was corrupt?" |
+| Before/after | "3 months ago our API took 1.2s. Now it takes 90ms. Here's what we changed." |
+| Counterintuitive | "Slower shipping made our team faster." |
+
+Do NOT open with:
+- "A thread on [topic]:"
+- "Let me share"
+- "Today I want to talk about"
+- "Quick thread:"
+- Anything that announces the thread instead of starting it
+
+---
+
+## Section 3: Body Tweet Rules (Tweets 2 to N-1)
+
+- One idea per tweet, no more
+- If a tweet can be split into two, split it
+- 280 chars max including tweet number ("3/9 " = 4 characters)
+- Use line breaks inside tweets for readability (2 lines max)
+- Specifics beat generics ("saved 4 hours/week" beats "saved time")
+- Numbers, examples, and quotes from the source are your best material
+- Conversational tone: contractions, plain words, direct address ("you" not "one")
+
+---
+
+## Section 4: CTA Tweet Rules (Final Tweet)
+
+End with exactly one action. Options:
+
+- **Link CTA:** "Full post in the replies." (then post the URL as a reply after the thread)
+- **Engagement CTA:** "What's your experience with this? Reply below."
+- **Follow CTA:** "Follow [handle] for more posts like this." (only if user provides their handle)
+- **Retweet CTA:** "If this was useful, retweet tweet 1 so others see it."
+
+Do NOT combine multiple CTAs. Do NOT use "let me know your thoughts" — it's low signal.
+
+---
+
+## Section 5: Thread Numbering
+
+Format: "1/8" at the start of each tweet. "8/8" for the final tweet.
+
+Example tweet 1: `1/8 Most developers are optimising the wrong bottleneck.`
+Example tweet 8: `8/8 The bottleneck is almost always what you're sending, not how fast you're finding it. Full post in the replies.`
+
+Always number. Readers use numbers to track how far they are in the thread.
+
+---
+
+## Section 6: Banned Words
+
+Do not use any of these in any tweet:
+
+incredible, amazing, leveraging, synergize, game-changing, game changer, let's dive in, buckle up, it's worth noting, delve, harness, unlock, groundbreaking, cutting-edge, remarkable, paradigm, revolutionize, disruptive, transformative, thrilled, excited to share, powerful, innovative, comprehensive, actionable, crucial, vital, pivotal, elucidate, utilize, can, may, just, that, very, really, literally, actually, certainly, probably, basically, could, maybe
+
+If a draft tweet contains any banned word, rewrite before presenting.
+
+---
+
+## Section 7: No Hashtags
+
+Do not include hashtags in any tweet. Hashtags reduce the quality signal of technical threads and are not needed for reach in reply chains.
+
+---
+
+## Section 8: Validation Checklist
+
+Run before presenting. Fix all violations first.
+
+- [ ] Tweet 1 creates a curiosity gap or leads with most surprising insight
+- [ ] Every tweet is under 280 characters (including tweet number)
+- [ ] Each tweet contains exactly one idea
+- [ ] No tweet starts with "I" (unless Story/Journey style)
+- [ ] No banned words in any tweet
+- [ ] No em dashes in any tweet
+- [ ] No hashtags anywhere
+- [ ] No URLs except in the CTA tweet
+- [ ] No invented data
+- [ ] Thread reads naturally in sequence
+- [ ] Total tweet count is 7-10

package/skills/twitter-GTM-find-skill/README.md

@@ -0,0 +1,43 @@
+# Twitter GTM Find Skill
+
+<img width="1280" height="640" alt="Generated_chart__twitter-gtm-find-cover-bw png" src="https://github.com/user-attachments/assets/618b0abe-34fc-4c3e-a345-1a3eaeb3d20b" />
+
+This repository contains the `twitter-GTM-find/` AI Skill. 
+
+This pipeline automates the discovery of highly-targeted, Developer-First startups hiring for Go-To-Market (GTM), Developer Relations (DevRel), and Growth roles by scraping Twitter (via Apify) and automatically verifying the startups' funding and product type using Gemini's native Google Search Grounding.
+
+## The Skill Directory
+
+All executable code and documentation are packaged cleanly inside the `twitter-GTM-find/` folder. This is designed to be directly imported and read by AI agents (like OpenClaw or Claude) so they understand how to use the tool.
+
+```text
+twitter-GTM-find/
+├── SKILL.md             <-- The AI entry point and documentation
+├── references/          
+│   └── icp-checklist.md <-- The strict evaluation criteria (Dev-first + $100K+ funded)
+└── scripts/
+    ├── run_pipeline.sh  <-- The executable shell script
+    └── src/             <-- The TypeScript pipeline source code
+```
+
+## Usage
+
+To run the pipeline manually or via an agent:
+
+1. Create a `.env` file at the root of the repository:
+   ```env
+   APIFY_API_TOKEN=your_apify_token
+   GEMINI_API_KEY=your_gemini_api_key
+   MAX_POSTS=20
+   ```
+2. Run the shell script:
+   ```bash
+   cd twitter-GTM-find/scripts
+   bash run_pipeline.sh
+   ```
+
+## Output
+
+The pipeline generates two temporary files at the root of the repository (which are `.gitignore`d to prevent leaking data):
+- `radar-jobs.json`: The initial raw batch of scraped tech jobs.
+- `openclaw-icp-jobs.json`: The final, strict ICP-validated list of highly funded, developer-first startups hiring right now.

package/skills/twitter-GTM-find-skill/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: twitter-GTM-find-skill
+description: A skill for twitter-GTM-find-skill
+author: OpenDirectory
+version: 1.0.0
+---
+

package/skills/twitter-GTM-find-skill/twitter-GTM-find/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: twitter-GTM-find-Skill
+description: End-to-end pipeline for scraping Twitter for GTM/DevRel tech startup jobs using Apify, and validating them against an Ideal Customer Profile (ICP) using Gemini's native Google Search Grounding. Use this skill when OpenClaw needs to find developer-first, funded startups actively hiring for GTM, DevRel, or Growth roles.
+---
+
+# Twitter GTM Find Skill
+
+This skill provides an automated pipeline to scrape Twitter for Developer-First startups hiring GTM/DevRel roles, followed by an automatic web-search verification step to validate them against our Ideal Customer Profile (ICP).
+
+## Using the Pipeline
+
+You can run the full pipeline using the executable Node.js project bundled in `scripts/`. 
+
+```bash
+cd scripts
+npm install
+npx ts-node src/index.ts
+```
+
+**Requirements:**
+A `.env` file must be present at the workspace root with:
+- `APIFY_API_TOKEN` (Apify account access)
+- `GEMINI_API_KEY` (Gemini 3 Flash Preview with Search Grounding)
+- `MAX_POSTS=20` (Optional limit)
+
+## Outputs
+
+The script handles two primary JSON files:
+1. `radar-jobs.json`: The initial raw batch of tech jobs identified by the scraper.
+2. `openclaw-icp-jobs.json`: The **final validated file** OpenClaw should ingest, containing only companies that passed the strict web-search evaluation.
+
+## References
+
+For deeper context on how the evaluation works or modifying the pipeline, read these files as needed:
+
+- **ICP Checklist**: See [references/icp-checklist.md](references/icp-checklist.md) for the exact strict evaluation criteria (Developer-first + $100K minimum funding).
+- **Gemini Search Grounding**: The pipeline (`scripts/src/icp-filter.ts`) natively uses Google Search Grounding via the `@google/generative-ai` SDK (`gemini-3-flash-preview` / `gemini-flash-latest`) to look up live funding and product data.

package/skills/twitter-GTM-find-skill/twitter-GTM-find/references/icp-checklist.md

@@ -0,0 +1,35 @@
+# Ideal Customer Profile (ICP) Checklist
+
+When evaluating whether a scraped company meets our OpenClaw ICP, follow these strict guidelines.
+
+## 1. Developer-First Product
+**What qualifies:**
+* API platforms, infrastructure tools, SDKs, dev utilities
+* AI agents/automation for technical workflows
+* DevOps, CI/CD, monitoring, analytics
+* Code editors, Data infrastructure, LLM deployment platforms
+
+**Auto-skip (NOT ICP):**
+* Consumer apps, B2C SaaS
+* HR tools, Recruiting agencies
+* Pure Fintech or Healthcare software
+* Traditional physical industries (Real estate, Automotive, Clinics)
+
+## 2. Funding Evidence
+**Minimum requirement:**
+* $100K+ raised (verifiable via Crunchbase, YC, press, founder posts)
+
+**Preferred:**
+* $500K-$5M seed/Series A in the last 18 months
+* Backed by Y Combinator (YC), a16z, Sequoia
+
+**Skip if (NOT ICP):**
+* Purely bootstrapped companies with zero external capital mentioned
+* Service agencies with no product (even if they do tech/web3 marketing)
+* No verifiable funding evidence found online
+
+## Evaluation Process
+1. Research the company's official website to determine the product type.
+2. Search "[Company Name] funding Crunchbase Y Combinator" to find capital raised.
+3. If they are a dev-first/infrastructure/AI tool AND have funding -> `isICP` is `true`.
+4. If they fail EITHER criteria -> `isICP` is `false`.

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "twitter-gtm-jobs-radar",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "dependencies": {
+    "@google/generative-ai": "^0.24.1",
+    "apify-client": "^2.22.3",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/run_pipeline.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+
+echo "Installing pipeline dependencies..."
+npm install
+
+echo "Running OpenClaw Twitter Jobs Radar..."
+npx ts-node src/index.ts