Find people asking for what you build

---
name: "Social Demand Radar"
description: "Every day, find X and Reddit posts from the last 24 hours where people in your target segments ask for something you could build or already offer, and post the list to Slack, each post matched to your catalog when one is configured. Read-only on X and Reddit."
connection_needs:
  - "X / Twitter: search recent posts (twitter_search_recent_posts) with X recent-search syntax, including conversation_id reply mining. Read-only."
  - "Reddit research tools built into Type's managed agent (reddit/search, reddit/get_thread). Read-only; each call is a paid lookup."
  - "Slack (the Type Slack app): post one parent message and one thread reply in the alert channel."
  - "Optional: a public catalog URL (fetched with curl in the managed sandbox) or a Type document listing your offerings."
inputs:
  - "destination_space: the Space for the automation and its bundled skill"
  - "slack_connection: the Slack connection"
  - "x_connection: the X / Twitter connection"
  - "slack_channel_id: the Slack channel that receives the alert"
  - "slack_channel_name: that channel's name"
  - "demand_topic: what people are asking for (source default: AI skills, agents, custom GPTs and workflows for business)"
  - "demand_item_label: the singular noun used in the list (source default: skill)"
  - "segments: exhaustive segment definitions a post must fit (source default: B2B, Agencies, Finance/Ops, Ecommerce)"
  - "qualification_rules: the two must-pass criteria for a post (source defaults below)"
  - "x_queries: X recent-search queries grouped as broad, ask and topic-specific (source defaults below)"
  - "reddit_topic_subreddits: subreddits about the topic itself (source defaults below)"
  - "reddit_business_subreddits: subreddits where buyers discuss their work (source defaults below)"
  - "reddit_broad_queries: Reddit queries run on both subreddit sets (source defaults below)"
  - "reddit_topic_queries: Reddit queries run on topic subreddits only (source defaults below)"
  - "reddit_deep_dive_subreddit: subreddit whose top post of the day is mined for comments (source default: claudeskills)"
  - "exclusions: posts that are always out (source defaults below)"
  - "own_accounts: your company and team X handles to exclude"
  - "company_name: your company, used in the gut-check rule"
  - "reviewer_name: the person who replies to these posts"
  - "catalog_name: label for your catalog in the summary line (source default: Library)"
  - "catalog_source: optional; how to fetch your catalog (public JSON URL plus jq listing, or a Type document ID); none skips matching"
  - "catalog_link_format: optional public link pattern for catalog entries, for example https://example.com/library/<slug>"
  - "parent_message_text: exact parent message (source default: Today's posts related to skills 👇)"
  - "empty_reply_text: exact thread reply when nothing qualifies (source default: No relevant skill posts in the last 24h.)"
  - "schedule_timezone: time zone for the daily run (source default: America/Los_Angeles, 12:00)"
---

# Social Demand Radar

## Purpose

People ask in public for the exact thing a company could build or already sells, and the posts scroll away within a day. Every day this automation searches X and Reddit for posts from the last 24 hours where someone in a target segment asks for or discusses a specific {{input:demand_item_label}} ({{input:demand_topic}}), keeps only buildable, business-relevant demand, optionally matches each post to the company's catalog (existing, partial or new), and posts the list to one Slack channel: a fixed parent message plus one thread reply. It is strictly read-only on X and Reddit and never drafts replies.

The source configuration listened for AI-skill demand in four segments; it is included below as the default for teams with the same audience.

## Setup

Settle every binding before creating the automation. None inherits a value from the original workspace.

| Binding | Meaning and how to supply it |
| --- | --- |
| `{{input:destination_space}}` | Space for the automation and the bundled skill. It needs the Slack and X connections. |
| `{{input:slack_connection}}`, `{{input:x_connection}}` | Saved in `integrationAccounts`; never put connection IDs in instructions. |
| `{{input:slack_channel_id}}`, `{{input:slack_channel_name}}` | Alert channel, resolved with `slack_search_channels`. The Type Slack app must be in it. |
| `{{input:demand_topic}}`, `{{input:demand_item_label}}` | What the radar listens for, and the noun used in each list line. |
| `{{input:segments}}`, `{{input:qualification_rules}}` | The filter. Segments are exhaustive: anything outside them is dropped. |
| `{{input:x_queries}}` | X recent-search queries. Cast a wide net on vocabulary: people describe the work, not your category name. |
| `{{input:reddit_topic_subreddits}}`, `{{input:reddit_business_subreddits}}`, `{{input:reddit_broad_queries}}`, `{{input:reddit_topic_queries}}`, `{{input:reddit_deep_dive_subreddit}}` | Reddit scope. Every Reddit search passes `subreddits`. |
| `{{input:exclusions}}`, `{{input:own_accounts}}` | Always-out topics, and your own accounts. |
| `{{input:company_name}}`, `{{input:reviewer_name}}` | Used in the gut-check rule. |
| `{{input:catalog_name}}`, `{{input:catalog_source}}`, `{{input:catalog_link_format}}` | Optional catalog matching. Without a catalog, the verdict lines and summary line are omitted. |
| `{{input:parent_message_text}}`, `{{input:empty_reply_text}}` | Exact Slack texts. |
| `{{input:schedule_timezone}}` | Run time zone. The source ran every day at 12:00 America/Los_Angeles. |

### Source defaults (AI-skill demand)

Use these verbatim when the installer's audience matches; otherwise replace them with the installer's own.

**`demand_topic`:** AI skills, agents, custom GPTs, workflows and automations for business (Claude skill / SKILL.md / agent skill / custom GPT / "an AI that does X").

**`demand_item_label`:** `skill`

**`parent_message_text`:** `Today's posts related to skills 👇` · **`empty_reply_text`:** `No relevant skill posts in the last 24h.` · **`catalog_name`:** `Library`

**`segments`:**
- **B2B**: sales, outbound, CRM hygiene, lead gen/enrichment, pipeline reporting, SaaS GTM, customer success, B2B content/SEO/LinkedIn.
- **Agencies**: *marketing, creative, performance, SEO, or dev agencies only* — client reporting, campaign audits/optimization, proposals/pitches, client onboarding, multi-client account management.
- **Finance/Ops**: invoicing, bookkeeping, AP/AR, month-end close, reconciliation, forecasting, KPI/ops reporting, SOP/process documentation.
- **Ecommerce**: DTC/Shopify/Amazon store ops — performance ad analysis and creative testing, product listings/PDPs, email/SMS flows, inventory, CX/support, store analytics.

**`qualification_rules`:**
1. It is about an AI skill / agent / GPT / workflow / automation for business (not human skills, games, sports, job hunting, courses, pure dev tooling).
2. It names or clearly implies a concrete, buildable **business workflow that a serious operator would run regularly** and that connects to business data or tools (ads accounts, analytics, CRM, Shopify, Stripe/QuickBooks, Slack, Gmail, Sheets, etc.). Posts where someone is *asking how to automate* a business task count even if they haven't named a specific tool yet.

**`x_queries`:**

Broad workflow queries (highest volume):
- `("automate" OR "automation" OR "workflow") (claude OR "AI agent" OR GPT OR codex) (marketing OR sales OR ecommerce OR agency OR reporting OR ads)`
- `("AI workflow" OR "AI agent" OR "claude for" OR "GPT for") (ads OR analytics OR shopify OR clients OR invoicing OR outreach OR reporting OR CRM)`
- `("anyone using" OR "how do you" OR "is there") (claude OR "AI agent" OR GPT) (marketing OR sales OR shopify OR ads OR CRM OR email OR SEO)`

Ask queries (highest intent):
- `("need help" OR "looking for" OR "recommend" OR "anyone know") (AI OR claude OR GPT) (automate OR automation OR workflow) (business OR marketing OR agency OR ecommerce)`
- `("custom GPT for" OR "is there an agent that" OR "AI agent that can") (sales OR marketing OR ads OR shopify OR invoices OR clients OR reporting)`

Topic-specific queries (narrower, still run):
- `("claude skill" OR "claude skills" OR "agent skill" OR "SKILL.md") (marketing OR sales OR seo OR ads OR shopify OR ecommerce OR DTC OR agency OR clients OR outreach OR crm OR finance OR invoices OR bookkeeping OR reporting OR ops)`
- `("is there a skill" OR "anyone have a skill" OR "looking for a skill" OR "need a skill") (claude OR codex OR agent OR AI OR GPT)`

**Reddit:**
- `reddit_topic_subreddits`: claudeskills, ClaudeAI, ClaudeCode, AI_Agents, ChatGPTPro, ChatGPT, OpenAI, automation, n8n, PromptEngineering
- `reddit_business_subreddits`: ecommerce, shopify, PPC, marketing, agency, digital_marketing, SaaS, sales, Accounting, smallbusiness, Entrepreneur, startups
- `reddit_broad_queries`: `automate claude AI workflow` · `"AI agent" OR "AI workflow" automate business` · `claude workflow automation marketing sales` · `"GPT for" OR "AI for" marketing sales ads reporting`
- `reddit_topic_queries`: `"claude skill"`, `"agent skill"`, `"skill for"`, `"SKILL.md"`
- `reddit_deep_dive_subreddit`: claudeskills

**`exclusions`:**
- **Legal, medical, real estate, education/tutoring, recruiting/job applications** — not our segments, even if the poster is a "professional services firm".
- **Novelty or gimmick creative**: cartoon/animated ads, singing/song ads, memes, AI influencers, "viral video in one prompt", avatar/UGC-faking tools. Ad *analysis, testing, and reporting* is in; toy content generators are out.
- Generic "list of 100+ skills" roundups, skill-repo hype threads, and philosophical "are skills useful?" debates.
- Crypto/trading, pure dev tooling (IDE, CLI, debugging, code style, design-to-code), personal/hobby, spam/affiliate, course ads, bots (@grok etc.).

**`catalog_source`** (source shape): a public skills-library JSON endpoint fetched once per run without auth, saved to a file, and listed with jq as `slug | title | businessTypes | summary`; links built as `https://<your-site>/library/skills/<slug>`.

**Create the bundled skill first** with `create_space_skill` (name `Social Demand Radar`, the description from the frontmatter below, and the SKILL.md content with every placeholder filled). Then **create the automation** with `create_task`: the instructions under Reference implementation, `scheduleConfig: { mode: "specific_time", time: "12:00", days: all seven, timezone: {{input:schedule_timezone}} }`, `integrationAccounts` for Slack and X, and `skillReferences` for the new skill. It is agent-only (`agentModeReason`: deciding which posts express real, buildable demand in a segment is judgment; searching is incidental). Create it paused and enable it after review.

## Triggers and execution

Instruction (agent-only) automation, scheduled every day at 12:00 in `{{input:schedule_timezone}}`. No model or run settings are configured in the source (agent defaults). It loads the bundled `social-demand-radar` skill. No code stage.

## Workflow

1. **X (last 24h).** Run every configured query with `twitter_search_recent_posts`, appending ` -is:retweet lang:en`, following `nextToken` for up to 3 pages, and discarding posts older than 24h.
2. **Reply mining.** For the 5 highest-engagement posts (≥10 replies) where someone shares a {{input:demand_item_label}} or something similar, search `conversation_id:<id> -is:retweet` and keep replies asking for it or a variant.
3. **Spam filter.** Drop coordinated promo blasts (5+ near-identical posts from different accounts within hours), bot accounts, and launch announcements with no user discussion.
4. **Reddit (last 24h).** `reddit/search` with `timeFilter: "day"`, `sort: "new"`, always with `subreddits`, `maxResults` ≤10; comments for topic subs, posts for business subs. Pull up to 50 top comments of the day's top post in the deep-dive subreddit (`reddit/get_thread`; at most 3 `get_thread` calls per run).
5. **Filter.** Keep a post only if it meets both qualification rules, fits a segment, and passes the gut check ("Would {{input:reviewer_name}} be proud to reply with a {{input:company_name}} {{input:demand_item_label}}, and would the poster's business plausibly pay?"). Apply every exclusion. ASK posts before TALK posts; TALK only with clear demand. Dedupe same author and same ask across platforms. **Max 15 posts.**
6. **Catalog match (optional).** Fetch the catalog once; verdict per post: ✅ Existing (link), 🟡 Partial (closest link + missing piece in ≤6 words), 🆕 New (proposed name ≤5 words). Never invent links. A failed fetch marks every post `❓ Catalog unavailable`.
7. **Slack.** Exactly two messages: the parent `{{input:parent_message_text}}`, then one thread reply with the numbered list (`<URL> — <implied {{input:demand_item_label}}, ≤8 words> · <Segment>`, plus the verdict line) and the summary `{{input:catalog_name}}: X existing · Y partial · Z new`. If nothing qualifies, the thread reply is `{{input:empty_reply_text}}`.

## State and failure behavior

- No stored state; each run covers the trailing 24 hours.
- The parent message is posted every run, including empty days; the thread reply always follows it.
- Catalog failures are labeled per post rather than guessed; no link is ever invented.
- Oversized tool results are read from the saved file in the sandbox rather than retried at a larger size (see the skill's operational notes).
- Nothing is ever posted, liked, replied to or voted on X or Reddit, and no reply copy is drafted.

## Integration data and capabilities

| Integration | Data and capabilities used | Relevant semantics |
| --- | --- | --- |
| X / Twitter | `twitter_search_recent_posts` (X recent-search syntax, `nextToken` paging, `conversation_id:` reply mining); post `createdAt`, author username, status ID, engagement counts. | ~10 posts per call. A bare `?` token in a query can cause an HTTP 400. Large results spill to `~/.type-tool-results/` (`.structuredContent.posts`). |
| Reddit (Type managed agent tools) | `reddit/search` (`subreddits`, `timeFilter`, `sort`, `contentType`, `maxResults`), `reddit/get_thread` (`sort: "top"`, `maxComments`); permalinks. | Paid lookups. Bodies are long; keep result sizes small and one `contentType` per call. |
| Slack (Type Slack app) | `slack_post_message` (`channel_id`, `text`, `thread_ts`); the parent `ts` threads the reply. | Exactly two messages per run. |
| Catalog (optional) | A public JSON endpoint fetched with `curl` in the sandbox and listed with `jq`, or a Type document. | Read once per run; links built from the configured format. |

## Reference implementation

### Automation instructions

Original provider assumptions: the X / Twitter connection, Type's built-in Reddit tools, Slack tools from the Type Slack app, and the bundled skill below. **Reuse when these assumptions hold; adapt when they do not, preserving the behavior above.**

```text
Run the Social Demand Radar skill (/social-demand-radar) for the last 24 hours across X and Reddit. Follow its search, reply-mining, and strict segment filter (only the segments in its configuration).

Then post to Slack using service "slack", tool "slack_post_message", channel_id "{{input:slack_channel_id}}" ({{input:slack_channel_name}}):
1. Parent message, exact text: "{{input:parent_message_text}}"
2. One threaded reply (thread_ts = the parent's ts) with the numbered list of URLs, each followed by " — <implied {{input:demand_item_label}}> · <Segment>". If nothing qualifies, reply in the thread: "{{input:empty_reply_text}}"

Post exactly these two Slack messages and nothing else. Read-only on X and Reddit: never post, reply, like, or vote there.

/social-demand-radar
```

### Bundled skill: `social-demand-radar` (`SKILL.md`)

The source skill with the topic, segments, queries, exclusions, accounts, catalog and Slack texts made configurable; the procedure, caps, formats and operational notes are unchanged.

````markdown
---
name: social-demand-radar
description: "Social listening on X and Reddit for posts from the last 24 hours that ask for or discuss {{input:demand_topic}}, filtered to the configured segments. Posts the URLs to Slack as \"{{input:parent_message_text}}\" with the list in the thread, optionally matched to the {{input:catalog_name}}. Read-only on X and Reddit. Use when the scheduled alert fires or when asked to run the demand radar."
---

# Social Demand Radar

Goal: surface fresh posts on **X** and **Reddit** where someone is **asking for, looking for, or talking about a specific {{input:demand_item_label}}** ({{input:demand_topic}}) **that is relevant to one of the configured segments.** {{input:reviewer_name}} uses the list to build the {{input:demand_item_label}} or point to an existing {{input:company_name}} offering, and reply with it.

There is no fixed list. Discover the demand, then filter by segment.

Read-only on X and Reddit: never post, reply, like, quote, or vote. LinkedIn is out of scope.

## Configuration (filled at setup)

**Segments** (these definitions are exhaustive; anything else is out):
{{input:segments}}

**Qualification rules** (criteria 1 and 2 of the filter):
{{input:qualification_rules}}

**X queries:**
{{input:x_queries}}

**Reddit:**
- Topic subs (call A): {{input:reddit_topic_subreddits}}
- Business subs (call B): {{input:reddit_business_subreddits}}
- Broad queries (run on both sets): {{input:reddit_broad_queries}}
- Topic-specific queries (topic subs only): {{input:reddit_topic_queries}}
- Daily deep-dive subreddit: r/{{input:reddit_deep_dive_subreddit}}

**Always exclude:**
{{input:exclusions}}
- Our own accounts: {{input:own_accounts}}

**Catalog** (optional): {{input:catalog_source}}. Public link format: `{{input:catalog_link_format}}`.

## 1. Search X (last 24h)

Tool: `twitter` integration → `twitter_search_recent_posts` (via `find_tools` service `twitter`).

The tool returns ~10 posts per call. For each query, follow `nextToken` for up to 3 pages. Append ` -is:retweet lang:en` to every query. Discard anything with `createdAt` older than 24h.

Most people asking for this do NOT use our category's own word for it; they describe the work they want done. Cast a wide net on vocabulary: run every configured X query (broad, ask, and topic-specific).

Reply mining (often the best signal): take the 5 highest-engagement posts found above (someone sharing a {{input:demand_item_label}} or something similar, ≥10 replies). For each, search `conversation_id:<id> -is:retweet` and keep replies that ask for it or a variant ("link?", "is there one for…", "does this work for…", "need this for my agency/store").

Spam filter: discard coordinated promo blasts (5+ near-identical posts from different accounts promoting the same product within hours). Discard bot accounts and pure product launch announcements with no user discussion.

## 2. Search Reddit (last 24h)

Tool: `reddit/search` with `timeFilter: "day"`, `sort: "new"`. Always pass `subreddits`; unscoped searches are pure noise. Keep `maxResults` ≤ 10 per call (bodies are long). Prefer `contentType: "comments"` for topic subs, `"posts"` for business subs.

Run the broad queries on both subreddit sets and the topic-specific queries on the topic subs only.

Also pull comments on the top post of the day in r/{{input:reddit_deep_dive_subreddit}} (`reddit/get_thread`, `sort: "top"`, `maxComments` 50) and keep comments asking for a {{input:demand_item_label}} or workflow. Cap: 3 `get_thread` calls per run.

## 3. Filter (selective)

Be selective but cast a wide net on vocabulary. Most people don't use our jargon; accept the everyday words for the same need as equivalent signal.

Keep a post only if ALL are true:
1–2. It meets both qualification rules in the configuration.
3. It fits at least one configured segment.
4. Gut check: "Would {{input:reviewer_name}} be proud to reply to this post with a {{input:company_name}} {{input:demand_item_label}}, and would the poster's business plausibly pay for {{input:company_name}}?" If not, drop it.

Always exclude everything in the configured exclusion list, including our own accounts.

Prioritize ASK (explicitly seeking a {{input:demand_item_label}}) over TALK (showcasing/discussing one). Include TALK posts only if they show clear demand (lots of replies asking for it). Dedupe same author/same ask across platforms. Max 15 posts.

## 3b. Match each post to the catalog (only when a catalog is configured)

Fetch the catalog once per run, as configured above. Save large responses to a file and list only slug/title/segments/summary.

For each kept post, compare the implied {{input:demand_item_label}} against the catalog entries and pick one verdict:
- **✅ Existing** — a published entry already does what the poster asked. Link it.
- **🟡 Partial** — an entry covers part of it; link the closest one and name the missing piece in ≤6 words.
- **🆕 New** — nothing covers it. Propose a name (≤5 words).

Be honest: only call it Existing if {{input:reviewer_name}} could reply with that link today without caveats. Never invent links; every linked entry must exist in the fetched catalog. If the catalog fetch fails, mark every post `❓ Catalog unavailable` instead of guessing. Without a configured catalog, skip this step and omit the verdict lines and the summary line below.

## 4. Post to Slack

Channel: {{input:slack_channel_name}} (`{{input:slack_channel_id}}`), via `slack` → `slack_post_message`.

1. Post the parent message with exactly this text: `{{input:parent_message_text}}`
2. Take the `ts` from that response and post ONE threaded reply (`thread_ts` = that ts) listing the URLs, ordered ASK first then TALK:

```
1. https://x.com/<username>/status/<id> — <implied {{input:demand_item_label}}, ≤8 words> · <Segment>
   ✅ Existing: <catalog link>
2. https://www.reddit.com/r/<sub>/comments/... — <implied {{input:demand_item_label}}> · <Segment>
   🟡 Partial: <catalog link> (missing: <gap>)
3. https://x.com/... — <implied {{input:demand_item_label}}> · <Segment>
   🆕 New {{input:demand_item_label}} needed: <proposed name>
...
```

End the thread reply with one summary line: `{{input:catalog_name}}: X existing · Y partial · Z new`.

URL formats: X → `https://x.com/<username>/status/<id>`; Reddit → `https://www.reddit.com<permalink>`.

If nothing qualifies, still post the parent message and reply in thread: `{{input:empty_reply_text}}`

Post exactly two Slack messages per run (parent + one thread reply). Do not post anything else to the channel. Do not draft reply copy.

## Operational notes

- Reddit search with `contentType: "both"` (or posts at `maxResults` 10) can exceed the tool output limit; use one `contentType` per call with `maxResults` ≤5 for topic subs.
- Oversized `call_tool` results (for example X search at `maxResults` 50) are saved under `~/.type-tool-results/` and are readable with managed-sandbox `exec_command`; posts are at `.structuredContent.posts` (jq).
- Reddit queries combining quoted phrases with OR plus `sort: "new"` returned unrelated newest items; use one quoted phrase per call with `sort: "relevance"` and `timeFilter: "day"`.
- Business-sub Reddit post searches can overflow unreadably even at `maxResults` 2; use `contentType: "comments"` there.
- An X HTTP 400 citing a rate-limit reset came from a bare `?` query token; the query without it worked.
- Run the core X queries and reply mining first. Reply mining fits in one X call by OR-ing 5 `conversation_id:` terms at `maxResults` 100.
````

## Verification

**Examples derived from the source rules (not executed against live accounts):**

- A post from one of your own accounts: excluded.
- Five near-identical promotional posts from different accounts within hours: all dropped as a promo blast.
- A post asking for help automating month-end close: kept under the Finance/Ops segment (source defaults), ASK priority.
- A real-estate firm asking for an AI agent: dropped (excluded segment), even though it is a business.
- Nothing qualifies: the parent message is still posted, followed by the thread reply `{{input:empty_reply_text}}`.
- The catalog fetch fails: each kept post shows `❓ Catalog unavailable`; no links are guessed.

**Proposed acceptance checks after installation:**

1. Run once in a test channel; confirm exactly two Slack messages (parent + one thread reply) and no activity on X or Reddit.
2. Confirm every listed post is from the last 24 hours, fits a configured segment, and appears at most once across platforms.
3. With a catalog configured, confirm every ✅ or 🟡 link resolves to a real entry; break the catalog URL and confirm the `❓ Catalog unavailable` label.
4. Confirm the list never exceeds 15 posts and ASK posts come before TALK posts.