The idea started from a realization, not a project brief: Reddit is sitting on a genuine trove of user feedback and feature requests, threads full of people describing exactly what's broken and what they wish existed, and I kept wondering how much of that companies actually mine versus just letting it scroll past. That curiosity generalized fast to wearables specifically, a category I already track closely. The first real-world test was concrete: prepping for an upcoming Whoop Sleep PM interview, I ran the tool against r/whoop for sleep-tracking and battery-life signal, ranked and sourced, instead of skimming hundreds of threads by hand.

Two rules shaped everything from day one. First, the output had to be synthesized, not republished: paraphrased summaries with links back to the source thread, never Reddit comments lifted verbatim into a report. Second, the tool had to run on infrastructure I already had. No second API key, no separate billing relationship, no waiting on Reddit's developer-app approval queue before I could pull a single post.

Three decisions that weren't the default

Reddit blocks anonymous requests to its own JSON endpoints, and I did not have Data API access yet, so the client authenticates with a cookie copied out of a logged-in browser session instead of OAuth. It works, it is a little fragile since the cookie needs re-copying periodically, and swapping it for PRAW once Reddit approves my API access is the one piece of the architecture I already know I will rebuild.

Classification runs through the local claude CLI instead of the Anthropic API. I batch many posts into a single claude -p call and ask for structured JSON back per item: relevance, theme labels, sentiment, intensity, confidence, a short paraphrase. This runs on my existing Claude Pro subscription instead of opening a second pay-per-token account, and I stripped the system prompt down to a minimal override, because the default Claude Code system prompt costs something like 180,000 cached tokens per call. That is not a tidiness choice, that is a cost problem.

The third decision was about scope, not infrastructure. My original plan was open-ended: discover a theme taxonomy across a whole subreddit with no target topic in mind. Partway through the build I cut that in favor of a topic flag that judges relevance against one specific concern, because the actual thing I needed was sleep-tracking and battery-life signal, not a general survey. I did not throw the open-ended idea away, I just wrote it into the README roadmap and came back to it later.

Proving it against real data

The pipeline is four stages, pull, classify, aggregate, report, each independently rerunnable and connected by JSONL files on disk instead of in-memory state, so a crash mid-run never costs me work that already finished. Pull fetches posts and comments in a time window and can resume where a previous run left off. Aggregate scores each theme on frequency, unique voices, upvotes, recency, and average sentiment intensity, with recency weighted softly on purpose: a complaint that has been showing up for a year does not get zeroed out just for not being from this week.

Before I did anything with polish, I ran it for real. A pull against r/whoop brought in 1,110 items, classification marked 715 of them relevant to sleep tracking and battery life, and the merged report across five combined pull runs became the actual brief I used to prep for that interview. That was the test that mattered.

Building the second feature properly

The open-ended discovery mode I had deferred earlier came back once I had the room to build it properly: a real spec-to-merge process instead of another quick pass at the code. That meant clarifying questions first, then a proposed design broken into sections with a checkpoint after each one, then a written spec with eight concrete decisions in it. Things like: discover the taxonomy in one pass over a random sample, then classify everything else against that fixed result. Keep it behind an explicit discover flag instead of quietly making the topic flag optional, because self-documenting behavior mattered more than a slightly shorter command. Always keep an Other catch-all theme so nothing silently falls through.

I broke the plan into six TDD tasks and had fresh subagents implement them one at a time, in an isolated git worktree that never touched main until the whole thing passed review. Every one of those six tasks passed its own review clean, no blocking findings. The value showed up somewhere else: a final whole-branch review, deliberately run on the most capable model available since it was the last checkpoint before merge, caught three real bugs that none of the six task-level reviews could have seen on their own, because each one only became visible once you read the pieces together.

One was a dead abort guard: the discovery function always appended the Other theme before returning, so even a fully failed discovery pass returned something that looked valid, and the safety check meant to catch that never fired. Another was a stale taxonomy bug: re-classifying a run directory that had previously used discovery mode left the old taxonomy file sitting on disk, and since reports auto-load whatever taxonomy file they find, a later topic-scoped run could show a legend describing themes nothing was actually classified against. The third was a target that only worked on paper: I had asked the model for fifteen to thirty themes per batch, not per run, so a real pull with eight batches could realistically merge into over a hundred themes instead of the handful the spec intended.

I fixed all three, re-reviewed the fixes specifically rather than re-running the whole review, and merged. Forty-one tests passing, up from twenty-two at the start of that phase.

What this project actually taught me

The build itself was mostly Python I already knew how to write. What I got real practice with was structuring an agentic build so that review catches things review is supposed to catch: task-scoped review for correctness within a task, a whole-branch review for the seams between tasks, and treating eight decisions written down before coding as cheaper than finding out the hard way three tasks deep. That discipline is the part of this project I would reuse on something that has nothing to do with Reddit.

The tool does two real things now. It answers a scoped question, what are people saying about sleep tracking on r/whoop, and it answers an open one, what is this subreddit actually talking about with no topic given, and both paths are documented and shipped rather than one finished feature next to one half-built idea. What is left open is small and known: swap the cookie for OAuth once Reddit approves my API access, reconcile taxonomies across separately discovered runs, which right now has a documented workaround instead of a real fix, and give the README a pass so it reads like something written for someone other than me.

Code is on GitHub at reddit-product-feedback-miner, MIT licensed.