Publish Sign in

Clojure Code Review

Review Clojure and ClojureScript code changes for compliance with Metabase coding standards, style violations, and code quality issues.

You say
Install this skill Read the source first Free Written by metabase · unverified publisher
Context cost
1.6k tokensestimated from the bundle, loaded when it triggers
Bundle
1 file · 6.6 kBtext throughout, nothing executable
Licence
AGPL-3.0free to use
Last change
—no release on file
Servers it uses
Noneruns standalone

What it does

Review Clojure and ClojureScript code changes for compliance with Metabase coding standards, style violations, and code quality issues. Use when reviewing pull requests or diffs containing Clojure/ClojureScript code.

Installed, it changes the agent in these ways.

What this skill changes about the agent is not written down here yet. The listing was collected from its source, and the description is in its own SKILL.md.

Voice & style

Changes how the agent writes and reviews.

collaborationcode review
Filed under

Communication & Collaboration

The skill itself

This is the whole product. A skill is instructions the model reads, so there is nothing behind the listing you cannot see first — the front matter loads with every session, and the body below it loads when the skill triggers.

SKILL.md6.6 kB · 161 lines
--- name: clojure-review description: Review Clojure and ClojureScript code changes for compliance with Metabase coding standards, style violations, and code quality issues. Use when reviewing pull requests or diffs containing Clojure/ClojureScript code. allowed-tools: Read, Grep, Bash, Glob ---
7# Clojure Code Review Skill
8
9@./../_shared/clojure-style-guide.md
10@./../_shared/clojure-commands.md
11
12## Review guidelines
13
14**What to flag:**
15
16- Check compliance with the Metabase Clojure style guide (included above)
17- If CLOJURE_STYLE_GUIDE.adoc exists in the working directory, also check compliance with the community Clojure style guide
18- Flag all style guide violations
19
20**What NOT to post:**
21
22- Do not post comments congratulating someone for trivial changes or for following style guidelines
23- Do not post comments confirming things "look good" or telling them they did something correctly
24- Only post comments about style violations or potential issues
25
26Example bad code review comments to avoid:
27
28> This TODO comment is properly formatted with author and date - nice work!
29
30> Good addition of limit 1 to the query - this makes the test more efficient without changing its behavior.
31
32> The kondo ignore comment is appropriately placed here
33
34> Test name properly ends with -test as required by the style guide.
35
36**Special cases:**
37
38- Do not post comments about missing parentheses (these will be caught by the linter)
39
40## Quick review checklist
41
42Use this to scan through changes efficiently:
43
44### Naming
45
46- [ ] Descriptive names (no tbl, zs')
47- [ ] Pure functions named as nouns describing their return value
48- [ ] kebab-case for all variables and functions
49- [ ] Side-effect functions end with !
50- [ ] No namespace-alias repetition in function names
51
52### Documentation
53
54- [ ] Public vars in src or enterprise/backend/src have useful docstrings
55- [ ] Docstrings use Markdown conventions
56- [ ] References use [[other-var]] not backticks
57- [ ] TODO comments include author and date: ;; TODO (Name 2025-01-01) -- description
58
59Docstring content — check every new or rewritten docstring against the anti-pattern table in the
60style guide above. Read the diff's docstrings on their own, separately from the code: prose is
61where review attention slides off, and a long docstring reads as diligence rather than as the
62liability it usually is.
63
64### Code Organization
65
66- [ ] Everything ^:private unless used elsewhere
67- [ ] No declare when avoidable (public functions near end)
68- [ ] Functions under 20 lines when possible
69- [ ] No blank, non-comment lines within definition forms (except pairwise constructs in let/cond)
70- [ ] Lines ≤ 120 characters
71
72### Tests
73
74- [ ] Separate deftest forms for distinct test cases
75- [ ] Pure tests marked ^:parallel
76- [ ] Test names end in -test or -test-<number>
77
78### Modules
79
80- [ ] Correct module patterns (OSS: metabase.<module>.*, EE: metabase-enterprise.<module>.*)
81- [ ] API endpoints in <module>.api namespaces
82- [ ] Public API in <module>.core with Potemkin
83- [ ] No cheating module linters with :clj-kondo/ignore [:metabase/modules]
84
85### REST API
86
87- [ ] Response schemas present (:- <schema>)
88- [ ] Query params use kebab-case, bodies use snake_case
89- [ ] Routes use singular nouns (e.g., /api/dashboard/:id)
90- [ ] GET has no side effects (except analytics)
91- [ ] Malli schemas detailed and complete
92- [ ] All new endpoints have tests
93
94### MBQL
95
96- [ ] No raw MBQL manipulation outside lib, lib-be, or query-processor modules
97- [ ] Uses Lib and MBQL 5, not legacy MBQL
98
99### Database
100
101- [ ] Model and table names are singular nouns
102- [ ] Uses t2/select-one-fn instead of selecting full rows for one column
103- [ ] Logic in Toucan methods, not helper functions
104
105### Drivers
106
107- [ ] New multimethods documented in docs/developers-guide/driver-changelog.md
108- [ ] Passes driver argument to other driver methods (no hardcoded driver names)
109- [ ] Minimal logic in read-column-thunk
110
111### Miscellaneous
112
113- [ ] Example data is bird-themed when possible
114- [ ] Kondo linter suppressions use proper format (not #_:clj-kondo/ignore keyword form)
115
116## Pattern matching table
117
118Quick scan for common issues:
119
120| Pattern | Issue |
121| -------------------------------------------- | ----------------------------------------------------------- |
122| calculate-age, get-user | Pure functions should be nouns: age, user |
123| update-db, save-model | Missing ! for side effects: update-db!, save-model! |
124| snake_case_var | Should use kebab-case |
125| Public var without docstring | Add docstring explaining purpose |
126| ;; TODO fix this | Missing author/date: ;; TODO (Name 2025-01-01) -- description |
127| (defn foo ...) in namespace used elsewhere | Should be (defn ^:private foo ...) |
128| Function > 20 lines | Consider breaking up into smaller functions |
129| /api/dashboards/:id | Use singular: /api/dashboard/:id |
130| Query params with snake_case | Use kebab-case for query params |
131| New API endpoint without tests | Add tests for the endpoint |
132
133## Feedback format examples
134
135**For style violations:**
136
137> This pure function should be named as a noun describing its return value. Consider user instead of get-user.
138
139**For missing documentation:**
140
141> This public var needs a docstring explaining its purpose, inputs, and outputs.
142
143**For docstrings documenting code they don't own:**
144
145> This describes how lib decides binning strategies internally. Nothing here fails when that
146> changes, so it will go stale silently — drop it and let available-binning-strategies answer
147> for its own behavior.
148
149**For docstring content that belongs in the body:**
150
151> This paragraph explains why the branches are ordered this way, which is what someone editing
152> the cond needs — but a caller can't act on it. Move it to an inline comment above the cond.
153
154**For organization issues:**
155
156> This function is only used in this namespace, so it should be marked ^:private.
157
158**For API conventions:**
159
160> Query parameters should use kebab-case. Change user_id to user-id.
161
In the file
SKILL.md953 words
Files1
LicenceAGPL-3.0
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈70
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
1,580
on trigger
The instruction body, read only when the skill fires.
0.83%
of a 200k window
Ten skills this size would take about 8% of the window before you open a file.
050k100k150k200k context window

1.6k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Middling. Fine to keep on in a project where you use it weekly, worth unloading in one where you never do.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

Adoption
Installsnone yet
Ratingno reviews yet

The procedure it runs

The procedure has not been published here. It is in the skill’s own SKILL.md, which its author has not sent to the marketplace yet.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

It writes no files and reaches no network. All it changes is how the model reasons and writes.

What it asks for
Writes filesno
Network accessno

Read from the allowed-tools line of this skill’s own SKILL.md. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

1 file, 6.6 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md6.6 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing. The AGPL-3.0 licence covers the templates and examples as well as the instructions.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# Clojure Code Review · 1.6k tokens when loaded npx mcprush@latest skill add metabase/clojure-code-review

Writes to .claude/skills/clojure-code-review/ in the current project. Add --global to put it in your home directory instead, for every project.

Which clients pick it up on their own

A skill is a folder of text. A client with a skills folder reads it without being told; everywhere else the same text works, it is just handed to the model rather than found.

Claude Code.claude/skills/
Claude Desktop
ChatGPT
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok.grok/skills/
Zed.agents/skills/
Windsurf.windsurf/skills/
Agent SDK.claude/skills/
HTTP / API
This release
Versionnot versioned
Publishedno release date on file
PriceFree
Referencemetabase/clojure-code-review

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

v
  • No earlier releases have been published to the marketplace.
Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet · no installs yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Who can post

Only accounts that have had the skill installed for fourteen days, so a review is written after living with it rather than after reading it. Publishers may reply once.

Who wrote it

ME
metabase

Publishes on mcprush.

0 servers listed9 skills listednot claimed
Profile
Publisher
Servers0
Claim this skill