Glossary
The glossary defines each term Athenode uses in the web app, the Athenode CLI and the documentation in one sentence and links to the page that covers it.
Terms for the product and its tools
| Term | Definition | Covered in |
|---|---|---|
| Athenode | Athenode is a spec-driven development platform where you think a product through before your AI coding agent writes code. | Athenode documentation |
| spec-driven development (SDD) | Spec-driven development is a way of building software in which the work is written down as a specification before an AI coding agent writes the code. | The spec-driven development guide |
| web app | The web app is the Athenode interface in your browser, where you work with projects, specifications, setups, ToDo cards, members and the plan. | Core concepts |
| Athenode website | The Athenode website is athenode.com, which holds the documentation and the public pages of the setup library. | The setup library catalogue |
| Athenode CLI | The Athenode CLI is the command-line tool athenode from the package @athenode/cli, which connects a directory to a project, installs a setup and reads and changes the project's content. |
Athenode CLI reference |
| Athenode MCP server | The Athenode MCP server is the server named athenode through which an AI agent reads and changes specifications, ToDo cards and setups. |
Athenode MCP server |
| AI coding tool, AI tool | An AI coding tool is the product you write code with, such as Claude Code, Codex or Cursor. | Supported AI tools |
| AI coding agent, AI agent | An AI coding agent is what does the work in a session of your AI tool, from asking questions to implementing a specification. | The Athenode workflow |
Terms for projects, members and plans
| Term | Definition | Covered in |
|---|---|---|
| project | A project is the container you create in the web app for one specification tree, its agent setups, ToDo cards, members, project tokens and plan. | Projects |
| member | A member is a person with access to a project, in the role of owner, editor or viewer. | Invite and manage members |
| owner | The owner is the member who created the project and the one who invites members, changes the plan and deletes specifications or the project. | Roles and permissions |
| editor | An editor is a member who creates and changes specifications, setups and ToDo cards and can create project tokens. | The role matrix |
| viewer | A viewer is a member who can read everything in a project and cannot change its content. | What each role can do |
| invite | An invite gives a person access to a project by email, as an editor or a viewer. | Invites |
| plan | A plan is what a project is subscribed to (Free, Solo, Team or Business) and sets the project's limits. | Plans and limits |
| project token | A project token is a personal access token that lets the Athenode CLI, and your AI agent through it, act on one project. | Project tokens |
| local project directory | The local project directory is the folder on your computer, normally the repository root, where you run init and where .athenode/config.json is kept. |
Install a setup |
Terms for specifications
| Term | Definition | Covered in |
|---|---|---|
| specification | A specification is one described piece of work, with a title, a summary, Markdown content, a status and its own questions and answers. | Specifications |
| specification tree | The specification tree is the hierarchy of a project's specifications, in which any specification can have sub-specifications to any depth. | The specification tree |
| sub-specification | A sub-specification is a specification that has another specification as its parent. | Specifications in the web app |
| leaf specification | A leaf specification is a specification with no sub-specifications, and leaves are what an AI agent implements. | Leaf specifications |
| deliverable | A deliverable is the word the web app uses for a leaf specification where it counts them, as in the Orbit view. | The Orbit view |
| specification id | A specification id identifies one specification in skills and commands, and Copy ID copies it in the web app. | Copying a specification id |
| status | A status says where a specification is in its life: Draft, Prepared, Processing or Completed. | Statuses |
| Draft | Draft is the status of a specification that is being shaped. | The four statuses |
| Prepared | Prepared is the status of a specification that is finished and ready to be decomposed or implemented. | What Prepared means |
| Processing | Processing is the status of a specification that an AI agent is planning or implementing. | Statuses during an apply run |
| Completed | Completed is the status of a specification that is implemented, and reviewed when review is on. | How statuses move |
| blocker | A blocker is a dependency between two specifications: a specification that is blocked by another is implemented after it. | Blockers |
| questions and answers | Questions and answers are the record of the clarifying questions an AI agent asked about a specification and the answers you gave. | Questions and answers |
| implementation plan | An implementation plan is the plan an AI agent records for a leaf specification before it implements the leaf. | The implementation plan |
| Tree view | The Tree view is the view of the Specifications page that lists the specification tree with a search box and a status filter. | Browsing the Tree view |
| Orbit view | The Orbit view is the view of the Specifications page that draws the specification tree as rings around a centre that shows how much is done. | Browsing the Orbit view |
| search by meaning | Search by meaning finds the specifications that match what a query means as well as those that contain its words. | Search by meaning |
Terms for the workflow
| Term | Definition | Covered in |
|---|---|---|
| mind map | A mind map is a session in which your AI agent asks rounds of questions and turns your answers into a specification. | Mind map: /atn-mindmap |
| decompose | To decompose a specification is to break it down into one level of stages, each a sub-specification of its own. | Decompose: /atn-decompose |
| stage | A stage is a sub-specification that decomposing a specification creates. | Stages of a decomposition |
| apply | To apply a specification is to have your AI agent plan and implement each leaf under it, in the order the blockers allow, with tests, review and git handled as your workflow settings say. | Apply: /atn-apply |
| apply run | An apply run is one execution of /atn-apply on a specification or a subtree. |
An apply run |
| workflow settings | Workflow settings are a project's choices for gitflow, testing, code review and methodology, which the workflow skills follow. | Settings: /atn-settings |
| sub-project | A sub-project is a folder of a repository that has its own workflow settings. | Sub-projects in /atn-settings |
Terms for agent setups
| Term | Definition | Covered in |
|---|---|---|
| agent setup, setup | An agent setup is a named bundle of what your AI coding tools work with: skills, agents, rules, MCP servers and setup files. | Agent setups |
| standard Athenode setup | The standard Athenode setup is the setup with the workflow skills and their agents, of which every project starts with its own copy. | Standard Athenode setup |
| installed setup | The installed setup is the setup whose files are in a local project directory, chosen when you run init. |
The installed setup |
| install | To install a setup is to have the Athenode CLI write it into your repository in the format each selected AI tool reads. | Install a setup |
| setup id | A setup id identifies one setup in CLI commands, and athenode setups list prints it with the setup's slug, which init --setup accepts as well. |
The setups commands |
| skill | A skill is a reusable set of instructions that an AI tool loads when it is relevant, usually run as a slash command such as /atn-mindmap. |
Skills in a setup |
| bundle files | Bundle files are the files a skill carries next to its instructions. | Bundle files of a skill |
| agent | An agent is a specialist that an AI tool can hand work to (a subagent in most AI tools). | Agents in a setup |
| rules | Rules are the instructions every agent in a setup follows. | Rules in a setup |
| Athenode rules block | The Athenode rules block is the part of a rules file such as AGENTS.md or CLAUDE.md, between two marker lines, where Athenode writes the rules of the installed setup. |
The Athenode rules block |
| MCP server | An MCP server is a connection to an external tool server that the agents of a setup may use. | MCP servers in a setup |
| setup files | Setup files are the extra Markdown files stored with a setup, such as references that its skills and agents read. | Setup files and settings |
| settings files | Settings files are the setup files under settings/, which hold a project's workflow settings. |
The settings files |
| clone | To clone a setup is to copy the whole setup under another name inside a project. | Create and organise setups |
| pull | To pull is to copy skills, agents, MCP servers, setup files or rules from another setup into a setup, once. | Pull from another setup |
| setup cards | Setup cards are the row at the top of the Setups page that shows one card for each setup of the project. | The Setups page |
| blueprint | The blueprint is the part of the Setups page that maps the rules, files, skills, agents and MCP servers of the selected setup. | The blueprint |
| inspector | The inspector is the panel of the Setups page that opens the part you select in the blueprint. | The inspector |
Terms for the setup library
| Term | Definition | Covered in |
|---|---|---|
| setup library | The setup library is the shared catalogue of agent setups that projects have published. | Setup library |
| library entry, entry | A library entry is a setup that a project published to the setup library, with a name, a description, tags, a publisher, versions and likes. | Library entries |
| add | To add an entry is to copy it into your project as a setup of its own. | Adding an entry |
| merge | To merge an entry is to bring its skills, agents, MCP servers, setup files and rules into a setup you have. | Merging an entry |
| update | To update a setup added from the library is to bring it to the latest version of its entry. | Updating from the library |
| publish | To publish a setup is to make it a library entry, or the next version of the entry it has. | Publish a setup |
| public display | Public display is the setting that shows a library entry on the Athenode website to people without an account. | Public display of an entry |
Terms for ToDo cards
| Term | Definition | Covered in |
|---|---|---|
| ToDo card, card | A ToDo card is a short note of work to do later: a follow-up, tech debt, a bug or an idea. | ToDo cards |
| card status | A card status is Open, Done or Dismissed, and every card starts as Open. | Card statuses |
| card type | A card type says what kind of work a card is: Bug, Tech debt, Follow-up or Idea. | Card types and priorities |
| open questions | Open questions are the decisions that have to be made before a card is carried out. | Open questions of a card |
| carry out directly | To carry out a card directly is to have your AI agent implement it without a specification. | Card queue: /atn-todo-dequeue |