Three skills that find the names of new AI models, products and repositories as they surface, and size the search terms behind them with Google Ads volume and Google Trends.
Collect what is new in AI in the last 24 hours across X, Hugging Face, GitHub and sitemaps, deduplicated, as one report of names that are starting to surge. Use when the user asks what is new or trending in AI today, wants a daily AI listening report, or needs fresh names of models, products and repositories to feed keyword research. Runs the new-term-radar command line; needs an AISA_API_KEY.
# AI listening
Produce one report: the names of new AI models, products and repositories seen in the last 24 hours, where each was seen, and how strong the signal is. This is collection, not analysis. For search demand behind a name, hand the names to the `seo-new-keywords-research` skill.
## Before you run anything
1. Find the radar. Use `$NEW_TERM_RADAR_DIR` if set, else `~/new-term-radar`. If neither exists, clone it: `git clone https://github.com/zhuyansen/new-term-radar ~/new-term-radar`. Run every command from that directory. Python 3.10 or newer; no packages to install.
2. Check an AIsa key is available: `AISA_API_KEY`, or the AIsa CLI logged in (`ls ~/.aisa/key`). Without one only the free signals run (Hugging Face, GitHub, sitemaps), no X posts are read, and nothing judges which terms are names. Say so in the report. A key comes from https://go.aisa.one/yansen-zhu.
3. If there is no `config.json`, copy `config.example.json` to `config.json`. Tell the user they are on the example list of X accounts and sitemaps and can edit it.
## Cost and time, say this first
A run reads every X account in `config.json`: about 0.003 USD and 10 seconds each, so the example list of 35 accounts is about 0.11 USD and 6 minutes. Tell the user the estimate before you start, and do not run it twice in a row: the second run reports only what changed since the first.
## Run
```bash
python -m radar daily --skip usecases,review,newsites --out listening.md
```
This reads X, Hugging Face, GitHub breakouts and the sitemaps, merges terms seen by several signals, and scores each as a name or a common word. It writes `listening.md` and `listening.json`.
The first run on a machine only builds snapshots (yesterday's X vocabulary, star counts, sitemap URLs do not exist yet), so it reports GitHub breakouts and little else. Say this plainly instead of presenting a thin report as a quiet day. From the second run on, every signal reports what is new.
If the user only wants the fastest-moving sources, `python -m radar sources --out listening.md` reads X and Hugging Face alone and writes nothing when there is no new name.
## Write the report
Read `listening.json` (key `leads`), not only the Markdown. For each lead you have `term`, `kinds` (which signals saw it), `signals` (one line per signal), `named` (0 to 1), `examples`, `posts` (text, url, likes) and `known`.
Give the user:
1. **New names, strongest first**: seen by two or more signals, then by name score. For each: the name, what it is in a few words (from the examples, do not guess), where it was seen with the number that shows its strength (accounts and likes, stars a day, trending rank), and one link (the post or the repository).
2. **Breakout repositories** from `breakout.repos` that are new today.
3. **What did not run**: any signal whose block holds `error` or `skipped`, and what the report lacks because of it.
Keep only leads with `named` of 0.5 or more unless the judge did not run. Leave out leads whose `known` is set: the user already covers those. Do not add names from your own knowledge: the report is what the radar saw.
`python -m radar leads --days 1` lists what was kept, for a quick look without a new run. It is free.
## What this cannot tell you
- Whether people search for these names. That is the next skill.
- Names that none of the configured accounts or sites mentioned.
- Anything about a name beyond the examples it was seen in.One run from signal to decision. Finds the names of new AI models, products and repositories seen in the last 24 hours (X, Hugging Face, GitHub, sitemaps), then builds a keyword priority table for them, each new name and the generic search terms behind it, sized against Google Ads volume and Google Trends, with prioritize, watch or skip. Use when the user wants today's new AI keywords, an AI trend radar, or asks what new AI terms are worth building a page or tool for. Also takes names the user already has. Runs the new-term-radar command line; needs an AISA_API_KEY.
# New-term radar
The whole job in one run: collect what is new, then work out which keywords are worth acting on. If the user wants only the collection, or only the keyword research on names they already have, the split skills `ai-listening` and `seo-new-keywords-research` do each half.
## Before you run anything
1. Find the radar: `$NEW_TERM_RADAR_DIR` if set, else `~/new-term-radar`; clone https://github.com/zhuyansen/new-term-radar there if missing. Run every command from that directory. Python 3.10 or newer; nothing to install.
2. An AIsa key must be available, as `AISA_API_KEY` or from the AIsa CLI (`aisa login` stores it in `~/.aisa`): the X posts, the search volumes, Google Trends and the models all go through it. Without it, stop and say so. A key comes from https://go.aisa.one/yansen-zhu.
3. `TRUSTMRR_API_KEY` is optional: with it the weekly ⑥ revenue signal reads the products people pay for that grow fastest (TrustMRR). Its leads are for the user's own research: TrustMRR's terms forbid republishing the data, so never paste the product list into anything public.
4. `GOANYAPI_API_KEY` is optional (a key comes from https://goanyapi.com/r/ga-95708898fb). With it the table also holds what people really searched together with each name, and reads the bigger rows from one country's settled series. Without it, tell the user a "flat" reading is weaker evidence.
5. If there is no `config.json`, copy `config.example.json` and tell the user they are on the example list of X accounts and sitemaps.
## Choose the path
**The user has names already** ("research PhotoCraft and SynthID Detector"): skip collection.
```bash
python -m radar keywords "photocraft" "synthid detector" --repo "photocraft=storytold/photocraft" --json
```
About 0.05 USD a name plus 0.09 USD a call, 40 to 90 seconds a name, eight names at most. One call for all the names.
**The user wants today's new terms**: run everything.
```bash
python -m radar daily --out report.md
```
With the example config this is about 0.30 USD and 10 to 15 minutes: it reads every X account in `config.json` (0.003 USD and 10 seconds each), finds breakout repositories and new sitemap pages, scores which terms are names, then builds the keyword table for up to five of the day's names. It writes `report.md` and `report.json`.
Say the cost and the time before either command, and do not run `daily` twice in a row: the second run reports only what changed since the first.
The first `daily` run on a machine only builds snapshots, so it reports GitHub breakouts and little else. Say so; do not present it as a quiet day.
On Mondays (or with `--asks`) `daily` also reads what people asked for on Reddit that week (⑦, about 0.12 USD): jobs an AI tool could do, sized and checked for room on page one. It also lists the sites that just put up a payment link (⑧, Stripe, Polar, Lemon Squeezy, Gumroad, Creem; about 0.25 USD): new products people already pay for, AI and software first. A payment link means the site sells, not that it sells well. With `--revenue` and a `TRUSTMRR_API_KEY` it reads the products people pay for (⑥).
**The user wants to know what people complain about for a kind of tool** ("what's wrong with AI headshot tools?"):
```bash
python -m radar pains "ai headshot" --json
```
About 0.05 USD and a minute or two. It reads low-star Chrome Web Store reviews (needs `GOANYAPI_API_KEY`), Reddit complaints and comments under tutorial videos, and returns `gaps`: each with `gap`, `kind` (missing, too hard, quality, price, wants a tool), `count`, `phrase` (what someone with the problem would search) and `quotes` with links. Counts are of what was read, not of the market. App Store, Google Play and Trustpilot reviews are not reachable, and the radar does not read There's An AI For That or Facebook groups; say so if the user expects them.
## Read the result honestly
From `report.json`: `leads` are the day's names (with `kinds`, `signals`, `named`, `examples`, `posts`), `keywords` is the keyword table (`rows`, `tails`, `cosearch`, and the error fields). From `keywords --json` the table is the whole output.
Each table row: `phrase`, `kind` (`name` or `generic`), `names` (the name it sits behind), `new`, `per_day`, `started`, `peak_day`, `momentum`, `now`, `decision`, `brand`, `source`, `trend_geo`, `evidence`.
- `per_day` is an estimate, good to an order of magnitude.
- `now` is `rising`, `holding`, `fading` or `flat`. A row with `trend_geo` was read from one country's daily data settled to yesterday. A row without it was read from a worldwide series whose last two days are discarded, where a real move can read `flat`: for those rows say "no rise seen", never "did not rise".
- `brand` true (⚠): the keyword carries someone else's brand. Keep it, flag it; using it is the user's call.
- `source` "searched" (🔎): people searched it together with the name. Stronger than a phrase the model proposed.
- If `posts_error`, `related_errors` or `country_errors` is set, or a signal's block in `report.json` holds `error`, a source failed. Say which, and that the result holds less than it should. A thin table is not a quiet market.
- If `keywords.names` is empty, no lead today was a thing with a name score of 0.8 or more. Say that; offer to run `keywords` on a name the user picks from the leads.
- Names usually rise within days of release and may fade within a week. Generic terms move later and less, if at all.
## Deliver
1. **Today's new names** (skip this part on the names-given path): strongest first, each with what it is in a few words from the examples, where it was seen with the number that shows its strength, and one link.
2. **The priority table**, sorted prioritize, watch, skip:
| Keyword | Type | Behind | New? | Est. searches/day | Started rising | Momentum (7d) | Now | Page one | Decision | Why |
Use the radar's `decision` and add one short reason per row from the fields above.
`competition` (rows that would be acted on): `verdict` open, mixed or crowded; `weak` = page-one results on sites rated under 30, the slots a new site can take; `kd`; `ads`; `weakest` (the site a new page can push past). A row with `demoted` was rising but moved to watch because page one is crowded: say so. In a name's first week page one is still forming; trust the second reading.
3. **Under the table**: each name's long-tails (`tails`), other names found alongside (`cosearch`), then every caveat that applies: missing key, failed source, first run, estimate quality.
4. **Two or three lines of advice**: which rows are worth a page or a tool now, and what to look at again in a few days. Search volume data runs about two months behind; say so if the user is about to commit work to a number.
Do not add names, rows, volumes or dates from your own knowledge. The output is what the radar saw.Turn new AI names or unstructured AI market signals into a keyword priority table. For each name it finds the generic search terms downstream of it, screens them for relevance, and checks novelty, demand size and momentum against Google Ads volume and Google Trends, ending in prioritize, watch or skip. Use when the user has new model, product or repository names (or an AI listening report, a batch of posts, a changelog) and asks which keywords to build pages or tools for. Runs the new-term-radar command line; needs an AISA_API_KEY, and a GOANYAPI_API_KEY improves it.
# SEO new-keywords research
Input: names of new AI things, or raw text that mentions them. Output: one table, names and the generic terms behind them, each with a decision.
A name ("SynthID Detector") has a short life as a keyword and belongs to someone. The job it does ("ai image detector") is what people keep searching, and nobody owns it. You need both in the same table.
## Before you run anything
1. Find the radar: `$NEW_TERM_RADAR_DIR` if set, else `~/new-term-radar`; clone https://github.com/zhuyansen/new-term-radar there if missing. Run every command from that directory.
2. An AIsa key must be available, as `AISA_API_KEY` or from the AIsa CLI (`aisa login` stores it in `~/.aisa`): every lookup here is paid through it. Without it, stop and say so. A key comes from https://go.aisa.one/yansen-zhu.
3. `GOANYAPI_API_KEY` is optional (a key comes from https://goanyapi.com/r/ga-95708898fb). With it the table also holds what people really searched together with each name, and reads the bigger rows from one country's settled series. Without it, tell the user that a "flat" reading is weaker evidence (see below).
4. If there is no `config.json`, copy `config.example.json`.
## Step 1: pick the names
If the user gave names, use them. If they gave text (a listening report, posts, release notes), extract the names yourself:
- Keep names of specific models, products, tools and repositories. Drop companies alone ("Google"), common words, and features.
- Use the searchable form: lowercase, as people would type it, with its version when the version is the news ("nano banana 2.1"), without it when the family is ("photocraft").
- A repository's README is good evidence: note its `owner/repo`.
- Choose at most five, the newest and most specific first. Each name costs money and about a minute. Tell the user which you chose and which you left out.
## Step 2: say the cost, then run
About 0.05 USD a name plus 0.09 USD a call, and 40 to 90 seconds a name. State the estimate, then:
```bash
python -m radar keywords "photocraft" "synthid detector" --repo "photocraft=storytold/photocraft" --json
```
Drop `--json` for the Markdown table alone. Run one call with all the names, not one call per name: the 0.09 USD is per call.
## Step 3: read the result honestly
Each row has `phrase`, `kind` (`name` or `generic`), `names` (which name it sits behind), `new`, `per_day`, `started`, `peak_vs` and `bench_level`, `peak_day`, `momentum`, `now`, `decision`, `brand`, `source`, `trend_geo`, `evidence`, `volume`.
- **`per_day` is an estimate**, good to an order of magnitude. A generic term's comes from its own Google Ads volume moved along its Trends curve; a name's is sized against a benchmark keyword.
- **`now`**: `rising`, `holding`, `fading`, `flat`. A row with `trend_geo` was read from one country's daily data settled to yesterday. A row without it was read from a worldwide series whose last two days are discarded, and there a real move can read `flat`: say "no rise seen" for those rows, never "did not rise".
- **`brand` true** (⚠): the keyword carries someone else's brand ("photoshop alternative"). Keep it in the table and flag it; whether to use it is the user's legal and positioning call.
- **`source` "searched"** (🔎): people searched it together with the name. Stronger evidence than a phrase the model proposed.
- **A thin table is not a quiet market.** If the output's `posts_error`, `related_errors` or `country_errors` is set, a source failed: say which, and that the table holds less than it should.
- Names usually rise within days of release and may fade within a week. Generic terms move later and less, if at all. Do not present a name's spike as lasting demand.
## Step 4: deliver the priority table
One table, sorted prioritize, watch, skip:
| Keyword | Type | Behind | New? | Est. searches/day | Started rising | Momentum (7d) | Now | Page one | Decision | Why |
- Use the radar's `decision`, and add one short reason per row in your own words from the fields above (for example: "steady 2,500 a day, did not move on the release" or "rose 80% in the US for five days, still small").
- `competition` (rows that would be acted on): `verdict` open, mixed or crowded; `weak` = page-one results on sites rated under 30, the slots a new site can take; `kd`; `ads`; `weakest` (the site a new page can push past). A row with `demoted` was rising but moved to watch because page one is crowded: say so. In a name's first week page one is still forming; trust the second reading.
- Under the table: the long-tails of each name (`tails`), the other names found alongside (`cosearch`), then every caveat that applies: missing key, failed source, estimate quality.
- Then two or three lines of advice at most: which rows are worth a page or a tool now, and what to check again in a few days. Search volume data runs about two months behind; say so if the user is about to commit work to a number.
Do not invent rows, volumes or dates. If the radar returned nothing for a name, say that the posts showed no concrete use yet and offer to read it again in three days.