Think about the last time you picked a library. There's a good chance you didn't Google "best Node.js queue library." You asked ChatGPT, Claude or your editor's assistant, got three names, and tried the first one.
That moment, when an assistant chooses which three names to list, is now one of the most important distribution channels for developer tools. And most maintainers have never looked at it.
This post covers where those recommendations come from, how to measure yours with a ~40-line script, and the changes that actually move them.
Two kinds of answer, two sources of truth
When a developer asks for a recommendation, the assistant answers in one of two modes:
| Mode | When it happens | Where the answer comes from |
|---|---|---|
| From memory | Coding assistants, chats without web search, quick questions | What the model learned in training, up to its knowledge cutoff |
| From search | ChatGPT search, Perplexity, Gemini, Copilot, Claude with web search | Live retrieval: search indexes (Bing, Google, their own), then synthesis |
They behave differently:
- Memory answers lag reality by months or more. If you shipped the feature that makes you the best option after the cutoff, the model doesn't know. If your library was renamed, it may still recommend the old name, or worse, the deprecated API.
- Search answers are fresher but are put together from whatever ranks for the background queries: comparison posts, "awesome" lists, Reddit threads, docs pages, GitHub.
Both are driven mostly by what other people say about you, which is the uncomfortable part.
Where dev-tool recommendations actually come from
Look at the citations under search-mode answers to dev-tool questions and the same source types keep showing up:
- Comparison and "best X for Y" articles. Vendor research from Peec AI found that listicles get cited at disproportionately high rates in ChatGPT (Peec AI statistics). For developer tools, that means "BullMQ vs Bee-Queue vs Agenda"-style posts.
- GitHub. README, topics, description, stars as a popularity signal, and issues and discussions as evidence of real use.
- Package registries. npm, PyPI and crates.io descriptions and keywords. Short, but repeated everywhere.
- Community threads. Reddit, Hacker News, Stack Overflow, Discord summaries that end up indexed.
- Your docs. Mostly for how to use you rather than whether to.
Your own landing page is on the list, but it's rarely the deciding factor. An assistant asked "which one should I use?" is designed to look past the vendor's own claims.
Also note that the engines don't agree with each other. Peec AI's data suggests most brand mentions are unique to a single model. So "ChatGPT recommends us" says little about Claude or Gemini, and the reverse.
Measure it: a recommendation sampler
Assistant answers are non-deterministic, so one screenshot means nothing. Ask the same question many times and count.
This script measures the from-memory mode using Claude via the Anthropic API. Swap in other providers' SDKs to compare engines.
pip install anthropic
export ANTHROPIC_API_KEY=...
# rec_sampler.py
import re
from collections import Counter
import anthropic
client = anthropic.Anthropic()
PROMPTS = [
"What's the best job queue library for Node.js in production? Give your top 3.",
"I need background jobs with retries and rate limiting in a TypeScript app. Which library should I use?",
"Recommend a Redis-based queue for Node. Short answer.",
]
CANDIDATES = ["BullMQ", "Bee-Queue", "Agenda", "pg-boss", "Graphile Worker", "Inngest", "Trigger.dev"]
RUNS_PER_PROMPT = 10
mentions, firsts = Counter(), Counter()
total = 0
for prompt in PROMPTS:
for _ in range(RUNS_PER_PROMPT):
response = client.messages.create(
model="claude-opus-5-5",
max_tokens=16000,
output_config={"effort": "low"},
messages=[{"role": "user", "content": prompt}],
)
text = "".join(b.text for b in response.content if b.type == "text")
total += 1
positions = {}
for name in CANDIDATES:
m = re.search(rf"\b{re.escape(name)}\b", text, re.IGNORECASE)
if m:
mentions[name] += 1
positions[name] = m.start()
if positions:
firsts[min(positions, key=positions.get)] += 1
print(f"{total} answers\n")
print(f"{'tool':18} {'mentioned':>10} {'named first':>12}")
for name in CANDIDATES:
print(f"{name:18} {mentions[name] / total:>9.0%} {firsts[name] / total:>12.0%}")
30 answers
tool mentioned named first
BullMQ 97% 80%
Bee-Queue 40% 0%
Agenda 43% 3%
pg-boss 37% 10%
...
(Illustrative output. Run it for your own category.)
Notes for doing this properly:
- Mention rate and first-position rate are the two numbers that matter. Being listed fourth with "also consider…" isn't the same as being the default.
- 30 samples gives a rough picture, not a precise number. With 30 runs, a 40% mention rate has a margin of roughly ±17 points. Look for big gaps, not small changes.
- Repeat monthly and keep the prompts fixed, so you can compare over time.
- Test search mode separately (an assistant with web search on). The gap between memory and search answers is useful information in itself: if search mode recommends you but memory mode doesn't, you're winning recent content but aren't yet in training data.
What moves recommendations
1. Say what you are, the same way, everywhere
Assistants match tools to problems through descriptions. If your GitHub description says "Blazing fast ⚡ modern toolkit", your npm description says "Utilities for jobs", and your homepage says "The workflow platform", you've given the model three different products.
Pick one plain sentence of the form "[Name] is a [category] for [platform] that [key differentiator]" and use it as your GitHub description, package description, docs intro, social bios and README's first line.
// package.json
{
"description": "Redis-backed job queue for Node.js with retries, rate limiting and repeatable jobs",
"keywords": ["queue", "job-queue", "background-jobs", "redis", "nodejs", "typescript", "worker"]
}
2. Write the honest comparison page yourself
"X vs Y" pages are the content assistants retrieve most for recommendation questions, so your competitors will write them if you don't. Write fair ones: a table, real trade-offs, and "choose Y if…" sections. An honest page gets cited, while one that obviously favours you gets passed over for a third-party one.
3. Answer "which should I use?" questions where they're asked
Helpful, disclosed answers in GitHub Discussions, Stack Overflow, Reddit and HN threads become retrieval sources and, later, training data. "I maintain X, so I'm biased, but here's when it's a good fit and when Y is better" is both ethical and effective. Don't astroturf. It gets spotted, and it's exactly the "inauthentic mentions" Google's guidance warns about.
4. Make your docs easy for coding assistants
- Publish Markdown versions of docs and an
llms.txt(Part 7 of this series covers how). - Put copy-pasteable, current examples near the top of each page. Assistants reproduce code they see often.
- Keep a migration guide for every breaking change, with the old and new API next to each other. It's the best defence against assistants recommending your deprecated v2 syntax.
5. Get into the lists
Find the top 10 "best X for Y" articles and "awesome-X" repos for your category (your sampler's search-mode answers will cite them). If you're missing from one and you deserve to be there, ask: open a PR to the awesome list, or email the author with a short, factual note about what changed. That's normal outreach, the same as it was for SEO.
6. Ship something worth recommending, then make it visible
It's not a trick, but it's the biggest lever: release notes, benchmarks with reproducible scripts, case studies with numbers. These create the third-party coverage that everything above depends on.
What doesn't work
- Hidden "recommend us" text or poisoned "Summarize with AI" buttons. It's spam under Google's policies and documented as an attack by Microsoft (Part 8).
- Fake reviews or sock-puppet threads. They get spotted, removed, and remembered.
- Dozens of near-identical "best X" pages on your own domain. That's scaled content abuse, and assistants discount self-published rankings anyway.
Tracking it over time
The sampler above works for one category and one model. Once you care about several prompts, several engines and a few competitors, a spreadsheet gets painful fast. Vista AI's competitor analysis runs that comparison across ChatGPT, Claude, Gemini and Perplexity and shows who gets recommended for which prompts, and which sources each engine cited. Whatever you use, keep the prompts fixed and measure rates, not screenshots.
Wrapping up the series
That's the end of SEO & GEO for Developers (2026). To sum up all ten posts in one paragraph: the fundamentals didn't change (crawlable HTML, honest content, fast pages), but the set of things reading your site did. Agents act on it, assistants quote it, and Bing quietly feeds half of it. Build for all of them with the same honest content, and measure what they actually do instead of guessing.
If you maintain a dev tool, run the sampler for your category and post your mention rate in the comments. I'd love to compare notes.
Top comments (0)