CodeSampleX

Does it run there?

Documentation alone leaves coding agents guessing what will actually build. Install csx to add a real execution experience layer to your AI — recalling verified successes, failures, and environment boundaries in the background.

Install the CLI

Real execution experience for your AI

Where it actually ran

A live slice of one measured package's compatibility cube. Click any cell to drill into that slice; every number is a recorded observation, not an estimate.

633K Observations recorded observations — one per build stage that ran, with the environment it ran in
8.6K Samples that built usable answers that passed their contract
3.3K Packages coverage — targets with recorded evidence
Runtime × Symbol
1 8○ 32026-09-14
golang.org/x/net/html.CommentTokengolang.org/x/net/html.ErrorTokengolang.org/x/net/html.NewTokenizergolang.org/x/net/html.Parsegolang.org/x/net/html.Tokengolang.org/x/net/publicsuffix.EffectiveTLDPlusOnegolang.org/x/net/publicsuffix.Listgolang.org/x/net/publicsuffix.PublicSuffix
go 1.26 100%2 100%2 100%2 88%8 100%2 57%7 57%7 57%7
node 22 100%15 100%15 100%15 100%15

golang.org/x/net · golang — Open the full explorer → Showing the environments with the most evidence.

How to read the grid

Reading a cell: The number is how many recorded observations the rate divides — one build files an observation per stage it reached, so it counts neither builds nor machines nor people. The document beside it is a different fact from a different source: whether a sample exists at that coordinate, and how our own run of it went there.

  • no sample at this coordinate yet
  • there is a sample here, and nothing of ours has run it at this coordinate yet
  • there is a sample here, and our run of it at this coordinate came back clean
  • there is a sample here, and our run of it at this coordinate failed
  • there is a sample here, and this coordinate records both a passing and a failing run of it
  • nothing recorded — unknown, never "works" and never "broken"
  • there is a level below this cell — click to open it

A document means there is a sample at that coordinate. Whether one EXISTS is a fact about this release and this API and does not change with OS, runtime or package manager; its COLOUR is how that sample ran in the environment you are looking at.

The cell states a rate and passes no verdict. The percentage is of the recorded observations beneath it — one build files an observation per stage it reached, so the count is neither builds nor machines nor people. Observation and verification are never summed — that a project compiled is never presented as an API working — and a grid spread over environments carries observation only, because what this network ran belongs to a version and not to an OS.

Install

Windows (PowerShell)
irm https://codesamplex.dev/install.ps1 | iex
macOS / Linux
curl -fsSL https://codesamplex.dev/install.sh | sh

Source · Read the installer · Code: Apache-2.0 · Data: CDLA-Permissive-2.0

One command, one question. Everything else is automatic.

What the CLI does

  • csx run -- npm testwrap any build or test — its exit code becomes anonymous evidence
  • csx search "axios multipart upload"ask for a sample that built, with the exact difference from your environment
  • csx scanrecord which public packages a project uses, without building
  • csx statsyour local dashboard: hits, adoptions, queue

csx init automatically detects and connects Claude Code, Codex, Gemini CLI, Antigravity, and OpenCode. Other agents connect via configuration. Supported coding agents →

Let your coding agent install it

Paste this prompt into the coding agent you already have open. It follows the official install instructions instead of guessing them, adds csx to your agent configuration, and checks the connection before it reports success.

Install the CodeSampleX (csx) MCP server for the coding agent I am using right now.

Use only the official CodeSampleX instructions — https://github.com/r2cuerdame/CodeSampleX/blob/main/llms-install.md, with the installers at https://codesamplex.dev/install.sh (macOS, Linux) and https://codesamplex.dev/install.ps1 (Windows). Do not improvise commands or config from memory.

1. Read my MCP config before you write to it. Keep every server already listed and add csx next to them; never replace the file.
2. Register csx by its absolute path — a client my editor starts does not inherit my shell PATH.
3. csx has no account: do not ask me for a token, password or API key, and do not write a secret into any config.
4. Initialize community mode with `csx init --community --yes` so this installation receives and contributes network evidence; do not leave it local-only. Only sanitized public package, version, symbol, environment and build-result facts are shared — never source, paths, project names, secrets, private packages or raw logs.
5. Verify before reporting success: confirm `csx daemon status` reports `mode: community`, run `csx sync` once, then confirm my client lists csx and that a `search_known_solution` call answers.
6. Tell me every file you changed, and anything you could not do.

Read it before you send it. It asks for no account, token or password — csx needs none — and it tells the agent to add csx alongside the MCP servers you already have, never to overwrite your config.
Supported coding agents

Installing csx automatically connects the execution experience layer to your coding agents — registering detected clients without manual configuration.

  • Claude Code
  • Codex
  • Gemini CLI
  • Antigravity
  • OpenCode

Install csx and your detected agents are connected automatically. csx init registers the tool rules and connection — no config files to edit.

Other agents or manual configuration

Any other client works too — Cursor, Windsurf, Cline, Zed, VS Code. Run this command and paste what it prints to configure the absolute path:

csx mcp-config

Model-agnostic. The same execution experience serves Claude, GPT, Codex, Gemini, Llama — any model connected to your coding agents.

How it worksWill this API actually work with my package, version, and runtime combination?

Will this API actually work with my package, version, and runtime combination? Official docs can't answer that. Recorded observations from real environments can.

  1. You build or test through csx — or your coding agent does it for you.
  2. Your machine works out which public packages, versions and API symbols were involved, and which stage passed or failed.
  3. Errors are reduced to fingerprints locally. Paths, project names, secrets and raw logs never leave your machine.
  4. Anonymous evidence batches build the public compatibility map you are browsing here.
  5. Your agent asks CodeSampleX first and gets the closest sample that built, plus the exact difference from your environment.

Your coding agent can consume the same network through the MCP adapter: it asks CodeSampleX before writing code against a public library, and reports back whether the answer built. The CLI and the web report read identically.

The install contract

You get

  • Public compatibility knowledge
  • Code answers that built here
  • Local agent integration
  • Public sample cache

You contribute

  • Public package/version usage
  • Public API/symbol usage when detectable
  • Build/typecheck/test result
  • Sanitized failure fingerprints

Never shared automatically

  • Source code
  • Repository/project name
  • File names or paths
  • Source snippets
  • Secrets or environment variables
  • Private packages
  • Raw compiler/runtime logs