# I built a pipeline that scouts real pain points for me

_The bottleneck in shipping side-projects was never the building. It was me, sitting down every day to invent something worth building. So I handed that job to a pipeline._

`2026-07-01·shipped·idea-scout`

## The bottleneck was me

For a while the loop looked like this: I think of an idea, I ask Claude to research whether it's feasible, we decide. It kept stalling — not on the research, but on the first step. Generating ideas I actually believed in was slow, and every stall was mine.

So we flipped the roles. I stop being the front of the funnel. A pipeline scouts and filters; I only make the go / no-go call. The point isn't _more_ ideas — a firehose of shallow ideas is worse than none. The point is to only ever look at signal.

## What an idea needs before it earns any code

Building is cheap now. The expensive, scarce thing is knowing a real person will use the result. So every idea the pipeline surfaces has to arrive with three things attached, or it doesn't count:

- **A specific target user** — not "small businesses", but who exactly feels this.
- **A way to reach them** — the actual channel, or the idea is a fantasy.
- **A 30-minute test** — the cheapest experiment that proves demand _before_ a line of product gets written.

## How it works

The shape is deliberately boring and deterministic. Code does the fetching, deduping, and scoring; the model is only invited in at the very end to frame what the code already found.

```
sources  →  dedup  →  rank  →  claude -p  →  Telegram
(Reddit,    (state   (pain-   (frames the   (push to
 HN, PH)     file)   signal)   real signal)   my phone)
```

Each source is read for posts where people say the quiet part out loud — `I wish there was a tool`, `is there any way to`, `I do this by hand`. A state file remembers everything it has already shown me, so nothing repeats. Only then does `claude -p` get the top signals — with their source links — and turn them into framed ideas.

> Code decides what's worth reading. The model only ever reasons on top of real, fetched signal — it never gets to invent a pain point.

That last rule is the whole game. It's the same discipline I lean on everywhere: the machine can reason, but it reasons on numbers and quotes it was _handed_, never ones it made up. An idea with no source link attached is not an idea; it's a hallucination with good grammar.

## What broke

Reddit fought back. Its JSON endpoints now return `403` to anything that looks like a bot, and the RSS fallback rate-limits your IP hard — so a chunk of the richest sources (where non-developers describe everyday pain) drop out, and the ideas skew toward developer tools. Telegram bit me too: sending with Markdown means one stray `_` in scraped text returns `400 can't parse entities` and the push silently dies. Plain text fixed it.

## What I'd change next

The honest weakness right now is signal strength. RSS gives me no vote count, so a pain point voiced by one person ranks the same as one echoed by hundreds. The fix is a proper Reddit app token — not just to dodge the rate limit, but to filter for pain that _many_ people feel, not one. Fewer ideas, higher conviction. That's the trade I want.