just: agent skill
just
A reference for running recipes and writing a justfile, shipped in the just repository by its author for agents
- 36,479 ★ on the repository
- Last commit
- CC0-1.0
Extended access
Why this level
- Following the skill, the agent runs `justfile` recipes, which are arbitrary shell commands and scripts
- The skill advises turning frequent commands into recipes, so the agent may create and edit the project's `justfile`
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/justDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Following the skill, the agent runs `justfile` recipes, which are arbitrary shell commands and scripts
- The skill advises turning frequent commands into recipes, so the agent may create and edit the project's `justfile`
This is third-party code. Review the repository files before installing.
What it does
The just skill is a single SKILL.md inside the casey/just repository, the command runner's own source. An agent loads it when the project has a `justfile` or the user mentions just. The file then explains how to find the project's recipes, run the one you need and write a new one. For discovery it lists `just --list` (recipes with descriptions), `just --show` (a recipe's source), `just --dump` (the whole file), `just --evaluate` (variable values), `just --summary` and `just --help`. For execution it gives three forms: `just` for the default recipe, `just <RECIPE>`, and `just <RECIPE> <ARG1> <ARG2>` with arguments. A syntax sample shows a variable, recipes with dependencies and parameters, and a recipe starting with `#!/usr/bin/env bash` that is written to a file and run as a script. The notes say a comment above a recipe becomes its description in `just --list`, that each line runs in a fresh shell by default, and that frequently used commands are worth turning into recipes.
Who it is for. For developers whose project commands live in a `justfile` and who want an agent to run builds, tests and releases through recipes.
Good fit when
- The project has a `justfile` and the agent needs a list of recipes with their descriptions
- The agent should run tests or a build through a recipe with arguments, for example `just test <name>`
- You need to add a recipe with dependencies or a parameter with a default value
- A bash recipe has to be written as a script with `#!/usr/bin/env bash` and `set -euxo pipefail`
- You want the agent to read a recipe's source with `just --show` before changing it
Not a fit when
- The project builds with make, npm scripts or another tool: the skill covers only just
- You need a full reference on modules, imports, attributes and settings: the skill omits them, and they are described in the repository README
- The just program is not installed: the skill does not install it, so you first need a package manager, a pre-built binary or `cargo install just`
- You need an MCP server that lets the agent run recipes itself: the skill only explains commands, and the just author points to an MCP adapter as a separate project
Example request
Show which recipes this project's justfile has and run the tests for the api packageLimitations
The skill is short: about seventy lines with a list of flags, three ways to run and one sample `justfile`. The rest of the language is described in the repository README, and the skill does not point to it.
The skill does not install the just program. The README lists package managers, pre-built binaries, `cargo install just` and the just-install package for Node.js. Windows needs the sh shell from Git for Windows or Cygwin, or another shell chosen with the `shell` setting.
The agent picks up the skill when it sees a `justfile` or the word just in a request. Without that condition the reference stays unloaded.
License CC0-1.0.
How to disable. Delete the just skill folder from your agent's skills directory. If you installed it with `npx skills add casey/just --global`, find the installed just folder in the global skills directory and remove it. The just program itself stays in place; remove it with the package manager you used to install it.
FAQ
How do I install the skill?
Two ways: by hand, copying the skills/just folder, or with `npx skills add casey/just --global`.
What does `just --list` show?
The project's recipes with their descriptions. A description is the comment on the line above the recipe in the `justfile`.
How do I run a recipe with arguments?
Write `just <RECIPE> <ARG1> <ARG2>`. In the skill's sample the recipe `test name` takes a test name, and the recipe `serve port='8080'` has a default port.
What happens when a recipe starts with `#!`?
The body of such a recipe is written to a file and executed as a whole script. Without `#!`, each recipe line runs in a fresh shell, so variables do not carry over between lines.
Which recipe runs on a bare `just`?
The one with the `[default]` attribute, or the first recipe in the `justfile` if none has it. The program's documentation describes this rule; the skill itself does not.
Is there an MCP server for just?
In the documentation's Model Context Protocol section the author points to a third-party project, just-mcp. That adapter lets models read the contents of a `justfile` and run recipes.
Discussion
No questions or reviews yet.
Related
SkillsA code review skill across many languages and frameworks: architecture, performance, security, anti-patterns and common bugs
The author's personal set: shared agent rules and dozens of skills for GitHub, the browser, macOS, messaging and releases, plus a sync script
skill-creator: skills from OpenAPI, GraphQL and MCP
@asnd/skill-creator
The /skill-creator command turns a link to an OpenAPI spec, GraphQL schema or MCP server into a ready skill with wrappers.
Skills from the Dart team: tests and mocks, analysis and dart fix, CLI apps, FFI, documentation and package conflict fixes for an AI agent
agent-skills (misaka-mikoto-tech)
agent-skills
Three skills by one author for an agent on Windows: safe PowerShell, reading Bilibili videos and working with an open Unity Editor
A skill that replaces terminal ASCII with self-contained HTML pages: diagrams, diff reviews, plan reviews, tables and slide decks
README in short
A detailed document on the recipe language in one file: installation from package managers, pre-built binaries and source, with sections on parameters, dependencies, attributes, expressions, strings, script recipes, shell settings and `.env` files. It covers editors and a language server. A short section on the skill names its folder and install command. A Chinese translation of the documentation and a test suite sit alongside.
README badge
Original SKILL.md
---
name: just
description: >
Reference for `just`, the command runner. Use when working in a project with
a `justfile` or when the user mentions `just` or `justfile`.
---
Just
====
Discovery
---------
- `just --dump` Print justfile
- `just --evaluate` Print variable values
- `just --help` Print detailed command-line syntax help
- `just --list` Print recipes with descriptions
- `just --show <RECIPE>` Print recipe source
- `just --summary` Print recipes without descriptiosn
Execution
---------
- `just` Run default recipe
- `just <RECIPE>` Run specific recipe
- `just <RECIPE> <ARG1> <ARG2` Run recipe with arguments
Syntax
------
```just
executable := 'main'
# compile main.c
compile:
cc main.c -o {{ executable }}
# run main
run: compile
./{{ executable }}
# run test
test name: compile
./bin/test {{ name }}
# start webserver
serve port='8080':
python -m http.server {{port}}
# publish current tag
publish:
#!/usr/bin/env bash
set -euxo pipefail
tag=`git describe --tags --exact-match`
./bin/check-tag $tag
git push origin $tag
```
Notes
-----
The comment proceeding a recipe is used as its doc-comment, and included in
`just --list`.
By default, each line of a recipe runs in a fresh shell. Recipes whose bodies
start with `#!` are written to a file and executed as a script.
Commonly used commands and scripts should be turned into `just` recipes.