Build the environment in two layers and do not confuse them.

The lower layer is deterministic and has nothing to do with language models: a parser that can repair delimiters, a formatter, a linter, and a running nREPL. It is cheap, it is boring, and it is the layer that actually prevents the failure this whole subject is about. The upper layer is agent-facing context — CLAUDE.md, skills, hooks, an MCP server — and it is worth nothing on top of a missing lower layer.

The evidence for putting it that way is in §3: across 93 Clojure projects on this machine, clj-kondo configuration appears in 20 and delimiter repair in 2. The upper layer is better provisioned than the lower one, which is exactly backwards.

Minimum viable stack, in the order it should be adopted:

1. A hook that repairs delimiters on every write. One line of configuration.
2. clj-kondo and a formatter, which most projects here already have.
3. One long-lived nREPL the agent can evaluate against.
4. CLAUDE.md naming the above, so an agent knows the REPL exists.
5. Only then: an MCP server, if the extra tools earn their tokens.

Distinguishing official capability from community tooling matters here, because the community tools are configured through the official mechanisms and inherit their constraints.

Surveys of this subject list what exists. The more useful question is what a working Clojure shop has actually adopted, so the audit below walked every project under two GitHub orgs carrying a deps.edn, project.clj, shadow-cljs.edn or bb.edn.

Three readings.

The cheapest control is the least adopted. Delimiter repair is one line of configuration and it is the direct answer to the failure mode every survey names. Two projects have it.

Linting is not the same as indexing. clj-kondo at 20 and clojure-lsp at 1 means the corpus checks its code but gives an agent no symbol index to navigate with. An agent without clojure-lsp does what a reader without an index does: greps.

Twelve projects have a REPL an agent could use and no CLAUDE.md to mention it. That is the widest gap between capability and reachability in the corpus, and it costs nothing to close. It is also a clean instance of Norman's gulf of evaluation: the capability is present and documented, and the presentation makes it unreachable.

The no licence column matters more than the star count. Three of these projects ship without one, which means no grant of rights — fine for reading, a problem for anything a business depends on.

The star counts above are the weak signal, and a better one exists. The sibling survey github-skills-search crawled the Clojure AI ecosystem on the same day this note was written: two hops from four seed repositories to 743 users and 180,255 star edges, yielding 118 candidates with a structured card each. Its ranking uses independent co-stars — cohort users who starred a repository, excluding those recruited through an engagement with that same repository. Without the correction a seed's own contributors inflate its count by construction; one project in that survey drops from 62 raw co-stars to 3 independent ones.

That survey also had to solve a problem this note did not notice: since 2026-06-30 GitHub restricts stargazer and watcher lists to repository admins, so a cohort cannot be built from who starred a thing. It is built from public engagement instead — contributors, fork owners, issue and pull-request authors.

Two things it found that the table above misses entirely.

ECA (editor-code-assistant/eca, 1,011 stars) is the flagship product written in Clojure in this space — an editor-agnostic coding assistant, second by independent co-stars across the whole cohort. It is a peer of the harness, not a plugin for one, which is why a survey organised around "what can I add to Claude Code" does not surface it.

There are eight or more Clojure MCP SDKs, a category this note omits by framing MCP as something to consume rather than something to build. Co-stars favour the early entrants — modex, mcp-clojure-sdk — while the newer plumcp (client and server, Clojure and ClojureScript, OAuth 2.1, all transports, used by ECA and Nubank) and mcp-server (RokLenarcic) are the more complete. Worth knowing before writing an MCP server by hand.

The last row is the one no tool supplies. See §8.

.claude/
  settings.json          hooks: paren repair on Write|Edit, both Pre and Post
  skills/
    clojure-repl/        how to reach the REPL here, and what to evaluate first
    clojure-test/        run the focused test, then the namespace, then the suite
    clojure-review/      what to check that a linter cannot
CLAUDE.md                the REPL address, the aliases, the tier boundaries
.clj-kondo/config.edn
.lsp/config.edn

The split: CLAUDE.md carries what is true every turn and nothing more; skills carry procedures with a trigger; settings.json carries what must happen whether or not the model agrees.

Step 1, run rather than asserted:

known-bad   (defn f [x] (inc x)    ->  updatedInput: (defn f [x] (inc x))
known-good  (defn f [x] (inc x))   ->  no output at all
tool absent from PATH              ->  exit 1, naming the install step

The middle line is what makes the first line mean something. If balanced input also produced output, a check that greps for the repair would pass against a hook that does nothing.

The runtime half, against a live nREPL:

$ clj-nrepl-eval -p 42527 "(+ 1 2 3"
=> 6

The input is missing a delimiter. The client repaired it and evaluated it. That single line exercises both halves of the lower layer at once.

The audit in §3 counted .claude/skills/ directories in two GitHub orgs and found 10 of 93. A skill-specific crawl of GitHub, run the same day, found 1,251 repositories holding 4,414 skill directories. Both numbers are correct. They measure different things, and the gap between them is the finding.

Dedicated skill repositories barely exist — topic:claude-skills clojure returns 1, topic:agent-skills clojure returns 3. Skills live inside other repositories, where a repository-level search cannot see them, and where my directory-existence check only sees them if I happen to be standing in the right tree.

Three consequences.

Large Clojure products already ship skills. Penpot (60k stars) carries nrepl-eval. Metabase (49k) carries clojure-eval, clojure-review, clojure-write and add-malli-schemas. Defold ships clojure-code-style for its editor; XTDB ships xtdb-testing and xtdb-object-boundaries. Shipping a skill is now part of how a large Clojure codebase onboards an agent, and the practice is further along than a survey of one person's repositories suggests.

Skills propagate, and nobody is tracking provenance. Metabase's three skills appear in 19 to 31 other repositories — forks, dotfiles, and marketplaces including aiskillstore and awesome-omni-skill. Nearly half of all matched skill directories, 47.8%, sit in eight or more registry repositories that mirror them in bulk. A skill is a Markdown file that tells an agent what to do, it copies as easily as a dotfile, and one of the places Metabase's skills turn up is a malicious-skill benchmark. That is a supply chain with no provenance layer, and this note has nothing to offer about it.

The center of gravity is narrower than the volume suggests. Among classified skill names, REPL and evaluation is the largest single group at 55 of 768. Everything else is specific — a library, a frontend framework, a house style. The generic "Clojure skill" is rarer than the count implies.

The landscape survey's strongest negative finding: evaluation is the largest gap in this ecosystem. There is no benchmark for Clojure code generation, the one effort at a fine-tuning dataset was abandoned in 2023, and apart from one project requiring a Rama cluster there is no maintained evaluation tooling.

That matters for everything above. Every recommendation in every survey of this subject — including this note — rests on plausibility and on small local checks. Nobody can currently answer whether adding an MCP server changes outcomes, whether a delimiter hook reduces failed edits by a measurable amount, or whether a skill fires when it should. The tools are good and the evidence that they help is anecdote.

There are early signs of a measurement culture — skill A/B tests, benchmark receipts, an encrypted challenge suite — but they are per-project, not shared. Until that changes, the honest framing of a recommended stack is this is what the people building the tools believe, not this is what works.

The generalisable part: delimiter repair is a parsing problem and ports across the family almost unchanged; live runtime access is a protocol problem and does not port at all. Clojure's advantage is nREPL, not its parentheses.

1. Today. Add the repair hook. One line, no context cost.
2. This week. Calibrate it — feed it an unbalanced form and watch it fire. An uncalibrated hook is indistinguishable from no hook.
3. This week. Add CLAUDE.md to the twelve projects that have a REPL and no note saying so.
4. Next. clj-kondo where missing; clojure-lsp anywhere an agent navigates rather than reads.
5. Then. A CLI nREPL client, so claims become executable under any harness.
6. Only then. MCP, on a minimal profile, and measure whether the extra tools change outcomes.
7. Not yet. Multi-agent orchestration.

• Shared REPL as Gossip Protocol — the multi-machine case for one long-lived REPL.
• Claude Code Features: 2026 Q2 — what the harness supplies natively.
• CLI Coding Agents: 2026 Q2 — the comparison this assumes.
• github-skills-search (aygp-dr) — the crawl this note leans on for ecosystem shape: 118 candidates, independent co-stars, a card per project.
• Advanced Clojure — one nREPL server that CIDER and Calva can both connect to.