# Init

> Initialize a new project or workspace with .memory/ tracking structure.

- Skill: `torarnv/init` (Agent Skill)
- Install (CLI): `npx skillmds@latest add torarnv/init`
- Raw SKILL.md: https://api.skillmd.com/api/skills/torarnv/init/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: torarnv (https://skillmd.com/u/torarnv)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/torarnv/init

---


# Project Initialization Skill

Sets up a `.memory/` structure for persistent multi-session tracking,
and a `.claude/CLAUDE.md` entry point that loads memory automatically every session.

## Workflow

### Step 1: Choose mode

Use `AskUserQuestion` to ask whether this is a **project** or **workspace**:

- **Project** — a focused effort with a clear scope, spec, and phased plan.
  Examples: building a feature, a new app, a library.
- **Workspace** — an ongoing environment where tasks are largely independent.
  Examples: dotfiles, personal scripts, a monorepo with unrelated work streams.

### Step 2: Interview the user

Ask conversationally — one or two questions at a time, not all at once.
Adapt based on what the user has already shared in the conversation.

1. **What are you building / what is this workspace for?**
2. **What problem does this solve / what's the goal?**
3. **What's explicitly out of scope?** (things you are NOT doing)
4. **What tech stack, languages, or frameworks?**
5. **Any key constraints or non-negotiables?**

Do NOT use `AskUserQuestion` for these — they need free-form text answers.

If the user has already described the project, skip what you already know and confirm.

### Step 3: Create the structure

#### Both modes

Create or update `.claude/settings.json` to include:

```json
{
  "autoMemoryEnabled": false
}
```

If the file already exists, merge — preserve any existing keys and add/update only this.

Create `.memory/` containing:
- `MEMORY.md` — index file (template below)
- `status.md` — current state snapshot (template below)

Create or update `.claude/CLAUDE.md` with the `@.memory/MEMORY.md` import.

#### Project mode additionally

Create:
- `.memory/spec.md` — project goal (template below)
- `.memory/plan.md` — phases and open questions (template below)
- `.memory/features/` — directory for per-feature tracking (add `.gitkeep`)

Add `spec.md` to the `MEMORY.md` index.

#### Workspace mode additionally

Create:
- `.memory/tasks/` — directory for per-task files (add `.gitkeep`)

No root `spec.md` or `plan.md` — those belong inside individual task files.

### Step 4: Populate the files

Use the templates below. Replace `{{placeholders}}` with interview content.

#### `.memory/MEMORY.md`

```markdown
# Project Memory

- [Project Status](status.md) — {{one-liner current state}}
```

Project mode also adds:
```markdown
- [Specification](spec.md) — {{one-liner project goal}}
```

Keep this index concise — one line per file, ~150 chars max per entry.
Add entries as new topic files are created. `diary.md` is NEVER listed here.

#### `.memory/status.md`

```markdown
---
name: Project Status
description: {{one-liner current state}}
type: status
---

**Phase**: Not started
**Focus**: Project setup complete. Ready to begin.
**Last updated**: {{today's date}}

## In Progress

_Nothing yet._

## Blocked

_Nothing._

## Next Up

- [ ] Review and refine spec
- [ ] Break spec into phases in plan.md
- [ ] Identify first task to work on

## Recent Completions

- [x] Project initialized
```

#### `.memory/spec.md` (project mode)

```markdown
---
name: Specification
description: {{one-liner project goal}}
type: spec
---

# {{Project Name}} — Specification

## Overview

{{1-2 sentence description}}

## Goals

{{Primary goal and sub-goals, as bullet points}}

## Non-Goals / Out of Scope

{{What we are NOT building, as bullet points}}

## Tech Stack

{{Languages, frameworks, platforms, key dependencies}}

## Constraints

{{Non-negotiables, compatibility requirements, performance budgets}}
```

#### `.memory/plan.md` (project mode)

```markdown
---
name: Plan
description: Phases and open questions
type: plan
---

# {{Project Name}} — Plan

## Phases

_Break the spec into sequential phases here. Each phase should be achievable
in a few sessions._

### Phase 1: {{Name}}

- [ ] {{Task}}

## Open Questions

_Questions that need answers before or during implementation._
```

#### `.claude/CLAUDE.md`

If `.claude/CLAUDE.md` does not exist, create:

```markdown
# {{Project Name}}

{{1-2 sentence description}}

## Project Memory

@.memory/MEMORY.md

_Topic files are loaded on demand — read them when relevant, not every session._

## Memory Routing

When the user says "remember X", "note that", "record this", or anything similar,
always handle it by invoking the `/cpr:memory` skill. Never use the built-in
auto-memory system — it is disabled for this project.
```

If `.claude/CLAUDE.md` already exists, add the `@.memory/MEMORY.md` import under
an appropriate heading.

### Step 5: Confirm and suggest next steps

Mention that `.claude/settings.json` was written with auto-memory disabled.

Tell the user what was created. Suggest 2-3 concrete next steps:
- **Project mode**: review `spec.md`, define phases in `plan.md`, identify first feature
- **Workspace mode**: create the first task file in `tasks/`

Also mention how to use the project going forward:

> To work on this project, use these skills:
> - `/cpr:start` — Begin a session and see current state
> - `/cpr:end` — End a session and save progress
> - `/cpr:memory` — Record persistent information
> - `/cpr:research` — Investigate topics or explore code

Keep it to 3-4 lines — don't overwhelm.