> Markdown twin of https://adna.network/get-started/
> Index: https://adna.network/llms.txt · Full corpus: https://adna.network/llms-full.txt
> State is a build-time snapshot generated 2026-08-30 (UTC); nothing here is live.
> Derived from the rendered page — this route has no markdown source.

*[image: Cozy pixel-art scene of a desk and computer with a glowing cyan DNA helix rising from the screen — a new aDNA workspace coming alive]*
Illustration generated with Google Imagen 4 Ultra (imagen-4.0-ultra-generate-001) in the ss-ghibli-pixel / Tokyo Night register, commissioned under ADR-032 and now governed by ADR-053.

# Get Started

Set up your own aDNA workspace — a local, agent-readable home for every project's context — in
about 5 minutes. The workspace is files on your machine and makes no network calls of its own.

ℹ Prerequisites

Git, and [Claude Code](https://docs.anthropic.com/en/docs/claude-code)
installed via `npm install -g @anthropic-ai/claude-code`. Obsidian is optional — vaults are
plain Markdown, so any editor works.

💡 What you'll have when you're done

A `~/aDNA/` workspace that ships ready: the workspace `CLAUDE.md` router
(your agent's map between projects) pre-instantiated at the root; the standard itself embedded in a hidden
`.adna/` folder (your agent reads it, never edits it — updates arrive with `git pull`
at the workspace root); and your first `<name>.aDNA/` project, scaffolded for you when the
agent follows the standard's project-fork skill, with its own git history — kept out of the workspace
image's history by design.

## What this command does, before you run it

`git clone https://github.com/aDNA-Network/aDNA.git ~/aDNA && cd ~/aDNA && claude`

- **Writes one directory: `~/aDNA/`.** Nothing outside it — no system
settings, no `PATH` changes, no daemon, no login item. If you would rather not use that path,
clone anywhere: nothing in the workspace depends on its location, and `~/aDNA` is
only the default the docs assume.
- **The `&& claude` starts an agent in that directory**, which reads the
instruction files you just cloned — `CLAUDE.md` at the root, and the standard in
`.adna/`. That is the real trust question here, and it is a fair one: these files are
prompt-ware, and prompt-ware is executed by the agent that reads it.
- **So read them first.** [Every file the agent reads on first run, annotated →](/get-started/what-your-agent-reads/)
They are shown verbatim, at a pinned commit, with hashes you can check against your own clone.
- **The workspace sends nothing anywhere.** No account, no telemetry, no network call
after the clone — it is plain Markdown on your disk. **Your agent is a separate question,
and the command above starts one:** the trailing `&& claude` launches
Claude Code, which needs an Anthropic account and sends the files it reads to Anthropic. That is
the agent's network behaviour, not the workspace's — and you can skip it, open the files in any
editor, and the workspace still works.
- **This is a Claude Code convention.** The workspace is plain Markdown that any tool can read,
but this one-command flow assumes Claude Code specifically. Other agents can read the same files; they
will not run this command.
- **To undo it: `rm -rf ~/aDNA`.** There is nothing else to uninstall.

## 1. Clone the workspace

The clone *is* your workspace — not a template you copy from. The router comes pre-instantiated
and the standard comes embedded; there is nothing to bootstrap by hand.

```
git clone https://github.com/aDNA-Network/aDNA.git ~/aDNA
```

## 2. Start Claude Code

Run `claude` in the workspace. The agent reads the router, sees a fresh workspace
with no projects yet, and walks you through creating your first one:

```
cd ~/aDNA
claude
```

ℹ What a first run looks like — not yet recorded

There was a sample transcript here. We wrote it by hand, and it showed output the software does
not actually print, so we removed it rather than leave a plausible-looking invention on the page
you use to decide whether to trust us. A real recording, from a clean machine, replaces it once
we have made that run and measured it.

In the meantime the honest version of the same thing is the source:
[read the files your agent reads](/get-started/what-your-agent-reads/), including the
project-fork skill it follows here — step by step, so you can predict what appears on disk.

With no project in the workspace yet, the router sends the agent to the standard's
project-fork skill, which scaffolds `<your_project>.aDNA/` — its [triad](/glossary/glossary-triad/) of
`what/`&thinsp;·&thinsp;`how/`&thinsp;·&thinsp;`who/`, its governance
files, and its own git history. It then offers to run an onboarding interview that customises the
new project for your domain; you can take it now or leave it for the first session inside the
project. When the scaffolding finishes, your workspace looks like this:

```
~/aDNA/
├── CLAUDE.md            # workspace router (ships with the clone)
├── .adna/               # the standard, embedded (read-only)
└── my_project.aDNA/     # your first project — a context graph
    ├── CLAUDE.md        # the project's own governance
    ├── what/            # knowledge: context, decisions, artifacts
    ├── how/             # operations: sessions, missions, skills
    └── who/             # people: roles, coordination
```

From here, work happens *inside* projects: `cd my_project.aDNA && claude`
and the agent picks up that project's governance automatically.

ℹ The whole flow, one command

Both steps, chained — auditable inline, nothing executed from the network:

`git clone https://github.com/aDNA-Network/aDNA.git ~/aDNA && cd ~/aDNA && claude`

## 3. Check it worked

"It worked" should be something you can verify, not something you feel. Five commands — the first
two print nothing and exit `0` on success; the last three print your vault list, your
project's contents, and its first commit:

```
test -f ~/aDNA/CLAUDE.md            # the router your agent reads first
test -d ~/aDNA/.adna                # the standard, embedded and read-only
ls -d ~/aDNA/*.aDNA                 # at least one project vault exists
ls ~/aDNA/<name>.aDNA/what ~/aDNA/<name>.aDNA/how ~/aDNA/<name>.aDNA/who
git -C ~/aDNA/<name>.aDNA log      # its own history, separate from the image's
```

Replace `<name>` with whatever you called your project. That the last one has its own
git log — not the workspace image's — is the check people most often skip and the one that matters:
your context graph is your repository from the first commit.

**Then the half that is actually the point.** Open a *new* agent session inside
`<name>.aDNA/` and ask it something about the project. It should already know where it
is and what the project's governance says, without you telling it where to look. The five commands
prove files were written; this proves the thing the standard exists for.

## If something goes wrong

The surface here is small — a clone and an agent launch — so the list of ways it fails is short.
These are the failures the two commands can actually produce:

- `claude: command not found` — Claude Code is not installed, or not on your
`PATH`. Install it with `npm install -g @anthropic-ai/claude-code` and open a
new shell.
- `fatal: destination path '~/aDNA' already exists` — you already have a workspace
there. Either work in it, or clone somewhere else; nothing depends on the path.
- **The agent does not seem to know about aDNA.** It is almost always started in the
wrong directory. The router is `CLAUDE.md` at the workspace root, so
`cd ~/aDNA` first — an agent launched from your home directory reads nothing.
- **You want to check what the agent is acting on.** Every file it reads on first run is
[published here verbatim](/get-started/what-your-agent-reads/), with hashes to compare
against your clone.

This list is short because it is drawn from what the commands can do, not from a support inbox.
It will grow as real installs are recorded.

## Removing it

`rm -rf ~/aDNA` — and that is the whole uninstall. Nothing was installed outside
that directory, so there is no package to remove, no configuration to revert, and no service to stop.
If you moved your projects elsewhere first, they are ordinary git repositories and keep working.

ℹ Existing installs (pre-June-2026 layout)

Installed earlier, with a cloned hidden `.adna/` plus a copied router? It keeps working:
the previous template repository is preserved read-only at
[adna-legacy](https://github.com/aDNA-Network/adna-legacy), and your clone's old URLs
redirect there — frozen, so nothing underneath you changes. To move to the current layout, run the
standard's `skill_workspace_upgrade` from your workspace.

- Try this in Claude Code
Claude Code is Anthropic's official CLI (a terminal tool for AI-assisted development). Run this tutorial step by step with AI assistance — ask questions, get unstuck, and go deeper on any concept.
`npm install -g @anthropic-ai/claude-code`

## Next steps

You just built a node in a living network. Grow it — then see where it connects: **Where it joins:** the [living registry](/vaults/) of vaults and [the network](/network/) your project can federate with — building in the open is the whole point.
- **Ready to shape it:** aDNA is built in the open — see [how to propose a change](/community/community-contribution-standards/) to the standard or contribute a pattern, vault, or idea.
- [What is aDNA?](/learn/what-is-adna) — the five-minute conceptual tour
- [The Triad](/learn/concepts/triad) — why every project splits into what / how / who
- [Tutorial: Create Your First CLAUDE.md](/learn/tutorials/first-claude-md)
- [Tutorial: Navigate a Vault](/learn/tutorials/navigate-a-vault) — reading a context graph like an agent does
- [Knowledge graphs](/learn/concepts/knowledge-graph) — what your workspace grows into
- See it live: the [aDNA repository](https://github.com/aDNA-Network/aDNA) is the workspace image itself — clone it and you are holding everything this page described.
