dxkit-checks

dxkit-checks is a skill for Claude Code from vyuh-labs/dxkit. It costs 139 tokens per session (2,808 once invoked), scanned A, original, MIT.

A guardrail tool for making project rules and linters block newly introduced code problems. A linter checks source code for style and common mistakes, while a project rule can enforce requirements such as allowed imports or licenses.

In plain words
What is it for?
Use it to register custom commands, enable supported language linters, list active checks, and enforce architecture or license rules.
Why use it?
It lets teams enable checks without making old, already-known warnings fail every change. Only failures introduced by the current change are blocked.

Skill for Claude Code

Written for Claude Code: installed under .claude/.

Good fit Use it to register custom commands, enable supported language linters, list active checks, and enforce architecture or license rules.

Compare 6 skills from other repositories ↓
Install with agentmods
npx agentmods add skills/vyuh-labs/dxkit/dxkit-checks
Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

Any agent
npx skills add vyuh-labs/dxkit --skill dxkit-checks
Clone the repo
git clone --depth 1 https://github.com/vyuh-labs/dxkit

Made for: Claude Code.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for dxkit-checks

README.md
[![agentmods](https://agentmods.dev/badge/skills/vyuh-labs/dxkit/dxkit-checks.svg)](https://agentmods.dev/skills/vyuh-labs/dxkit/dxkit-checks)
Your own site
<a href="https://agentmods.dev/skills/vyuh-labs/dxkit/dxkit-checks"><img src="https://agentmods.dev/badge/skills/vyuh-labs/dxkit/dxkit-checks.svg" alt="Measured on agentmods" height="20"></a>
Per session 139 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 2,808 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. A grade says what 26 rules found in the file — not that it is safe. Third-party audits
  • NVIDIA SkillSpector warn 7 Sept 2026
SkillSpector: 7 findings, up to medium

These are SkillSpector’s own severities. On a checked sample its high-severity flags on skills were ~96% false positives — a documented command, a public API, a “never do X” rule — so we show them as a caution to read, not a verdict. Why →

  • medium MCP Rug Pull · line 20
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 21
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 22
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 23
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 121
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 129
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
  • medium MCP Rug Pull · line 63
    npx commands without a version suffix (e.g. @1.0.0) create a rug-pull risk if the upstream server is compromised and publishes a malicious update.
    Fix: Pin the version: npx @scope/[email protected]
How audits are shown
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5.1 $0.00139 $0.02808
Opus 5 $0.00069 $0.01404
Sonnet 5 $0.00028 $0.00562
Haiku 4.5 $0.00014 $0.00281

Measured 7d ago against content hash 662ffb76b728, method: parsed. Prices are Anthropic first-party input rates as of 2026-09-07, from the pricing page.

Security

Grade A, and why

dxkit-checks scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 7d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

src-templates/.claude/skills/dxkit-checks/SKILL.md · 156 lines

How it starts

The opening of the file, as written. The whole thing — 156 lines — stays where its author put it; the contents beside it link to each section on GitHub.

dxkit-checks

A custom check is any repo command dxkit runs as a first-class gate citizen. Two sources feed one seam:

  • User checks you declare in .dxkit/policy.json:checks — a project invariant (check:no-cross-layer-imports, make lint, a license audit, scripts/arch-gate.sh).
  • The built-in lint gate — each active language pack's linter (eslint, ruff, golangci-lint, rubocop, clippy, ktlint, dotnet analyzers), enabled with one policy flag.

Both normalize to the same runner and inherit the same machine every native finding gets: fingerprint → baseline → git-aware matcher → brownfield classify → allowlist → guardrail verdict. So the guardrail blocks only a net-new failure and grandfathers pre-existing debt — you can turn on a lint gate against a repo with a thousand existing warnings and it will only ever block the error this change introduced.

It is opt-in, default-off. A repo that declares nothing pays nothing (the runner spawns no process).

See what's configured

npx vyuh-dxkit checks            # list configured user checks + active lint gates
npx vyuh-dxkit checks --json     # the same, machine-readable (agent-queryable)
npx vyuh-dxkit checks run        # DRY-RUN: execute each check, show pass/fail/skip + findings
npx vyuh-dxkit checks run --json

checks run is a diagnostic — it runs the checks and shows what the gate would see right now, but it never blocks and never touches the baseline. Net-new-ness is decided by guardrail check against the committed baseline, not here.

Declare a user check

Add to .dxkit/policy.json:

{
  "checks": [
    {
      "name": "check:no-cross-layer-imports",
      "command": "node scripts/check-layers.js",
      "blocking": true            // default true; false = warn-only
    },
    {
      "name": "license-audit",
      "command": ["scripts/license-audit.sh", "--strict"],
      "blocking": false
    }
  ]
}
  • command is a string (split on whitespace) or an argv array. It resolves the binary on PATH; a missing binary is a fail-open skip, never a block (a developer who hasn't installed a tool locally isn't blocked — CI is the backstop).
  • name is the durable identity key — keep it stable, or the baseline treats a rename as "old check resolved, new check appeared".
  • expectedExit (default 0) sets which exit code means "pass".

Read the full file on GitHub · 156 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 7d ago First seen · 156 lines · 139 tokens per session scan A 662ffb76b728

Subscribe to this mod's changes

dxkit-checks is a skill published in the GitHub repository vyuh-labs/dxkit (10 stars, last pushed 10d ago), licensed MIT. It adds 139 tokens to every session and 2,808 once invoked, about $0.0007 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-08-31.

Related

Other skills, from other repositories

habit-hooks-review

Spawn a reviewer sub-agent to assess a change set against habit-hooks's coding principles. Use AFTER habit-hooks reports clean — habit-hooks catches structural smells; this catches what it cannot (correctness, tests, design, missed edge cases).

habit-hooks/habit-hooks · 51 tokens

release-habit-hooks

Cut a new release of the habit-hooks packages. Use when asked to release, publish, or bump the version. Reviews what lands, enforces the in-sync versioning rule, validates the changelog, and drives the tag-triggered PyPI publish.

habit-hooks/habit-hooks · 56 tokens

habit-hooks-prompting

Write or revise a habit-hooks coaching prompt. Use when a linter / knip / jscpd rule fires and the agent's default fix is wrong or shallow, or when adding a project-local override prompt. Keeps prompts short and outcome-focused using the ROSE pattern.

habit-hooks/habit-hooks · 61 tokens

recipe-front-review

Reviews completed frontend implementation for governing-source compliance, scope economy, repository quality, and security, then applies user-approved React corrections.

shinpr/claude-code-workflows · 29 tokens

dorodango

Polishes working code through successive quality passes in fresh subagents. Use after tests pass when code needs multi-dimension refinement before release.

athola/claude-night-market · 31 tokens

ring:exploring-codebases

Exploring a codebase across phases: scopes the target, detects architecture, components, and layers, deep-dives each discovered perspective, then synthesizes findings into actionable guidance with file:line evidence. Use to understand how a feature or system works before planning changes, or to orient on an unfamiliar…

LerianStudio/ring · 91 tokens