// the jack-in cli

Load skills from the command line.

jack-in is the companion CLI to Jack In. It downloads version-aware skills from the public DevNines/dotnet-skills (opens in new tab) repo and drops them straight into your agent — for every project on your machine, or just one.

Get it on NuGet Browse skills

bash — install & jack in

# one-time install (needs the .NET 8 SDK)
$ dotnet tool install --global JackIn
You can invoke the tool using the following command: jack-in

# load every skill into your agent
$ jack-in load all
status: LOADED (10 skills)

01 — install

One command, any machine.

bash — install · update · remove

# install (global .NET tool — command name: jack-in)
$ dotnet tool install --global JackIn

# update to the latest release
$ dotnet tool update --global JackIn

# remove
$ dotnet tool uninstall --global JackIn

Needs the .NET SDK (8.0 or later). If jack-in isn't found right after install, make sure ~/.dotnet/tools is on your PATH.

02 — the commands

Five verbs. That's the whole surface.

load one

jack-in load <package|skill>[@version]

Load a single skill. Address it by package id (Ardalis.Specification), folder name (ardalis-spec), or a sibling package — case- and punctuation-insensitive.

load all

jack-in load all

Pull every skill in the source repo in one shot.

list

jack-in list

Show every available skill with its package id and the versions it ships.

version

jack-in version

Print the installed tool version (also --version).

help

jack-in help

Full usage, targets, and options — right in the terminal.

03 — where skills land

Your whole machine, or one project.

User-level default

<user>/.claude/skills/

With no flag, skills install for your user — every project an agent opens can load them.

This project only

./.claude/skills/ · --project

Pass --project (-p) to write into the current directory's .claude/skills instead — scoped to one repo.

04 — options

Flags for every flavour.

Option	Alias	What it does	Default
`--project`	`-p`	Install into `./.claude/skills` for this project instead of the user dir.	user-level
`--force`	`-f`	Overwrite a skill that's already installed at the target.	off
`--repo <owner/name>`	—	Pull skills from a different source repository.	`DevNines/dotnet-skills`
`--ref <branch\|tag\|sha>`	—	Pull from a specific branch, tag, or commit.	`main`
`--user-dir <path>`	—	Override the user-level skills directory.	`<user>/.claude/skills`

05 — version resolution

The right version, never a wrong method.

Skills are version-aware at runtime — the skill reads the version a project pins from its .csproj and self-selects the matching reference files. So jack-in copies the whole skill folder (every version it ships); the @version you pass is validated and reported, it never filters what's copied. The match follows the same rule the skills use: exact → same minor (highest patch) → same major (highest minor ≤ requested) — and never a higher minor.

bash — version matching

$ jack-in load Ardalis.Specification@9.3.1
  · ardalis-spec: exact reference v9.3.1 · grounded, no invented methods

$ jack-in load Ardalis.Specification@9.5.0
  · ardalis-spec: v9.5.0 → closest reference v9.3.1

$ jack-in load Ardalis.Specification@9.0.0
  ! ardalis-spec: no reference data for v9.0.0 — copying anyway,
    the skill self-selects at runtime from your .csproj

Always tidy. Every run downloads the source repo to a temp folder and deletes the zip and the extracted files when it finishes — success or failure.

06 — the hosted mcp server

No install? Use the hosted server.

Don't want to install anything? The same version-aware reference is live on a hosted MCP server at https://jackin.dev/mcp. Any Model Context Protocol (opens in new tab) client — Claude Code, Claude Desktop, Cursor, Windsurf, VS Code — connects over HTTP and pulls the grounded docs into context on demand. Where jack-in load copies a skill onto your disk, the hosted server answers tool calls — nothing to install, no key.

bash — add it to Claude Code

# register the hosted server (HTTP transport)
$ claude mcp add --transport http jackin https://jackin.dev/mcp
  -s user  → every project · -s project → share via .mcp.json

# confirm it connected, inside Claude Code:
/mcp
  jackin · connected · 4 tools

Prefer config over the CLI? Drop this into a .mcp.json at your project root:

json — .mcp.json

{
  "mcpServers": {
    "jackin": { "type": "http", "url": "https://jackin.dev/mcp" }
  }
}

Tool	What it returns
`list_skills`	Every skill the server can ground, with the versions each one ships.
`get_skill_reference(package, version, section)`	The version-pinned document. `section` is one of `api-surface`, `patterns`, `examples`, or `migration`. Resolves the closest tracked version and reports which it served.
`detect_version(projectFileXml)`	Pinned versions of supported libraries, read from raw `.csproj` / `Directory.Packages.props` XML.
`resolve_version(package, requestedVersion)`	The closest tracked reference version for a package and a requested version.

claude code — using the tools

# once connected, ask in plain language — Claude picks the tool & args:
> list the skills jackin can ground
  list_skills → ardalis-spec, ardalis-result, fastendpoints, stripe,
               hangfire, swagger, shouldly, nsubstitute (+ versions)

> pull the api-surface for Ardalis.Specification 9.3.1
  get_skill_reference("Ardalis.Specification", "9.3.1", "api-surface")
  served v9.3.1 · real members, nothing invented

> show me FastEndpoints 8.1.0 patterns and examples
  get_skill_reference("FastEndpoints", "8.1.0", "patterns")
  get_skill_reference("FastEndpoints", "8.1.0", "examples")

> here's my csproj — which supported libraries does it pin?
  detect_version("<Project>…</Project>") → FastEndpoints 8.1.0

> closest tracked Stripe.net to 51.9.9?
  resolve_version("Stripe.net", "51.9.9") → 51.2.0

claude code — fix real code with jackin

# tip: name "jackin" and be specific — the tools fire only when you ask.

# ground every tracked library in your project, then fix the code:
> Use jackin: run detect_version on my .csproj, then get_skill_reference
  (api-surface + patterns) for each supported library, and fix the code
  that uses them so every call matches the pinned version.

# or target a single library / error:
> I'm getting an error with FastEndpoints — use jackin to pull the 8.1.0
  api-surface and fix my endpoint.

jackin only grounds the libraries the repo tracks (Ardalis.*, FastEndpoints, Stripe.net, Hangfire, Swashbuckle, Shouldly, NSubstitute) — it sharpens those, it doesn't fix unrelated code. For the most automatic experience, jack-in load installs the skill, which auto-activates whenever Claude touches that library.

Not on Claude Code? Any MCP client works — or call a tool directly over raw HTTP (JSON-RPC):

bash — call a tool over raw HTTP

# get the patterns doc for Ardalis.Specification 9.3.1
$ curl -sN https://jackin.dev/mcp \
    -H "Content-Type: application/json" \
    -H "Accept: application/json, text/event-stream" \
    -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":
         {"name":"get_skill_reference","arguments":
          {"package":"Ardalis.Specification","version":"9.3.1","section":"patterns"}}}'
  → { "servedVersion": "9.3.1", "section": "patterns", "content": "…" }

Open by design. The endpoint needs no key — anything that can reach it can call the tools — and is capped at 120 requests/min per client. It serves the reference data; it does not install a skill or run its instructions the way jack-in load does.

07 — examples

Copy, paste, jack in.

bash — everyday use

$ jack-in load Ardalis.Specification@9.3.1   # by package id → user-level
$ jack-in load ardalis-spec --project        # by name → ./.claude/skills
$ jack-in load all                           # every skill, user-level
$ jack-in load hangfire --force              # reinstall, overwriting
$ jack-in list                                # what's available + versions

Install jack-in Back to home