allium

Capture observable software behavior with a formal specification language.

5|4|Updated Mar 10, 2026

Search Tags:#test-generation #formal-language #allium #specification-language #behavior-specification #domain-specification

Ready to run

npx skills add https://github.com/editor-code-assistant/eca-plugins --skill allium-editor-code-assistant

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: allium
Source: https://github.com/editor-code-assistant/eca-plugins/tree/main/plugins/allium/skills/allium
Command: npx skills add https://github.com/editor-code-assistant/eca-plugins --skill allium-editor-code-assistant

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Allium provides a formal language for capturing software behaviour at the domain level, sitting between informal feature descriptions and implementation, to specify observable behaviour without prescribing how it's built.

The approach helps teams surface ambiguities early and produce language-driven specs that can be used to generate integration tests.

Core Features & Use Cases

Describes observable behaviour, not implementation details.
Generates integration and end-to-end tests from specifications.
Enables cross-team alignment on domain rules before coding.

Quick Start

Write a simple Allium spec to model a domain feature and generate tests from it.

Frequently Asked Questions about allium

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I capture domain behavior in a formal specification language for test generation?▼

You capture domain behavior using a formal specification language to model observable software actions, which then drives precise test generation. Allium specifies domain-level rules and triggers without prescribing implementation details.

What is the best way to write implementation-agnostic behavior specifications for software projects?▼

Implementation-agnostic behavior specifications describe what a system does rather than how it is built. Using a formal language like Allium clarifies domain rules and observable triggers before coding begins.

Can I generate integration tests directly from domain-level specifications?▼

Yes, you can generate integration and end-to-end tests directly from domain-level specifications. Allium applies formal language syntax for entities, rules, and triggers to produce these tests automatically.

How do formal behavior specifications help surface ambiguities in software features?▼

Formal behavior specifications surface ambiguities by forcing teams to define observable domain rules precisely. Allium sits between informal feature descriptions and implementation to align cross-team understanding before coding.

Does behavior-driven specification work for domain-level rules without coupling to implementation?▼

Yes, behavior-driven specification works at the domain level without implementation coupling. Allium captures observable behavior through formal syntax for entities and triggers, remaining completely implementation-agnostic.

What are the limitations of using a formal specification language for test generation?▼

The limitation of formal specification for test generation is that it requires upfront domain rule definition before specifying triggers. Allium focuses on observable behavior, meaning internal implementation logic is not captured in the spec.