allium

Allium

Velocity through clarity

---

Feed your AI something healthier than Markdown. juxt.github.io/allium

What this is

Allium is a skill for clarifying intent during agentic engineering. The LLM builds and maintains a behavioural specification alongside your code, capturing what the system should do in a form that persists across sessions. Paired with a CLI that validates syntax and draws semantic inferences, it catches design gaps, surfaces implications you missed and generates tests from the formal behaviours of your system.

Get started

Allium works with Claude Code, Copilot, Cursor, Windsurf, Aider, Continue and 40+ other tools. How you install depends on your editor, but the skills are the same everywhere.

Claude Code via the JUXT plugin marketplace:

/plugin marketplace add juxt/claude-plugins
/plugin install allium

Cursor, Windsurf, Aider, Continue and other skills-compatible tools:

npx skills add juxt/allium

GitHub Copilot reads skills and agents from the repository automatically. No installation needed.

Other editors: If your editor doesn't read from .agents/skills/, symlink the installed skills into wherever it does look (e.g. ln -s .agents/skills/allium .continue/rules/allium, or mklink /J on Windows). Use a symlink rather than copying; the skill files contain relative links to reference material that a copy would break.

Once installed, type /allium to get started. Allium examines your project and guides you toward the right skill, whether that's distilling a spec from existing code or building one through conversation. Once you're familiar with the individual skills, you'll likely invoke them directly.

Jump to what Allium looks like in practice.

Command-line tooling

The Allium CLI checks specs for structural problems and generates tests. It catches things language models can't do reliably on their own: tracing data flow across rules, verifying that every entity lifecycle can reach a terminal state, spotting dead ends. The LLM uses these findings to ask better questions and produce more complete specs.

The skills work without the CLI, falling back to the language reference, but installing it means every edit is formally checked and the results feed straight into the conversation.

Install via Homebrew or crates.io:

brew tap juxt/allium && brew install allium

cargo install allium-cli

See the allium-tools repo for details.

Skills and agents

Allium provides five skills, an entry point and two autonomous agents.

Skill	Purpose
/allium <prompt>	Entry point. Examines your project or the prompt and routes you to the right skill.
/elicit <feature idea> (or /allium:elicit)	Build a spec through structured conversation.
/distill <codebase area> (or /allium:distill)	Extract a spec from existing code.
/propagate <optional constraints> (or /allium:propagate)	Generate tests from a spec.
/tend <optional constraints> (or /allium:tend)	Targeted changes to existing specs.
/weed <optional constraints> (or /allium:weed)	Find and fix divergences between spec and code.

How skills appear depends on your editor. Some show the fully qualified form (/allium:weed), others show the short form (/weed), and some support both. If one form isn't recognised, try the other. Skills also auto-trigger when you open or edit .allium files.

Tend and weed are also available as autonomous agents that run in their own context, keeping Allium syntax out of your main session. Claude Code picks up agents from agents/, Copilot from .github/agents/. How editors discover skills and agents is still settling; we make these available in the most portable formats we can and expect to consolidate as conventions stabilise. If your editor doesn't pick something up, raise an issue.

For larger codebases, distillation and other ambitious tasks may need several passes to capture everything. Consider an iterative approach like the Ralph Wiggum loop, repeating until there's nothing further to do.

Why not just point the LLM at the code?

Within a session, meaning drifts: by prompt ten or twenty, the model is pattern-matching on its own outputs rather than the original intent. Across sessions, knowledge evaporates entirely. Modern LLMs navigate codebases effectively, but the limitation appears when you need to distinguish what the code does from what it should do. Code captures implementation, including bugs and expedient decisions. The model treats all of it as intended behaviour.