Skip to content

Getting Started

This guide takes you from zero to your first working session with RaiSE. Follow it top to bottom — everything you need is on this page.

What is RaiSE?

RaiSE is a methodology and toolkit for reliable AI software engineering. It turns AI coding assistants from unpredictable generators into disciplined collaborators — through governance, memory, and structured workflows.

You work through three collaborating parts:

  • You decide what to build and why. You own the judgment.
  • Rai is your AI partner. It executes with accumulated memory and follows your rules.
  • RaiSE provides the discipline — skills, governance, and quality gates.

The result: AI that learns from your project, follows your rules, and compounds knowledge across sessions instead of starting fresh every time.

Upgrading from a previous version?

  • From 2.x → 3.0: breaking changes — see the migration guide.
  • From venv/pip install → binary: RaiSE 3.1+ ships as a standalone binary. See Migrating venv to Binary — no more Python or uv dependency.
  • From 3.0 → 3.1: rebuild the graph (rai graph build), env prefix RAI_* → RAISE_*, session continuity scoped per worktree.

Step 1: Install the CLI

One command. RaiSE ships as a standalone binary — no Python, uv, or virtual environment needed.

# Linux / macOS
curl -fsSL https://github.com/humansys/raise/releases/latest/download/install.sh | bash

# Windows (PowerShell)
irm https://github.com/humansys/raise/releases/latest/download/install.ps1 | iex

Verify it worked:

rai --version

Prerequisites: Git (the only hard requirement) and Claude Code (recommended AI assistant).

Need more options?

Pin a specific version, install from source, or troubleshoot PATH issues — see the Installation Guide.

Step 2: Set up your project

Navigate to your project root and run:

cd your-project
rai onboard

rai onboard detects your repo state (new project or existing codebase) and routes you to the right setup automatically. It runs rai init --detect --yes for brownfield projects and rai init --yes for greenfield ones.

Manual alternative

You can initialize manually if you prefer more control:

cd your-project
rai init --detect

The --detect flag analyzes your existing code and detects conventions (naming, testing, formatting).

cd your-project
rai init

This creates the .raise/ directory — project metadata, configuration, and a place for memory to accumulate.

Step 3: Meet Rai

Open Claude Code in the project directory. Run:

/rai-welcome

This is a one-time setup. It creates your developer profile — the only mandatory question is your name. It detects your project type automatically and points you to the next step.

Step 4: Set up your project

Now set up governance — the rules, principles, and architecture that Rai will follow when working in your project.

/rai-project-onboard

This discovers your codebase conventions, reads existing documentation (README, ARCHITECTURE, etc.), and asks only what code can't tell it. It runs discovery automatically — you don't need to run anything else first.

Want more control?

You can run /rai-discover before /rai-project-onboard to review what was detected. The onboard skill will use those results instead of running discovery again.

/rai-project-create

This guides you through defining your project's principles, requirements, and rules from scratch.

Both skills write governance documents and build a knowledge graph. After this step, Rai understands your project.

Step 5: Start your first session

From now on, every time you open Claude Code to work, start with:

/rai-session-start

This loads your project's context, memory, and patterns. Rai proposes what to work on based on pending items and recent history.

Sessions are 1:1 with your AI assistant sessions — start one, do focused work, close it:

/rai-session-close

This captures what happened, persists patterns, and sets up continuity for next time. Every session makes the next one smarter.

The three work cycles

RaiSE organizes work in three nested cycles. You don't need to use all three from day one — start with sessions and stories.

Sessions

A session is one focused working period. Open with /rai-session-start, close with /rai-session-close. Sessions build continuity — what you learn today carries into tomorrow through memory and patterns.

Stories

A story is the unit of deliverable work — a feature, a fix, a refactor. Every story follows the same rhythm:

Step Skill What happens
Scope /rai-story-start Create branch, define what's in and out
Design /rai-story-design Read the code, specify the approach
Plan /rai-story-plan Break into atomic tasks
Build /rai-story-implement TDD: test → code → verify → commit per task
Reflect /rai-story-review What did we learn? Capture patterns
Ship /rai-story-close Merge, clean up, update tracking

Start with a small feature — something you can finish in one session. Get the rhythm first, then scale up.

→ Walk through your first story step by step

Epics

An epic is a body of work spanning 3–10 stories. Use epics when a feature is too big for a single story:

Step Skill What happens
Start /rai-epic-start Define scope and brief
Design /rai-epic-design Break into stories
Plan /rai-epic-plan Sequence and prioritize
Work [story cycle per story] Execute each story
Close /rai-epic-close Retrospective and cleanup

You don't need epics for your first few stories. They become useful once you're comfortable with the story cycle.

What's next

You're set up. Here's where to go from here: