A document discipline for AI-assisted software development. HELIX is a methodology and artifact catalog: templates for the documents your project needs at every level — vision, requirements, design, tests, deploy, metrics — plus a single alignment skill that keeps them in sync as the work moves.
HELIX runs on runtimes. DDx is the reference runtime — it provides the agent runtime, the tracker, and the execution loop that turn aligned artifacts into running code. Databricks Genie and Claude Code are target runtimes. HELIX itself is content (templates, prompts, methodology spec) plus the alignment skill. HELIX ships no checkout CLI; alignment, queue control, tracker behavior, and the broader historical command surface belong to runtimes like DDx.
Documentation · Demo Reels · Getting Started
Use the standard startup script when reviewing the Hugo site locally:
bash website/scripts/serve-local.shThe local review site lives at http://eitri:1315/helix/. Keep /helix in
review URLs; root paths such as http://eitri:1315/artifact-types/... are not
the local site shape and should be treated as invalid.
Regenerate published site content after changing artifact types, project artifacts, or resource summaries:
python3 scripts/generate-reference.py
python3 scripts/publish-artifacts.py
python3 scripts/publish-resources.pyHELIX names seven kinds of work in software development:
| Activity | Owns artifact types like… |
|---|---|
| Discover | Product vision, business case, competitive analysis, opportunity canvas |
| Frame | PRD, feature specifications, user stories, principles, cross-cutting requirements |
| Design | Architecture, ADRs, solution designs, technical designs, contracts |
| Test | Test plans, story test plans, security tests |
| Build | Implementation plan, executed work in the runtime's tracker |
| Deploy | Runbook, deployment checklist, monitoring setup, release notes |
| Iterate | Metric definitions, metrics dashboard, improvement backlog |
Activities are connected by an artifact authority hierarchy — vision governs PRD, PRD governs features, features govern designs, designs govern tests, tests govern code. When two artifacts disagree, the higher one wins. Work moves between activities in every direction: a failing test reveals a missing requirement; a production metric revises the PRD; a vision update propagates downstream.
HELIX runs on several runtimes. Pick the one you already use; each install guide
under docs/install/ has the full procedure.
The fastest path to running HELIX is the DDx runtime.
First, install DDx:
curl -fsSL https://raw.githubusercontent.com/DocumentDrivenDX/ddx/main/install.sh | bashThen install HELIX as a DDx plugin:
ddx install helixThis adds HELIX's artifact-type catalog and alignment skill to your DDx
project. You'll also want an agent runtime —
Claude Code or codex — plus git.
The HELIX repo is itself a Claude Code plugin. Inside a Claude Code session, add the marketplace and install the plugin:
/plugin marketplace add DocumentDrivenDX/helix
/plugin install helix@helix
For automation or a Dockerfile, use the scripted CLI equivalent:
claude plugin marketplace add DocumentDrivenDX/helix
claude plugin install helix@helix --scope user -yFull procedure: docs/install/claude-code.md.
HELIX installs into Codex as an agentskills.io-compliant routing skill via the Skills CLI (needs Node.js):
npx skills add DocumentDrivenDX/helix -a codexCodex auto-discovers the skill at session start. Full procedure, including a
Node-free filesystem copy: docs/install/codex.md.
From inside a Databricks notebook, the kernel already carries workspace credentials. Run this in a Python cell:
%pip install --quiet databricks-sdk PyYAML
import urllib.request, runpy
urllib.request.urlretrieve(
"https://github.com/DocumentDrivenDX/helix/releases/latest/download/genie-install",
"/tmp/genie_install.py",
)
g = runpy.run_path("/tmp/genie_install.py")
g["install"]() # user-scoped; g["install"](shared=True) for workspace-wideFrom a dev box or CI, set DATABRICKS_HOST + DATABRICKS_TOKEN (or
DATABRICKS_PROFILE) and run the genie-install
release asset directly. Full procedure:
docs/install/databricks-genie.md.
Shape intent into governed work, then let DDx drain the ready queue:
/helix input "Build a REST API for managing bookmarks"
ddx workThe first slash command invokes the HELIX skill against your project's artifacts, identifies what needs to change to support the new intent, and emits work items in the DDx tracker. The second runs DDx's bounded execution loop, dispatching agents to drain the queue. As work happens, the alignment skill keeps the governing artifacts in sync.
Inside a Claude Code session, HELIX is available through a single skill that routes to the appropriate mode:
| Command | What it does |
|---|---|
/helix input "build a bookmarks API" |
Shape intent into governed work items |
/helix align |
Reconcile the artifact tree top-down; emit a plan |
/helix frame |
Create or refine vision, PRD, feature specs |
/helix design auth |
Iteratively design a subsystem |
/helix evolve "add OAuth" |
Thread a new requirement through the artifacts |
/helix review |
Fresh-eyes review of recent work |
HELIX project artifacts live under docs/helix/:
docs/helix/
├── 00-discover/ # Vision, business case, competitive analysis
├── 01-frame/ # PRD, feature specs, user stories
├── 02-design/ # Architecture, ADRs, solution designs, technical designs
├── 03-test/ # Test plans
├── 04-build/ # Implementation plans, executed work evidence
├── 05-deploy/ # Runbooks, monitoring, release notes
└── 06-iterate/ # Metrics, improvement backlog, alignment reviews
Numeric prefixes are a reading-order convention. They do not imply that activities run in sequence — they don't.
- The Thesis — what HELIX is and what it's for
- Activities — the seven kinds of work, with examples
- Artifact Types — the catalog of templates and prompts
- Artifacts — this project's own governing documents, as a worked example
- Workflow — how the alignment loop runs
DDx is where execution lives. DDx provides the work tracker (beads), the agent dispatch harness, the execution-evidence store, the document graph, and the queue-drain loop. HELIX provides the methodology, the artifact catalog, and the alignment skill that runs on top.
The split is intentional: HELIX is portable methodology + content. DDx is one runtime that knows how to run that content. Other runtimes can run the same content with their own per-runtime packages.