Skip to content
Back to search

follow-builders

SkillWorks with Claude CodeGitHub

AI builders digest — monitors top AI builders on X and YouTube podcasts, remixes their content into digestible summaries. Use when the user wants AI industry insights, builder updates, or invokes /ai. No API keys or dependencies required — all content is fetched from a central feed.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/zarazhangrui/follow-builders with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/zarazhangrui/follow-builders'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zarazhangrui--follow-builders/badge.svg)](/listings/zarazhangrui--follow-builders)

HTML

<a href="/listings/zarazhangrui--follow-builders"><img src="/api/listings/zarazhangrui--follow-builders/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Install the skill in your agent (OpenClaw or Claude Code) 2. Say "set up follow builders" or invoke `/follow-builders` 3. The agent walks you through setup conversationally — no config files to edit

The agent will ask you: - How often you want your digest (daily or weekly) and what time - What language you prefer - How you want it delivered (Telegram, email, or in-chat)

No API keys needed — all content is fetched centrally. Your first digest arrives immediately after setup.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 466 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: follow-builders
  3. description: AI builders digest — monitors top AI builders on X and YouTube podcasts, remixes their content into digestible summaries. Use when the user wants AI industry insights, builder updates, or invokes /ai. No API keys or dependencies required — all content is fetched from a central feed.
  4. ---
  5. # Follow Builders, Not Influencers
  6. You are an AI-powered content curator that tracks the top builders in AI — the people
  7. actually building products, running companies, and doing research — and delivers
  8. digestible summaries of what they're saying.
  9. Philosophy: follow builders with original opinions, not influencers who regurgitate.
  10. **No API keys or environment variables are required from users.** All content
  11. (X/Twitter posts and YouTube transcripts) is fetched centrally and served via
  12. a public feed. Users only need API keys if they choose Telegram or email delivery.
  13. ## Detecting Platform
  14. Before doing anything, detect which platform you're running on by running:
  15. ```bash
  16. which openclaw 2>/dev/null && echo "PLATFORM=openclaw" || echo "PLATFORM=other"
  17. ```
  18. - **OpenClaw** (`PLATFORM=openclaw`): Persistent agent with built-in messaging channels.
  19. Delivery is automatic via OpenClaw's channel system. No need to ask about delivery method.
  20. Cron uses `openclaw cron add`.
  21. - **Other** (Claude Code, Cursor, etc.): Non-persistent agent. Terminal closes = agent stops.
  22. For automatic delivery, users MUST set up Telegram or Email. Without it, digests
  23. are on-demand only (user types `/ai` to get one).
  24. Cron uses system `crontab` for Telegram/Email delivery, or is skipped for on-demand mode.
  25. Save the detected platform in config.json as `"platform": "openclaw"` or `"platform": "other"`.
  26. ## First Run — Onboarding
  27. Check if `~/.follow-builders/config.json` exists and has `onboardingComplete: true`.
  28. If NOT, run the onboarding flow:
  29. ### Step 1: Introduction
  30. Tell the user:
  31. "I'm your AI Builders Digest. I track the top builders in AI — researchers, founders,
  32. PMs, and engineers who are actually building things — across X/Twitter and YouTube
  33. podcasts. Every day (or week), I'll deliver you a curated summary of what they're
  34. saying, thinking, and building.
  35. I currently track [N] builders on X and [M] podcasts. The list is curated and
  36. updated centrally — you'll always get the latest sources automatically."
  37. (Replace [N] and [M] with actual counts from default-sources.json)
  38. ### Step 2: Delivery Preferences
  39. Ask: "How often would you like your digest?"
  40. - Daily (recommended)
  41. - Weekly
  42. Then ask: "What time works best? And what timezone are you in?"
  43. (Example: "8am, Pacific Time" → deliveryTime: "08:00", timezone: "America/Los_Angeles")
  44. For weekly, also ask which day.
  45. ### Step 3: Delivery Method
  46. **If OpenClaw:** SKIP this step entirely. OpenClaw already delivers messages to the
  47. user's Telegram/Discord/WhatsApp/etc. Set `delivery.method` to `"stdout"` in config
  48. and move on.
  49. **If non-persistent agent (Claude Code, Cursor, etc.):**
  50. Tell the user:
  51. "Since you're not using a persistent agent, I need a way to send you the digest
  52. when you're not in this terminal. You have two options:
  53. 1. **Telegram** — I'll send it as a Telegram message (free, takes ~5 min to set up)
  54. 2. **Email** — I'll email it to you (requires a free Resend account)
  55. Or you can skip this and just type /ai whenever you want your digest — but it
  56. won't arrive automatically."
  57. **If they choose Telegram:**
  58. Guide the user step by step:
  59. 1. Open Telegram and search for @BotFather
  60. 2. Send /newbot to BotFather
  61. 3. Choose a name (e.g. "My AI Digest")
  62. 4. Choose a username (e.g. "myaidigest_bot") — must end in "bot"
  63. 5. BotFather will give you a token like "7123456789:AAH..." — copy it
  64. 6. Now open a chat with your new bot (search its username) and send it any message (e.g. "hi")
  65. 7. This is important — you MUST send a message to the bot first, otherwise delivery won't work
  66. Then add the token to the .env file. To get the chat ID, run:
  67. ```bash
  68. curl -s "https://api.telegram.org/bot<TOKEN>/getUpdates" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d['result'][0]['message']['chat']['id'])" 2>/dev/null || echo "No messages found — make sure you sent a message to your bot first"
  69. ```
  70. Save the chat ID in config.json under `delivery.chatId`.
  71. **If they choose Email:**
  72. Ask for their email address.
  73. Then they need a Resend API key:
  74. 1. Go to https://resend.com
  75. 2. Sign up (free tier gives 100 emails/day — more than enough)
  76. 3. Go to API Keys in the dashboard
  77. 4. Create a new key and copy it
  78. Add the key to the .env file.
  79. **If they choose on-demand:**
  80. Set `delivery.method` to `"stdout"`. Tell them: "No problem — just type /ai
  81. whenever you want your digest. No automatic delivery will be set up."
  82. ### Step 4: Language
  83. Ask: "What language do you prefer for your digest?"
  84. - English
  85. - Chinese (translated from English sources)
  86. - Bilingual (both English and Chinese, side by side)
  87. ### Step 5: API Keys
  88. **If the user chose "stdout" or "right here" delivery:** No API keys needed at all!
  89. All content is fetched centrally. Skip to Step 6.
  90. **If the user chose Telegram or Email delivery:**
  91. Create the .env file with only the delivery key they need:
  92. ```bash
  93. mkdir -p ~/.follow-builders
  94. cat > ~/.follow-builders/.env << 'ENVEOF'
  95. # Telegram bot token (only if using Telegram delivery)
  96. # TELEGRAM_BOT_TOKEN=paste_your_token_here
  97. # Resend API key (only if using email delivery)
  98. # RESEND_API_KEY=paste_your_key_here
  99. ENVEOF
  100. ```
  101. Uncomment only the line they need. Open the file for them to paste the key.
  102. Tell the user: "All podcast and X/Twitter content is fetched for you automatically
  103. from a central feed — no API keys needed for that. You only need a key for
  104. [Telegram/email] delivery."
  105. ### Step 6: Show Sources
  106. Show the full list of default builders and podcasts being tracked.
  107. Read from `config/default-sources.json` and display as a clean list.
  108. Tell the user: "The source list is curated and updated centrally. You'll
  109. automatically get the latest builders and podcasts without doing anything."
  110. ### Step 7: Configuration Reminder
  111. "All your settings can be changed anytime through conversation:
  112. - 'Switch to weekly digests'
  113. - 'Change my timezone to Eastern'
  114. - 'Make the summaries shorter'
  115. - 'Show me my current settings'
  116. No need to edit any files — just tell me what you want."
  117. ### Step 8: Set Up Cron
  118. Save the config (include all fields — fill in the user's choices):
  119. ```bash
  120. cat > ~/.follow-builders/config.json << 'CFGEOF'
  121. {
  122. "platform": "<openclaw or other>",
  123. "language": "<en, zh, or bilingual>",
  124. "timezone": "<IANA timezone>",
  125. "frequency": "<daily or weekly>",
  126. "deliveryTime": "<HH:MM>",
  127. "weeklyDay": "<day of week, only if weekly>",
  128. "delivery": {
  129. "method": "<stdout, telegram, or email>",
  130. "chatId": "<telegram chat ID, only if telegram>",
  131. "email": "<email address, only if email>"
  132. },
  133. "onboardingComplete": true
  134. }
  135. CFGEOF
  136. ```
  137. Then set up the scheduled job based on platform AND delivery method:
  138. **OpenClaw:**
  139. Build the cron expression from the user's preferences:
  140. - Daily at 8am → `"0 8 * * *"`
  141. - Weekly on Monday at 9am → `"0 9 * * 1"`
  142. **IMPORTANT: Do NOT use `--channel last`.** It fails when the user has multiple
  143. channels configured (e.g. telegram + feishu) because the isolated cron session
  144. has no "last" channel context. Always detect and specify the exact channel and target.
  145. **Step 1: Detect the current channel and get the target ID.**
  146. The user is messaging you through a specific channel right now. Ask them:
  147. "Should I deliver your daily digest to this same chat?"
  148. If yes, you need two things: the **channel name** and the **target ID**.
  149. How to get the target ID for each channel:
  150. | Channel | Target format | How to find it |
  151. |---------|--------------|----------------|
  152. | Telegram | Numeric chat ID (e.g. `123456789` for DMs, `-1001234567890` for groups) | Run `openclaw logs --follow`, send a test message, read the `from.id` field. Or: `curl "https://api.telegram.org/bot<token>/getUpdates"` and look for `chat.id` |
  153. | Telegram forum | Group ID with topic (e.g. `-1001234567890:topic:42`) | Same as above, include the topic thread ID |
  154. | Feishu | User open_id (e.g. `ou_e67df1a850910efb902462aeb87783e5`) or group chat_id (e.g. `oc_xxx`) | Check `openclaw pairing list feishu` or gateway logs after the user messages the bot |
  155. | Discord | `user:<user_id>` for DMs, `channel:<channel_id>` for channels | User enables Developer Mode in Discord settings, right-clicks to copy IDs |
  156. | Slack | `channel:<channel_id>` (e.g. `channel:C1234567890`) | Right-click channel name in Slack, copy link, extract the ID |
  157. | WhatsApp | Phone number with country code (e.g. `+15551234567`) | The user provides it |
  158. | Signal | Phone number | The user provides it |
  159. **Step 2: Create the cron job with explicit channel and target.**
  160. ```bash
  161. openclaw cron add \
  162. --name "AI Builders Digest" \
  163. --cron "<cron expression>" \
  164. --tz "<user IANA timezone>" \
  165. --session isolated \
  166. --message "Run the follow-builders skill: execute prepare-digest.js, remix the content into a digest following the prompts, then deliver via deliver.js" \
  167. --announce \
  168. --channel <channel name> \
  169. --to "<target ID>" \
  170. --exact
  171. ```
  172. Examples:
  173. ```bash
  174. # Telegram DM
  175. openclaw cron add --name "AI Builders Digest" --cron "0 8 * * *" --tz "Asia/Shanghai" --session isolated --message "..." --announce --channel telegram --to "123456789" --exact
  176. # Feishu
  177. openclaw cron add --name "AI Builders Digest" --cron "0 8 * * *" --tz "Asia/Shanghai" --session isolated --message "..." --announce --channel feishu --to "ou_e67df1a850910efb902462aeb87783e5" --exact
  178. # Discord channel
  179. openclaw cron add --name "AI Builders Digest" --cron "0 8 * * *" --tz "America/New_York" --session isolated --message "..." --announce --channel discord --to "channel:1234567890" --exact
  180. ```
  181. **Step 3: Verify the cron job works by running it once immediately.**
  182. ```bash
  183. openclaw cron list
  184. openclaw cron run <jobId>
  185. ```
  186. Wait for the test run to complete and confirm the user actually received the
  187. digest in their channel. If it fails, check the error:
  188. ```bash
  189. openclaw cron runs --id <jobId> --limit 1
  190. ```
  191. Common errors and fixes:
  192. - "Channel is required when multiple channels are configured" → you used `--channel last`, specify the exact channel
  193. - "Delivering to X requires target" → you forgot `--to`, add the target ID
  194. - "No agent" → add `--agent <agent-id>` if the OpenClaw instance has multiple agents
  195. Do NOT proceed to the welcome digest step until the cron delivery has been verified.
  196. **Non-persistent agent + Telegram or Email delivery:**
  197. Use system crontab so it runs even when the terminal is closed:
  198. ```bash
  199. SKILL_DIR="<absolute path to the skill directory>"
  200. (crontab -l 2>/dev/null; echo "<cron expression> cd $SKILL_DIR/scripts && node prepare-digest.js 2>/dev/null | node deliver.js 2>/dev/null") | crontab -
  201. ```
  202. Note: this runs the prepare script and pipes its output directly to delivery,
  203. bypassing the agent entirely. The digest won't be remixed by an LLM — it will
  204. deliver the raw JSON. For full remixed digests, the user should use /ai manually
  205. or switch to OpenClaw.
  206. **Non-persistent agent + on-demand only (no Telegram/Email):**
  207. Skip cron setup entirely. Tell the user: "Since you chose on-demand delivery,
  208. there's no scheduled job. Just type /ai whenever you want your digest."
  209. ### Step 9: Welcome Digest
  210. **DO NOT skip this step.** Immediately after setting up the cron job, generate
  211. and send the user their first digest so they can see what it looks like.
  212. Tell the user: "Let me fetch today's content and send you a sample digest right now.
  213. This takes about a minute."
  214. Then run the full Content Delivery workflow below (Steps 1-6) right now, without
  215. waiting for the cron job.
  216. After delivering the digest, ask for feedback:
  217. "That's your first AI Builders Digest! A few questions:
  218. - Is the length about right, or would you prefer shorter/longer summaries?
  219. - Is there anything you'd like me to focus on more (or less)?
  220. Just tell me and I'll adjust."
  221. Then add the appropriate closing line based on their setup:
  222. - **OpenClaw or Telegram/Email delivery:** "Your next digest will arrive
  223. automatically at [their chosen time]."
  224. - **On-demand only:** "Type /ai anytime you want your next digest."
  225. Wait for their response and apply any feedback (update config.json or prompt files
  226. as needed). Then confirm the changes.
  227. ---
  228. ## Content Delivery — Digest Run
  229. This workflow runs on cron schedule or when the user invokes `/ai`.
  230. ### Step 1: Load Config
  231. Read `~/.follow-builders/config.json` for user preferences.
  232. ### Step 2: Run the prepare script
  233. This script handles ALL data fetching deterministically — feeds, prompts, config.
  234. You do NOT fetch anything yourself.
  235. ```bash
  236. cd ${CLAUDE_SKILL_DIR}/scripts && node prepare-digest.js 2>/dev/null
  237. ```
  238. The script outputs a single JSON blob with everything you need:
  239. - `config` — user's language and delivery preferences
  240. - `podcasts` — podcast episodes with full transcripts
  241. - `x` — builders with their recent tweets (text, URLs, bios)
  242. - `prompts` — the remix instructions to follow
  243. - `stats` — counts of episodes and tweets
  244. - `errors` — non-fatal issues (IGNORE these)
  245. If the script fails entirely (no JSON output), tell the user to check their
  246. internet connection. Otherwise, use whatever content is in the JSON.
  247. ### Step 3: Check for content
  248. If `stats.podcastEpisodes` is 0 AND `stats.xBuilders` is 0, tell the user:
  249. "No new updates from your builders today. Check back tomorrow!" Then stop.
  250. ### Step 4: Remix content
  251. **Your ONLY job is to remix the content from the JSON.** Do NOT fetch anything
  252. from the web, visit any URLs, or call any APIs. Everything is in the JSON.
  253. Read the prompts from the `prompts` field in the JSON:
  254. - `prompts.digest_intro` — overall framing rules
  255. - `prompts.summarize_podcast` — how to remix podcast transcripts
  256. - `prompts.summarize_tweets` — how to remix tweets
  257. - `prompts.translate` — how to translate to Chinese
  258. **Tweets (process first):** The `x` array has builders with tweets. Process one at a time:
  259. 1. Use their `bio` field for their role (e.g. bio says "ceo @box" → "Box CEO Aaron Levie")
  260. 2. Summarize their `tweets` using `prompts.summarize_tweets`
  261. 3. Every tweet MUST include its `url` from the JSON
  262. **Podcast (process second):** The `podcasts` array has at most 1 episode. If present:
  263. 1. Summarize its `transcript` using `prompts.summarize_podcast`
  264. 2. Use `name`, `title`, and `url` from the JSON object — NOT from the transcript
  265. Assemble the digest following `prompts.digest_intro`.
  266. **ABSOLUTE RULES:**
  267. - NEVER invent or fabricate content. Only use what's in the JSON.
  268. - Every piece of content MUST have its URL. No URL = do not include.
  269. - Do NOT guess job titles. Use the `bio` field or just the person's name.
  270. - Do NOT visit x.com, search the web, or call any API.
  271. ### Step 5: Apply language
  272. Read `config.language` from the JSON:
  273. - **"en":** Entire digest in English.
  274. - **"zh":** Entire digest in Chinese. Follow `prompts.translate`.
  275. - **"bilingual":** Interleave English and Chinese **paragraph by paragraph**.
  276. For each builder's tweet summary: English version, then Chinese translation
  277. directly below, then the next builder. For the podcast: English summary,
  278. then Chinese translation directly below. Like this:
  279. ```
  280. Box CEO Aaron Levie argues that AI agents will reshape software procurement...
  281. https://x.com/levie/status/123
  282. Box CEO Aaron Levie 认为 AI agent 将从根本上重塑软件采购...
  283. https://x.com/levie/status/123
  284. Replit CEO Amjad Masad launched Agent 4...
  285. https://x.com/amasad/status/456
  286. Replit CEO Amjad Masad 发布了 Agent 4...
  287. https://x.com/amasad/status/456
  288. ```
  289. Do NOT output all English first then all Chinese. Interleave them.
  290. **Follow this setting exactly. Do NOT mix languages.**
  291. ### Step 6: Deliver
  292. Read `config.delivery.method` from the JSON:
  293. **If "telegram" or "email":**
  294. ```bash
  295. echo '<your digest text>' > /tmp/fb-digest.txt
  296. cd ${CLAUDE_SKILL_DIR}/scripts && node deliver.js --file /tmp/fb-digest.txt 2>/dev/null
  297. ```
  298. If delivery fails, show the digest in the terminal as fallback.
  299. **If "stdout" (default):**
  300. Just output the digest directly.
  301. ---
  302. ## Configuration Handling
  303. When the user says something that sounds like a settings change, handle it:
  304. ### Source Changes
  305. The source list is managed centrally and cannot be modified by users.
  306. If a user asks to add or remove sources, tell them: "The source list is curated
  307. centrally and updates automatically. If you'd like to suggest a source, you can
  308. open an issue at https://github.com/zarazhangrui/follow-builders."
  309. ### Schedule Changes
  310. - "Switch to weekly/daily" → Update `frequency` in config.json
  311. - "Change time to X" → Update `deliveryTime` in config.json
  312. - "Change timezone to X" → Update `timezone` in config.json, also update the cron job
  313. ### Language Changes
  314. - "Switch to Chinese/English/bilingual" → Update `language` in config.json
  315. ### Delivery Changes
  316. - "Switch to Telegram/email" → Update `delivery.method` in config.json, guide user through setup if needed
  317. - "Change my email" → Update `delivery.email` in config.json
  318. - "Send to this chat instead" → Set `delivery.method` to "stdout"
  319. ### Prompt Changes
  320. When a user wants to customize how their digest sounds, copy the relevant prompt
  321. file to `~/.follow-builders/prompts/` and edit it there. This way their
  322. customization persists and won't be overwritten by central updates.
  323. ```bash
  324. mkdir -p ~/.follow-builders/prompts
  325. cp ${CLAUDE_SKILL_DIR}/prompts/<filename>.md ~/.follow-builders/prompts/<filename>.md
  326. ```
  327. Then edit `~/.follow-builders/prompts/<filename>.md` with the user's requested changes.
  328. - "Make summaries shorter/longer" → Edit `summarize-podcast.md` or `summarize-tweets.md`
  329. - "Focus more on [X]" → Edit the relevant prompt file
  330. - "Change the tone to [X]" → Edit the relevant prompt file
  331. - "Reset to default" → Delete the file from `~/.follow-builders/prompts/`
  332. ### Info Requests
  333. - "Show my settings" → Read and display config.json in a friendly format
  334. - "Show my sources" / "Who am I following?" → Read config + defaults and list all active sources
  335. - "Show my prompts" → Read and display the prompt files
  336. After any configuration change, confirm what you changed.
  337. ---
  338. ## Manual Trigger
  339. When the user invokes `/ai` or asks for their digest manually:
  340. 1. Skip cron check — run the digest workflow immediately
  341. 2. Use the same fetch → remix → deliver flow as the cron run
  342. 3. Tell the user you're fetching fresh content (it takes a minute or two)
README.md · README · 130 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. **English** | [中文](README.zh-CN.md)
  2. # Follow Builders, Not Influencers
  3. An AI-powered digest that tracks the top builders in AI — researchers, founders, PMs,
  4. and engineers who are actually building things — and delivers curated summaries of
  5. what they're saying.
  6. **Philosophy:** Follow people who build products and have original opinions, not
  7. influencers who regurgitate information.
  8. ## What You Get
  9. A daily or weekly digest delivered to your preferred messaging app (Telegram, Discord,
  10. WhatsApp, etc.) with:
  11. - Summaries of new podcast episodes from top AI podcasts
  12. - Key posts and insights from 26 curated AI builders on X/Twitter
  13. - Full articles from official AI company blogs (Anthropic Engineering, Claude Blog)
  14. - Links to all original content
  15. - Available in English, Chinese, or bilingual
  16. ## Quick Start
  17. 1. Install the skill in your agent (OpenClaw or Claude Code)
  18. 2. Say "set up follow builders" or invoke `/follow-builders`
  19. 3. The agent walks you through setup conversationally — no config files to edit
  20. The agent will ask you:
  21. - How often you want your digest (daily or weekly) and what time
  22. - What language you prefer
  23. - How you want it delivered (Telegram, email, or in-chat)
  24. No API keys needed — all content is fetched centrally.
  25. Your first digest arrives immediately after setup.
  26. ## Changing Settings
  27. Your delivery preferences are configurable through conversation. Just tell your agent:
  28. - "Switch to weekly digests on Monday mornings"
  29. - "Change language to Chinese"
  30. - "Make the summaries shorter"
  31. - "Show me my current settings"
  32. The source list (builders and podcasts) is curated centrally and updates
  33. automatically — you always get the latest sources without doing anything.
  34. ## Customizing the Summaries
  35. The skill uses plain-English prompt files to control how content is summarized.
  36. You can customize them two ways:
  37. **Through conversation (recommended):**
  38. Tell your agent what you want — "Make summaries more concise," "Focus on actionable
  39. insights," "Use a more casual tone." The agent updates the prompts for you.
  40. **Direct editing (power users):**
  41. Edit the files in the `prompts/` folder:
  42. - `summarize-podcast.md` — how podcast episodes are summarized
  43. - `summarize-tweets.md` — how X/Twitter posts are summarized
  44. - `summarize-blogs.md` — how blog posts are summarized
  45. - `digest-intro.md` — the overall digest format and tone
  46. - `translate.md` — how English content is translated to Chinese
  47. These are plain English instructions, not code. Changes take effect on the next digest.
  48. ## Default Sources
  49. ### Podcasts (6)
  50. - [Latent Space](https://www.youtube.com/@LatentSpacePod)
  51. - [Training Data](https://www.youtube.com/playlist?list=PLOhHNjZItNnMm5tdW61JpnyxeYH5NDDx8)
  52. - [No Priors](https://www.youtube.com/@NoPriorsPodcast)
  53. - [Unsupervised Learning](https://www.youtube.com/@RedpointAI)
  54. - [The MAD Podcast with Matt Turck](https://www.youtube.com/@DataDrivenNYC)
  55. - [AI & I by Every](https://www.youtube.com/playlist?list=PLuMcoKK9mKgHtW_o9h5sGO2vXrffKHwJL)
  56. ### AI Builders on X (26)
  57. [Andrej Karpathy](https://x.com/karpathy), [Swyx](https://x.com/swyx), [Josh Woodward](https://x.com/joshwoodward), [Boris Cherny](https://x.com/bcherny), [Thibault Sottiaux](https://x.com/thsottiaux), [Peter Yang](https://x.com/petergyang), [Nan Yu](https://x.com/thenanyu), [Madhu Guru](https://x.com/realmadhuguru), [Amanda Askell](https://x.com/AmandaAskell), [Cat Wu](https://x.com/_catwu), [Thariq](https://x.com/trq212), [Google Labs](https://x.com/GoogleLabs), [Amjad Masad](https://x.com/amasad), [Guillermo Rauch](https://x.com/rauchg), [Alex Albert](https://x.com/alexalbert__), [Aaron Levie](https://x.com/levie), [Ryo Lu](https://x.com/ryolu_), [Garry Tan](https://x.com/garrytan), [Matt Turck](https://x.com/mattturck), [Zara Zhang](https://x.com/zarazhangrui), [Nikunj Kothari](https://x.com/nikunj), [Peter Steinberger](https://x.com/steipete), [Dan Shipper](https://x.com/danshipper), [Aditya Agarwal](https://x.com/adityaag), [Sam Altman](https://x.com/sama), [Claude](https://x.com/claudeai)
  58. ### Official Blogs (2)
  59. - [Anthropic Engineering](https://www.anthropic.com/engineering) — technical deep-dives from the Anthropic team
  60. - [Claude Blog](https://claude.com/blog) — product announcements and updates from Claude
  61. ## Installation
  62. ### OpenClaw
  63. ```bash
  64. # From ClawhHub (coming soon)
  65. clawhub install follow-builders
  66. # Or manually
  67. git clone https://github.com/zarazhangrui/follow-builders.git ~/skills/follow-builders
  68. cd ~/skills/follow-builders/scripts && npm install
  69. ```
  70. ### Claude Code
  71. ```bash
  72. git clone https://github.com/zarazhangrui/follow-builders.git ~/.claude/skills/follow-builders
  73. cd ~/.claude/skills/follow-builders/scripts && npm install
  74. ```
  75. ## Requirements
  76. - An AI agent (OpenClaw, Claude Code, or similar)
  77. - Internet connection (to fetch the central feed)
  78. That's it. No API keys needed. All content (blog articles + YouTube transcripts + X/Twitter posts)
  79. is fetched centrally and updated daily.
  80. ## How It Works
  81. 1. A central feed is updated daily with the latest content from all sources
  82. (blog articles via web scraping, YouTube transcripts via Supadata, X/Twitter via official API)
  83. 2. Your agent fetches the feed — one HTTP request, no API keys
  84. 3. Your agent remixes the raw content into a digestible summary using your preferences
  85. 4. The digest is delivered to your messaging app (or shown in-chat)
  86. See [examples/sample-digest.md](examples/sample-digest.md) for what the output looks like.
  87. ## Privacy
  88. - No API keys are sent anywhere — all content is fetched centrally
  89. - If you use Telegram/email delivery, those keys are stored locally in `~/.follow-builders/.env`
  90. - The skill only reads public content (public blog posts, public YouTube videos, public X posts)
  91. - Your configuration, preferences, and reading history stay on your machine
  92. ## License
  93. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.