Every hour on launch day: Product Hunt rank and votes, Hacker News rank, Reddit score, GitHub stars, and the visits, sign-ups and payments each one sent.
Reads
You get
The card on the right is a sample. Yours shows your own numbers and updates in place every run.
What lands on your board
HN front page at 09:40: 312 visits, 19 sign-ups, 2 paid. Product Hunt rank 4, 280 upvotes: 268 visits, 4 sign-ups. 3 Product Hunt comments wait for a maker reply.
On launch day a founder has six tabs open: the Product Hunt page, the Hacker News thread, a Reddit post, GA4 Realtime, the GitHub repo and Stripe. Each one shows its own number, and none of them answers the question that decides where to spend the afternoon: which channel is sending people who sign up?
Every hour the agent reads all six, puts each channel's public signal (rank, votes, points, stars) on one clock with the visits, sign-ups and payments that came from it, and lists the Product Hunt comments still waiting for a maker reply. It runs for one day; remove the routine when the launch is over.
POST to https://api.producthunt.com/v2/api/graphql with post(slug: "<slug>") { votesCount commentsCount dailyRank makers { id } comments(first: 50, order: NEWEST) { edges { node { id body createdAt userId replies(first: 20) { edges { node { userId } } } } } } }. A top-level comment not written by a maker waits for a reply when no reply's userId belongs to a maker. Cross-check the rank with posts(postedAfter: <today 00:00 Pacific>, order: RANKING, first: 20).
Find the HN story with https://hn.algolia.com/api/v1/search_by_date?query=<domain>&restrictSearchableAttributes=url&tags=story, then GET /v0/item/<id>.json for score and descendants; its rank is its position in /v0/topstories.json (1 to 30 is the front page). For Reddit, GET /api/info?url=<launch URL> or the post IDs you named, for score and num_comments.
GA4 runReport for today with dimensions: ["dateHour", "sessionSource"] and sessions, plus eventCount filtered to eventName == "sign_up" (the Realtime API has no source dimension). GitHub: gh api repos/{owner}/{repo} --jq .stargazers_count. Stripe: Checkout Sessions with status=complete created today, with metadata.utm_source and created.
Convert all timestamps to Pacific time (Product Hunt's day) and bucket by hour. Map sources to channels by domain: producthunt to Product Hunt, ycombinator to Hacker News, reddit to Reddit, github.com to GitHub; sign-ups and payments with no source go to "Direct / unknown" and are never split across channels. Mark when each channel's signal changed (HN rank first at 30 or better, PH rank change) and find the minute visits jumped with dateHourMinute.
Read the previous card with GET https://briefkin.dev/v1/cards/insight-product-hunt-launch-day-cockpit and state what changed since it. GA4 fills earlier hours in late, so re-read the whole day each run rather than adding hours up. Never suggest asking anyone for upvotes; Product Hunt's rules forbid it.
With BRIEFKIN_TOKEN set, the agent sends the result as one card that updates in place every run. Without it, you get the report in the chat.
Pick your agent, where the data comes from and how to schedule it; the commands below follow.
One command. It puts the SKILL.md in ~/.claude/skills and in ~/.agents/skills, which Codex, Cursor, Gemini CLI, Copilot CLI and OpenCode read too.
shellcurl -fsSL https://briefkin.dev/skills/product-hunt-launch-day-cockpit/install | shAsk Claude Code:
promptRun the product-hunt-launch-day-cockpit skillOr paste the prompt instead of installing:
promptIt is my launch day. Using the Product Hunt GraphQL API (post by slug: votesCount, commentsCount, dailyRank, makers, comments with replies), the Hacker News Algolia and Firebase APIs (my story's score and its position in topstories), Reddit (score of my post), GA4 runReport for today by dateHour and sessionSource (sessions, and sign_up events), my GitHub repo's star count and Stripe Checkout Sessions completed today with metadata.utm_source: give me a table per channel with its current rank or score, visits, sign-ups and payments since midnight Pacific, a short timeline of when each channel's rank changed and when its visits jumped, and the Product Hunt comments with no maker reply. Put sign-ups with no source under Direct / unknown. Tell me the one thing to do this hour. Do not suggest asking for upvotes.Every hour on launch day, from cron on any machine where Claude Code is signed in:
crontab0 * * * * claude -p "Run the product-hunt-launch-day-cockpit skill"Add it with crontab -e. A laptop asleep at that time runs it when it wakes if you use launchd or Task Scheduler instead; GitHub Actions works for the API route.
Connect Briefkin once with curl -fsSL https://briefkin.dev/install | sh and every run lands on your board as a report card. How setup works
SKILL.md---
name: product-hunt-launch-day-cockpit
description: "Every hour on launch day: Product Hunt rank and votes, Hacker News rank, Reddit score, GitHub stars, and the visits, sign-ups and payments each one sent. Use when the user asks for this, or when it runs on a schedule."
---
# Launch day cockpit: Product Hunt, Hacker News, Reddit, analytics and sales
Every hour on launch day: Product Hunt rank and votes, Hacker News rank, Reddit score, GitHub stars, and the visits, sign-ups and payments each one sent.
On launch day a founder has six tabs open: the Product Hunt page, the Hacker News thread, a Reddit post, GA4 Realtime, the GitHub repo and Stripe. Each one shows its own number, and none of them answers the question that decides where to spend the afternoon: which channel is sending people who sign up?
Every hour the agent reads all six, puts each channel's public signal (rank, votes, points, stars) on one clock with the visits, sign-ups and payments that came from it, and lists the Product Hunt comments still waiting for a maker reply. It runs for one day; remove the routine when the launch is over.
## Two ways to get the data
Use the API or MCP route when you have an MCP server, a CLI or an API token for the app. Otherwise, if you can drive a browser the user is signed in to (Claude in Chrome, a Playwright or Chrome DevTools MCP server), use the browser route. Say which one you used.
## Route A: API or MCP server
### What you need
- A Product Hunt developer token in `PRODUCTHUNT_TOKEN` and the launch's slug; the HN item ID and Reddit post URLs once they exist (or the launch URL to search for).
- A GA4 `sign_up` event with Viewer on the property, a Stripe checkout that stores `utm_source` (or `ref`) in Checkout Session metadata, and `gh` signed in for the star count.
- A routine that runs every hour on launch day only. Delete it, or set its schedule to off, when the day ends.
If something is missing, say what and stop; do not invent numbers.
### Steps
1. **Read the Product Hunt launch** (Product Hunt): POST to `https://api.producthunt.com/v2/api/graphql` with `post(slug: "<slug>") { votesCount commentsCount dailyRank makers { id } comments(first: 50, order: NEWEST) { edges { node { id body createdAt userId replies(first: 20) { edges { node { userId } } } } } } }`. A top-level comment not written by a maker waits for a reply when no reply's `userId` belongs to a maker. Cross-check the rank with `posts(postedAfter: <today 00:00 Pacific>, order: RANKING, first: 20)`.
2. **Read Hacker News and Reddit** (Hacker News): Find the HN story with `https://hn.algolia.com/api/v1/search_by_date?query=<domain>&restrictSearchableAttributes=url&tags=story`, then `GET /v0/item/<id>.json` for `score` and `descendants`; its rank is its position in `/v0/topstories.json` (1 to 30 is the front page). For Reddit, `GET /api/info?url=<launch URL>` or the post IDs you named, for `score` and `num_comments`.
3. **Get visits, sign-ups, stars and payments** (Google Analytics): GA4 `runReport` for today with `dimensions: ["dateHour", "sessionSource"]` and `sessions`, plus `eventCount` filtered to `eventName == "sign_up"` (the Realtime API has no source dimension). GitHub: `gh api repos/{owner}/{repo} --jq .stargazers_count`. Stripe: Checkout Sessions with `status=complete` created today, with `metadata.utm_source` and `created`.
4. **Put every channel on one clock**: Convert all timestamps to Pacific time (Product Hunt's day) and bucket by hour. Map sources to channels by domain: `producthunt` to Product Hunt, `ycombinator` to Hacker News, `reddit` to Reddit, `github.com` to GitHub; sign-ups and payments with no source go to "Direct / unknown" and are never split across channels. Mark when each channel's signal changed (HN rank first at 30 or better, PH rank change) and find the minute visits jumped with `dateHourMinute`.
5. **Compare with the last hour and post**: Read the previous card with `GET https://briefkin.dev/v1/cards/insight-product-hunt-launch-day-cockpit` and state what changed since it. GA4 fills earlier hours in late, so re-read the whole day each run rather than adding hours up. Never suggest asking anyone for upvotes; Product Hunt's rules forbid it.
## Route B: the browser
### What you need
- Signed in to Product Hunt as a maker of the launch, to GA4 with Viewer access, to GitHub, and to Stripe with a role that can view payments.
If something is missing, say what and stop; do not invent numbers.
### Steps
Start at https://www.producthunt.com/. The user is signed in already; never type passwords or codes, and ask if a sign-in page appears.
1. **Read Product Hunt**: On the homepage, find your launch in today's list and note its position and upvotes. Open its page, read the comment thread, and note each top-level comment with no reply from anyone marked as a maker.
2. **Read Hacker News and Reddit**: Open `https://news.ycombinator.com/` and look for your story on the first page (its number is the rank); if it is not there, open your story's page for points and comments. Open your Reddit post and note its score and comment count.
3. **Read visits and sign-ups by source**: In `https://analytics.google.com/`, open **Reports > Acquisition > Traffic acquisition**, set the date to **Today**, switch the primary dimension to **Session source**, and read Sessions and the `sign_up` event count per source. Glance at **Reports > Realtime** for the last 30 minutes.
4. **Read stars and payments**: Open the GitHub repo and note the star count against the morning's. In the Stripe Dashboard, open **Payments** filtered to today and read the source metadata your checkout sets on each one.
5. **Line them up**: Group sources by channel (Product Hunt, Hacker News, Reddit, GitHub, Direct / unknown), give each channel its rank or score beside visits, sign-ups and payments, and note what changed since the last check.
Note: The browser route is one snapshot per run, so the timeline is only as fine as how often you ask. GA4's Traffic acquisition for Today lags a few hours; Realtime is current but covers 30 minutes. Product Hunt's homepage order can differ slightly from the API's daily rank while votes are being counted.
## The report
- **Channel table**: visits, sign-ups and payments since launch per channel, beside its rank, votes or points.
- **Timeline**: when each channel's signal changed and when its visits jumped.
- **Waiting**: Product Hunt comments with no maker reply.
- **Since last hour**: rank, votes and sign-ups that moved.
- One thing to do now, for example "Reply to the 3 open Product Hunt comments; HN is doing the converting".
## Post it to Briefkin
When `BRIEFKIN_TOKEN` is set, or `~/.config/briefkin/env` exists (the installer from https://briefkin.dev/docs writes it), also send the result to the user's Briefkin board as one card. Keep the `item_key` the same on every run so the card updates in place, use a new `event_id` per run, and put today's real numbers in place of the example ones. If the request fails, say so once and carry on.
```bash
[ -n "${BRIEFKIN_TOKEN:-}" ] || . ~/.config/briefkin/env
curl -sS -X POST "${BRIEFKIN_URL:-https://briefkin.dev}/v1/events" \
-H "authorization: Bearer $BRIEFKIN_TOKEN" \
-H "content-type: application/json" \
-d @- <<'JSON'
{
"v": 1,
"event_id": "product-hunt-launch-day-cockpit/<date of this run, e.g. 2026-10-16>",
"item_key": "product-hunt-launch-day-cockpit",
"project": "Acme",
"source": "Launch day cockpit: Product Hunt, Hacker News, Reddit, analytics and sales skill",
"kind": "update",
"title": "HN front page sent 19 sign-ups; Product Hunt 4",
"summary": "HN front page at 09:40: **312 visits, 19 sign-ups, 2 paid**. Product Hunt rank 4, 280 upvotes: **268 visits, 4 sign-ups**. 3 Product Hunt comments wait for a maker reply.",
"widget": [
{
"type": "Table",
"props": {
"columns": [
"Channel",
"Now",
"Visits",
"Sign-ups",
"Paid"
],
"align": [
"left",
"left",
"right",
"right",
"right"
],
"rows": [
[
"Hacker News",
"Rank 7, 146 points",
312,
19,
2
],
[
"Product Hunt",
"Rank 4, 280 upvotes",
268,
4,
0
],
[
"Reddit r/SaaS",
"41 points, 18 comments",
74,
3,
0
],
[
"GitHub",
"+58 stars today",
41,
0,
0
],
[
"Direct / unknown",
"",
149,
2,
1
],
[
"All",
"",
844,
28,
3
]
]
}
},
{
"type": "Log",
"props": {
"lines": [
{
"time": "00:01",
"text": "Product Hunt launch live",
"level": "info"
},
{
"time": "07:15",
"text": "Show HN posted",
"level": "info"
},
{
"time": "09:40",
"text": "HN front page (rank 22); HN visits jump from 4 to 61 in ten minutes",
"level": "ok"
},
{
"time": "11:20",
"text": "Reddit post in r/SaaS",
"level": "info"
},
{
"time": "12:00",
"text": "Product Hunt rank 5 to 4; 3 comments still without a maker reply",
"level": "warn"
}
]
}
}
]
}
JSON
```
Widgets come from the Briefkin catalog (https://briefkin.dev/v1/catalog). Without a token, just give the user the report.
## Run it on a schedule
Suggested: Every hour on launch day (`0 * * * *`). From cron, with the agent signed in on that machine:
```bash
0 * * * * claude -p "Run the product-hunt-launch-day-cockpit skill"
# Codex: codex exec, Gemini CLI: gemini -p, Copilot CLI: copilot -p, OpenCode: opencode run
```
Or use the agent's own scheduler (Claude Code routines, Codex automations, Claude or ChatGPT scheduled tasks): https://briefkin.dev/skills/product-hunt-launch-day-cockpit#schedule
Source: https://briefkin.dev/skills/product-hunt-launch-day-cockpit
A Product Hunt developer token in PRODUCTHUNT_TOKEN and the launch's slug; the HN item ID and Reddit post URLs once they exist (or the launch URL to search for).
A GA4 sign_up event with Viewer on the property, a Stripe checkout that stores utm_source (or ref) in Checkout Session metadata, and gh signed in for the star count.
A routine that runs every hour on launch day only. Delete it, or set its schedule to off, when the day ends.
https://www.producthunt.com/v2/oauth/applications, add an application (any redirect URL works for a personal token), and copy the Developer Token from the application page. Store it in PRODUCTHUNT_TOKEN and send it as Authorization: Bearer $PRODUCTHUNT_TOKEN with a POST of the GraphQL query.The developer token reads public data as you and cannot post or vote. The API is rate limited by query complexity, so poll once an hour, not every minute.
HN_QUERIES (for example acme,acme.com,"Acme CLI"). An agent with web access can also fetch the URLs above directly.There is no account or token to scope; keep the list of terms short and the schedule daily rather than hourly.
reddit.com/prefs/apps, store REDDIT_CLIENT_ID, REDDIT_CLIENT_SECRET and REDDIT_USER_AGENT (for example brand-digest/1.0 by u/yourname), and request only the read scope.A token with only the read scope can't post, comment, vote or send messages. Keep the schedule modest, daily rather than every few minutes, since Reddit rate-limits each client.
analytics-mcp on PyPI, source). It runs locally with pipx run analytics-mcp, offers run_report, run_realtime_report and get_account_summaries, and Google labels it experimental.GOOGLE_APPLICATION_CREDENTIALS at its JSON key. The skill also reads GA4_PROPERTY_ID.gcloud auth application-default login --scopes https://www.googleapis.com/auth/analytics.readonly,https://www.googleapis.com/auth/cloud-platform --client-id-file=client.json gives the MCP server or a script your user's access without a key file.Request only analytics.readonly and keep the service account at Viewer: none of these reports needs Editor.
https://api.githubcopilot.com/mcp/. Sign in with OAuth or a personal access token; add /readonly to the URL, or use a toolset URL such as https://api.githubcopilot.com/mcp/x/pull_requests/readonly, to expose only read tools. It also runs locally (source).gh CLI. Run gh auth login once, or set GH_TOKEN for scheduled runs. gh pr list --search "review-requested:@me" --json number,title,url,createdAt and gh api repos/{owner}/{repo}/dependabot/alerts cover most reports.GITHUB_TOKEN, limit it to the repositories in the report, and grant Read on Metadata, Contents, Pull requests and Issues, plus Dependabot alerts if you report on them.With every permission on a fine-grained token set to Read, the agent can't push, merge, comment or close anything.
https://mcp.stripe.com. Add Stripe from Claude's connector directory, or run claude mcp add --transport http stripe https://mcp.stripe.com/, and sign in with OAuth; clients without OAuth can send a restricted key as a Bearer token.stripe login once, then stripe subscriptions list --status active --limit 100 or stripe invoices list --status open. The CLI defaults to test mode, so add --live for real data.rk_live_...) in the Dashboard under Developers > API keys, store it in STRIPE_API_KEY, and give it Read on the resources the report touches: Subscriptions, Invoices, Charges, Customers, PaymentIntents, Balance and Disputes.Never hand an agent the secret key (sk_live_...); a restricted key with Read where needed and None everywhere else can't refund, cancel or charge anything.
Standard GA4 properties take about 2 to 6 hours to process intraday data, and the Realtime API covers 30 minutes with no source dimension. The skill re-reads the whole day every hour, so earlier hours fill in, and marks the latest hours as provisional. Product Hunt, Hacker News and Stripe have no such lag, so their numbers are current.
Hacker News and many apps strip or shorten the referrer, and people who copy the URL into a new tab arrive as direct. The skill never spreads those across channels, because that would make every channel look a little better than it is. A ?ref= parameter on the links you post yourself (for example in the Show HN text or Reddit post) shrinks the unknown row.
No. The skill runs with your own agent and gives you the report in the chat. With a Briefkin token set, each run also posts it to your board as a report card, so you can glance at it instead of asking again.
Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot CLI, OpenCode, Windsurf and Amp all read SKILL.md files. The install command puts it in ~/.claude/skills and ~/.agents/skills, where they look. ChatGPT, the Claude app and Grok take the prompt instead. Pick your agent under "Install and run it" and the commands change to match.
Yes. Switch the data source to "Your browser" and the steps change to the Product Hunt, Hacker News, Reddit, Google Analytics, GitHub and Stripe pages themselves: the agent opens www.producthunt.com in a browser you are signed in to and reads the numbers off the page. Claude Code, Codex, Cursor, Claude app and ChatGPT can drive a browser out of the box; Gemini CLI, Copilot CLI and OpenCode need a Playwright or Chrome DevTools MCP server first. It is slower than the API and needs you signed in, so it suits a report you run by hand or from a scheduler on your own computer.
Skills are free to use with any agent. Briefkin is where their results land: one board for every report, number and question your agents send, with a ping when something needs you.
Free during the open beta. No card.