Allium skill
A behavioural specification language and skills: the agent keeps an .allium file beside your code, reconciles it with the code and generates tests
- 519 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- The Claude Code hook runs allium check after every file edit
- The tend and weed agents edit the spec themselves and may change code when reconciling divergences
- The propagate skill creates test files in the project
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/alliumDetects 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.
- The Claude Code hook runs allium check after every file edit
- The tend and weed agents edit the spec themselves and may change code when reconciling divergences
- The propagate skill creates test files in the project
This is third-party code. Review the repository files before installing.
What it does
Allium is a formal language for describing what a system should do, without saying how it is built inside. The agent keeps an .allium file next to the code: entities and rules, where each rule has a when event, requires preconditions and ensures outcomes. This structure makes contradictions visible on their own: two rules with incompatible conditions expose a conflict, and the model does not have to spot it in prose. The package has six working skills. /allium is the entry point and, given a goal like "add gift cards", drives the whole loop to convergence. /elicit builds a spec through a conversation about a new feature, /distill extracts one from existing code and drops implementation detail. /tend edits the spec as requirements change, /weed finds divergences between spec and code and reconciles them in either direction, /propagate generates tests from the spec. A witness skill independently confirms that the loop really converged and no test was weakened. For Claude Code the plugin also adds autonomous tend and weed agents in their own context and a hook that runs allium check after each edit. A separate CLI checks spec structure: it traces data flow across rules and finds entity lifecycles with no terminal state.
Who it is for. For developers and architects who run long projects with agents and want to pin down intent, not only code.
Good fit when
- By prompt ten or twenty the agent loses the original intent, and you need a document that outlives sessions
- A project has code with no behaviour description, and you want a spec distilled from it, bugs and edge cases surfaced along the way
- A new feature such as password reset or gift cards should get its rules first and an implementation after
- You need integration and end-to-end tests that follow from specified behaviour rather than from the current implementation
- Spec and code have drifted apart and you need to tell whether the code or the spec is wrong
Not a fit when
- You need to describe a database schema, API design or UI layout: the language deliberately excludes implementation details
- The task is small and one-off, such as restyling a button: a spec loop would be overhead
- You want unit tests for internal functions: specs yield integration and end-to-end tests
- You only use code autocompletion with no agent: the README rules such assistants out explicitly
Example request
/allium add gift cards to the shop and bring the spec, tests and code into agreementLimitations
The CLI installs separately (brew tap juxt/allium && brew install allium, or cargo install allium-cli). Without it the skills fall back to the language reference, but edits get no formal check. The autonomous tend and weed agents work in Claude Code and GitHub Copilot, automatic post-edit checks come built in for Claude Code, as a recipe for Cursor, Windsurf and Aider, and through a git hook elsewhere. On large codebases distilling a spec may need several passes.
How to disable. In Claude Code run /plugin uninstall allium. If you installed with npx skills, delete the allium folder and sibling skills from the agent's skills directory. The .allium files in your project stay as plain text.
FAQ
How do I install Allium in Claude Code?
Through the JUXT marketplace: /plugin marketplace add juxt/claude-plugins, then /plugin install allium. After that /allium launches the entry point, which inspects the project and suggests the next step.
How do I install Allium in Codex?
With codex plugin marketplace add juxt/claude-plugins and codex plugin add allium@juxt-plugins. Codex gets the skills but no autonomous agents; verification goes through a git hook or a manual allium check.
Why keep a spec next to the code if the code is the source of truth?
Code holds both intended and accidental behaviour and cannot tell them apart. The spec states what the system should do, and the gap between spec and code surfaces questions worth answering. The author calls that redundancy what makes the system resilient.
How is Allium different from requirements in markdown?
Markdown has no mechanism that would flag a clash between "users must be authenticated" and "guest checkout is supported". In Allium rules have formal conditions and outcomes, so a conflict of conditions shows up from the structure.
Do I need the CLI to use the skills?
No, without it the skills rely on the language reference. With the CLI every edit is formally checked and results feed straight into the conversation with the agent.
Discussion
No questions or reviews yet.
Related
SkillsTwo skills for spec-driven development: /spec asks questions and saves a document to specs/, /spec-impl implements an approved spec step by step
A Claude Code plugin: spec-driven development over a single SPEC.md file, a loop of seven commands with no sub-agents
A ready harness for Claude Code and Codex: spec-driven development, TDD, memory between sessions, quality gates and human checkpoints
An evidence-first development skill: the agent wraps code in a spec and a gauntlet of checks so line-by-line review becomes optional
Claude Code Skills and Agents
Claude Code Skills & Agents
A Claude Code plugin bundling skills and sub-agents: deep research, image generation, GitHub work, code review and model switching
Softaworks Agent Toolkit
Softaworks Agent Skills
A marketplace of skills, subagents and commands for coding agents: development, documentation, planning and workplace communication
Comparison with similar tools
Entries that share the main search query, and how they differ.
| Entry | Official | Repository stars | Main difference |
|---|---|---|---|
| Allium (this entry) | no | 519 | |
| Spec Kit | no | 142,487 | drives development from spec to plan to tasks, while Allium keeps formal behaviour rules and reconciles them with code |
| OpenSpec | no | 72,778 | stores change proposals and requirements in markdown, while Allium describes behaviour in a formal language checked by a CLI |
README in short
The README explains the loop: gather context with /elicit or /distill, act through /propagate and implementation, verify with tests and /weed, then repeat until convergence. It follows with a matrix of supported editors and integration levels, a skills table, sections on why a spec beats reading code directly or markdown requirements, and Allium rule examples for password reset and a circuit breaker.
README badge
Original SKILL.md
--- name: allium description: Give your AI agents something more useful than a prompt. Velocity through clarity. version: 3 auto_trigger: - file_patterns: ["**/*.allium"] - keywords: ["allium", "allium spec", "allium specification", ".allium file"] --- # Allium Allium is a formal language for capturing software behaviour at the domain level. It sits between informal feature descriptions and implementation, providing a precise way to specify what software does without prescribing how it's built. The name comes from the botanical family containing onions and shallots, continuing a tradition in behaviour specification tooling established by Cucumber and Gherkin. Key principles: - Describes observable behaviour, not implementation - Captures domain logic that matters at the behavioural level - Generates integration and end-to-end tests (not unit tests) - Forces ambiguities into the open before implementation - Implementation-agnostic: the same spec could be implemented in any language Allium does NOT specify programming language or framework choices, database schemas or storage mechanisms, API designs or UI layouts, or internal algorithms (unless they are domain-level concerns). ## Routing table | Task | Tool | When | |------|------|------| | Writing or reading `.allium` files | this skill | You need language syntax and structure | | Building a spec through conversation | `elicit` skill | User describes a feature or behaviour they want to build | | Extracting a spec from existing code | `distill` skill | User has implementation code and wants a spec from it | | Modifying an existing spec | `tend` skill | User wants targeted changes to `.allium` files | | Checking spec-to-code alignment | `weed` skill | User wants to find or fix divergences between spec and implementation | | Generating tests from a spec | `propagate` skill | User wants to generate tests from a specification |