███████████ ███
░░███░░░░░███ ░░░
░███ ░███ ████████ ██████ █████ █████ ████ █████
░██████████ ░░███░░███ ░░░░░███ ░░███ ░░███ ░░███ ███░░
░███░░░░░░ ░███ ░░░ ███████ ░░░█████░ ░███ ░░█████
░███ ░███ ███░░███ ███░░░███ ░███ ░░░░███
█████ █████ ░░████████ █████ █████ █████ ██████
░░░░░ ░░░░░ ░░░░░░░░ ░░░░░ ░░░░░ ░░░░░ ░░░░░░
Praxis is a development framework that bridges Intent‑Driven Development (IDD) and Spec‑Driven Development (SDD) into a single, coherent workflow.
It relays on Intended and OpenSpec.
Praxis helps teams start from why they are building something, derive what must be built in the form of explicit specifications, and continuously verify that the how (the code) never diverges from the original intent.
It is designed to be:
- AI‑native (usable from AI chats inside modern IDEs)
- CLI‑first (works without any IDE or AI integration)
- Intent‑centric (intent is the primary source of truth)
An Intent describes the purpose, value, and constraints of a feature or system. It answers the question:
Why are we building this?
Intents are technology‑agnostic and do not describe APIs, UI, or implementation details.
A Specification is a formal, verifiable description derived from an Intent. It answers the question:
What must the system do to satisfy the intent?
Specs act as contracts and can be translated into:
- behavioral rules
- acceptance criteria
- API contracts
- test cases
Praxis continuously checks for semantic drift:
- specs that no longer satisfy the intent
- code that implements features not justified by any intent
- Create, update, and validate intents
- Enforce intent structure and clarity
- Track intent evolution over time
- Extract capabilities, events, and states from intents
- Provide a bridge between intent and specification
- Generate initial specifications from intents
- Maintain traceability between intents and specs
- Support manual refinement without losing intent linkage
- Lock specs as formal contracts
- Validate implementations against specs
- Detect missing or incomplete implementations
- Detect features not backed by intent
- Detect intents no longer satisfied by current specs
- Slash‑command friendly design
- CLI commands that can be mapped to IDE AI chats
- Optional exposure as a local command server (e.g. MCP‑style)
.praxis/
├── intents/
│ ├── wip/ # Work-in-progress intents
│ └── archive/ # Archived intents
├── specs/ # Specifications (OpenSpec)
│ ├── wip/ # Work-in-progress specs
│ └── archive/ # Archived specs
└── templates/ # Templates for intents and specs
| Command | Description | Status/Version |
|---|---|---|
praxis init |
Initialize a new project to be used with Praxis. Templates are provided in the templates directory. |
✅ |
praxis intent create <intent-description> |
Create a new intent. | ✅ |
praxis intent update <intent-id> |
Update an existing intent. | ❔ |
praxis intent validate |
Validate all intents for completeness and consistency. | ❌ |
praxis intent list |
List all defined intents. | ✅ |
| Command | Description | Status/Version |
|---|---|---|
praxis intent model <intent-id> |
Generate or update the intent model (capabilities, events, states). | ❔ |
| Command | Description | Status/Version |
|---|---|---|
praxis spec derive --from-intent <intent-id> |
Generate initial specifications from an intent. | ✅ |
praxis spec refine <spec-id> |
Manually refine a specification while preserving intent traceability. | ❔ |
praxis spec validate <spec-id> |
Validate specs for internal consistency and completeness. | ❌ |
praxis spec apply <spec-id> |
Implement a specification in code. | ✅ |
praxis spec archive <spec-id> |
Archive a specification implemented. | ✅ |
praxis spec delete <spec-id> |
Delete a specific spec. | ✅ |
praxis spec delete --from-intent <intent-id> |
Delete all specs generated from an intent. | ❌ |
praxis spec lock <spec-id> |
Lock a specification as a formal contract. | ❔ |
praxis spec list --from-intent <intent-id> |
List all specifications and their associated intents. | ❌ |
praxis spec check |
Verify implementation compliance against locked specs. | ❔ |
| Command | Description | Status/Version |
|---|---|---|
praxis analyze impact --from-intent <intent-id> |
Analyze the impact of changes to an intent on specs and code. | ❔ |
praxis analyze drift |
Detect intent/spec/code drift. | ❔ |
| Command | Description | Status/Version |
|---|---|---|
praxis serve |
Expose Praxis commands through a local service for IDE or AI integration. | ❔ |
praxis commands |
List all available commands in machine‑readable form. | ❔ |
When integrated into an IDE or AI‑enabled editor, Praxis commands can be invoked as slash commands:
/praxis-intent-create
/praxis-spec-derive
/praxis-intent-check
The underlying behavior is identical to the CLI.
The following diagram illustrates how Intents and Specifications integrate into a standard development lifecycle.
┌────────────┐
│ Intent │
│ (WHAT) │
│ (WHY) │
└─────┬──────┘
│
▼
┌──────────────────┐
│ Intent Modeling │
│ (Capabilities, │
│ Events, States) │
└────────┬─────────┘
│
▼
┌────────────┐
│ Specs │
│ (WHAT) │
└─────┬──────┘
│
┌──────────┼──────────┐
│ │ │
▼ ▼ ▼
Tests Contracts Scenarios
│
▼
┌────────────┐
│ Code │
│ (HOW) │
└─────┬──────┘
│
▼
┌─────────────────┐
│ Validation & │
│ Drift Detection │
└─────┬───────────┘
│
└───────────────┐
▼
Intent Check
- Before coding: intents and specs are defined and validated
- During coding: specs act as executable and contractual guidance
- After changes: drift detection ensures alignment with original intent
This allows Praxis to integrate seamlessly with existing workflows such as:
- Agile / Scrum
- TDD / BDD
- CI/CD pipelines
- Intent is sacred: everything must trace back to a reason.
- Specs are contracts: informal requirements are not enough.
- Code must justify itself: no feature without intent.
- AI is an assistant, not the authority: Praxis remains deterministic and auditable.
Praxis is written in TypeScript and distributed as a Node.js CLI.
- Node.js >= 18
- npm (or compatible package manager)
You can verify your environment with:
node --version
npm --version
To install Praxis globally and make the praxis command available system-wide:
npm install -g praxis
After installation, verify it works:
praxis --help
You can also install Praxis as a development dependency inside a project:
npm install --save-dev praxis
Then run it via:
npx praxis --help
When installed locally or globally, Praxis commands can be mapped to:
- IDE extensions (e.g. VS Code)
- AI chat slash commands
- local tool servers (e.g. via
praxis serve)
The installation method does not change Praxis behavior; it only affects how commands are invoked.
Praxis is under active development. APIs, command names, and file formats may evolve.