Key takeaways
- Neither Claude Code nor Codex publishes a ranking system for SDKs. Recommendations come from a mix of your repository, instruction files (CLAUDE.md and AGENTS.md), connected tools like MCP servers, model training data, and web search when it's on.
- For a developer using these agents, the most reliable way to steer recommendations is to write down your stack in CLAUDE.md or AGENTS.md. Existing dependencies beat generic advice almost every time.
- For a developer-tool vendor, the work is crawlable docs, a visible GitHub presence, current review profiles, and where it makes sense, an MCP server.
- Promptwatch's October 2026 software citation data is a proxy, not a direct measurement. It shows which sources an LLM with web search leans on for software questions: docs, GitHub and review sites.
- I couldn't find a primary study of how either agent picks SDKs. Treat anyone who claims to know the exact mechanism with suspicion.
The honest starting point: nobody has published the algorithm
Let me say the awkward part first. When I went looking for a primary study of how Claude Code or Codex choose an SDK, I found comparison posts and Reddit threads. That's it. Anthropic and OpenAI document how their agents read instructions, run commands and connect to tools. Neither documents an SDK-selection policy.
So this guide is built from what is documented and observable: how the agents get context, what the comparison reviews say about configuration, and what third-party citation data tells us about the sources AI systems trust for software questions. Where something is inference, I'll say so.
The practical upshot is useful anyway. An agent's recommendation is the output of several inputs, and you can influence most of them.
The inputs that shape a recommendation
Think of a coding agent as a very fast engineer who has read a lot, has opinions baked in from training, and looks around your project before answering. Five inputs matter.
1. Your repository
Both agents read files, search the codebase and run commands. If your package.json already lists a payments SDK, the agent will almost always extend that choice rather than propose a rival. Existing lockfiles, import statements and config files are the strongest signal in the room. This is also why agents feel "opinionated" in a greenfield project and oddly conservative in an old one.
2. Instruction files
This is the lever you control most directly. Claude Code uses CLAUDE.md, and current versions also support AGENTS.md with configuration-specific behavior. Codex uses AGENTS.md. According to Blake Crosley's comparison, AGENTS.md is a cross-tool standard adopted by 60,000+ projects and donated to the Agentic AI Foundation under the Linux Foundation, and it works in Cursor, Copilot, Amp, Windsurf and Gemini CLI too.
Builder.io's practical advice: if you want one file that works everywhere, maintain AGENTS.md and keep a synced CLAUDE.md for Claude Code. Check which files actually load in your client, especially when a repo already holds instructions for several tools, as Northflank's comparison points out.
3. Connected tools (MCP)
Both agents support MCP integrations. Builder.io says Claude has more one-click MCP connectors, while the Medium piece notes Codex configures MCP in TOML. Crosley cites 10,000+ active public MCP servers. When an agent can call a vendor's MCP server, it can fetch current docs or perform an action with that vendor's API. A connected tool tends to get used. An unconnected one has to win on training data alone.
4. Model training data
When the repo and instructions are silent, the model falls back on what it learned. That means older, widely documented SDKs get recommended disproportionately. It also means a brand-new SDK can be invisible until the next model release. I'd treat this as the default bias of any LLM-based tool, not something specific to either agent.
5. Web search
Some sessions can pull in live information. For a vendor, that's where public documentation and third-party pages come in. Which brings us to the one piece of hard data I can cite.
What citation data says about trusted sources for software questions
Promptwatch Data's report on software-related prompts in ChatGPT (organic prompts, Sep 28 to Oct 4, 2026) doesn't measure Claude Code or Codex. It measures ChatGPT's web-search citations. I'm using it as a proxy for what an LLM with search treats as a credible source about software tools.
| Source | Share of software citations |
|---|---|
| github.com | 1.2% |
| learn.microsoft.com | 0.98% |
| g2.com | 0.73% |
| AWS docs | 0.41% |
| Google Cloud docs | 0.35% |
| Gartner | 0.34% |
| Capterra | 0.32% |
By source type, docs and help centers earned the largest share (2.64%), then vendor sites (2.01%), review sites and analysts (1.57%) and GitHub (1.2%). Vendor pages and docs together earned 4.65%, roughly three times what review sites and analysts earned. Those percentages look small because the report only charts 23 domains out of a very long tail, and together they account for 7.89% of software citations.
The pattern is what matters. Documentation and code hosting beat marketing and reviews. That matches how a coding agent behaves: it wants something it can read, run and verify. For related context on how citations are shaped, see Promptwatch's data on which content types ChatGPT cites, where product pages lead at 22.4%, and on how long cited content stays cited, where docs and landing pages last longest.
Claude Code vs Codex: differences that affect recommendations
The two agents converge more every quarter. Builder.io says the agents are "increasingly similar," and Superblocks says to pick based on workflow, not benchmark percentages. Still, a few differences touch how tool choice plays out.
| Factor | Claude Code | Codex |
|---|---|---|
| Instruction file | CLAUDE.md, plus supported AGENTS.md configurations | AGENTS.md |
| Extensibility | Deep hooks (more than two dozen event types), skills, subagents | Hooks, skills, multi-agent tools, open-source repo |
| MCP | STDIO and HTTP, many one-click connectors | STDIO and HTTP, OAuth for streamable HTTP servers |
| Where it runs | Terminal, VS Code, JetBrains, desktop, web | CLI, IDE extension, desktop app, cloud tasks, Chrome extension |
| Models | Claude models | OpenAI models only |
| Sandboxing | Application-layer permissions and hooks | OS-level sandbox modes |
Two things stand out. First, model lock-in: Braintrust notes Codex uses OpenAI models only, while Claude Code uses Claude models. Each agent's built-in sense of the ecosystem comes from its own vendor's training. I can't prove that this biases SDK suggestions, but it's a reasonable thing to test. Second, hooks. Crosley describes Claude Code's hooks as the deepest governance system, which means you can enforce rules like "never add a new dependency without approval" deterministically rather than hoping the model complies.
How to steer your own agent toward the SDKs you want
If you're a developer or team lead, you don't need to guess. Write your decisions down.
Put your stack in the instruction file
A short, specific file does more than a long one. Something like:
## Stack decisions
- Payments: use Stripe's official Node SDK. Do not add alternatives.
- Auth: Auth.js. Do not hand-roll session handling.
- Testing: Vitest. Run `pnpm test` before declaring a task done.
## Dependency rules
- Check package.json before suggesting any new library.
- Propose new dependencies in the plan, never install them silently.
Crosley's related post on AGENTS.md patterns goes deeper on which patterns change agent behavior and which are anti-patterns. The Northflank comparison makes the same point more briefly: give the agent build and test commands, architecture constraints and acceptance criteria it can read.
Gate dependency changes
Use permissions or hooks. Claude Code starts read-only and asks before editing or running state-changing commands, per Braintrust, and teams can tune that through shared settings. A hook that blocks npm install of anything outside an approved list turns a preference into a rule.
Connect the docs you trust
If a vendor offers an MCP server for its docs, adding it gives the agent current API details instead of stale training memory. That's often the difference between a deprecated method and a working call.
Run a bake-off on your own repo
Every comparison I read says some version of this. Aissist recommends a two-week bake-off on your own repository before standardizing, because public benchmarks don't measure your code. I agree. The agents' outputs differ less than the internet's arguments suggest, and your repo is the only benchmark that counts.
If you build an SDK or developer tool: how to get recommended
This is the other side of the question, and the one where being honest matters most. No one can guarantee a recommendation from Claude Code or Codex. What you can do is make your tool easy to read, easy to verify and easy to find.
Make the docs crawlable and complete
The citation data points the same direction: docs and help centers lead. Publish quickstarts with copy-pasteable, tested code. Keep versioned reference pages at stable URLs. Don't hide docs behind a login or a JavaScript wall that crawlers can't render.
Keep a public GitHub presence
github.com is the top domain in that software report. A maintained repo with a clear README, examples and recent commits is a trust signal for people and for machines. It's also where an agent can inspect real usage patterns.
Ship an MCP server and an llms.txt
An MCP server lets an agent use your tool directly. A tidy llms.txt points crawlers at the pages that matter. Neither is a magic switch. Both lower friction. Promptwatch's free LLMs.txt Generator is one way to produce the file, and for the MCP side, a hosted server with read and write tools is the pattern more vendors are adopting.
Keep review profiles current
G2 and Capterra show up in the citation data. Stale profiles with outdated pricing or deprecated features feed the wrong picture to any model that reads them.
Check what AI crawlers actually see
Coding agents also show up in your logs. Promptwatch's crawler traffic data breaks down verified requests from OpenAI, Anthropic, Google, Perplexity and Mistral, and its Meta-WebIndexer report shows how fast crawler mix can shift. If your docs return errors to these bots, no amount of content work will help.
Measuring whether any of this works
You can't improve what you can't see. For developer-tool companies, the practical question is: when someone asks an AI "which SDK should I use for X," do we show up, and which pages get cited?
Promptwatch tracks that across ChatGPT, Gemini, Perplexity, Google AI Overviews and others, and it also tracks the coding agents Codex, Claude Code and OpenCode, which matters for exactly this audience. Its crawler logs show which AI bots read your docs and where they hit errors, and its content gap analysis points to prompts your pages don't answer yet.
A few other trackers in the catalog cover the monitoring side if you want to compare. Profound and Otterly.AI are two common ones, though they focus on monitoring rather than the full crawl-to-citation loop. For a wider scan of the category, the GEO software directory lists more options.
A quick caveat I'd rather state than hide: tracking coding-agent recommendations is a young discipline, and results vary a lot by prompt wording, country and model version. Run the same prompts regularly and look at trends, not single snapshots.
A practical checklist
| If you are... | Do this first |
|---|---|
| A developer using Claude Code or Codex | Write stack decisions in AGENTS.md (and a synced CLAUDE.md); gate new dependencies with permissions or hooks |
| A team standardizing on one agent | Run a two-week bake-off on your real repo; compare diffs, test results and review burden |
| An SDK or API vendor | Publish crawlable docs, maintain GitHub, offer an MCP server, keep G2 and Capterra current |
| A marketing or DevRel lead | Track AI answers for "which SDK for X" prompts and check crawler logs for doc errors |
What I'd watch next
Three things. Whether AGENTS.md support in Claude Code becomes uniform, since that would end the duplicate-file chore. Whether either vendor documents how dependency suggestions are weighted. And whether coding-agent citation data gets published at scale. Today the only measurable proxy is web-search citation behavior, and it points at docs and GitHub. Build for that, and keep your instruction files honest.
For more on how AI citation patterns break down by category, browse the Promptwatch Data hub.