Skip to content

Getting Started

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.

The Triad

RaiSE works through three collaborating parts:

    You (Strategy, Judgment, Ownership)
         │
         │ collaborates with
         ▼
      Rai (AI Partner — Execution + Memory)
         │
         │ governed by
         ▼
      RaiSE (Methodology + Toolkit)

You decide what to build and why. Rai executes with accumulated memory and calibrated judgment. RaiSE provides the discipline — skills, governance, and quality gates — that makes the collaboration reliable.

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

Prerequisites

The install script handles Python and uv automatically — no manual setup needed.

Upgrading from 2.x?

See the migration guide for breaking changes in 3.0 before you upgrade.

Install

Run the install script inside your project directory — it creates a per-project virtual environment with the correct version:

# Linux / macOS
cd your-project
curl -LsSf https://docs.raiseframework.ai/install.sh | bash
source .venv/bin/activate

# Windows (PowerShell)
cd your-project
irm https://docs.raiseframework.ai/install.ps1 | iex
.venv\Scripts\Activate.ps1

The script installs uv if needed, creates .venv, installs raise-cli, and verifies the installation automatically.

Verify:

rai --version

For full options (pre-release, specific version, manual install) see the Installation Guide.

Initialize a project

Navigate to your project directory first — rai init works on the current directory:

cd your-project    # You MUST be in the project root
rai init

This creates the .raise/ directory with governance templates, memory structure, and a project manifest. For existing codebases, add --detect to analyze your conventions automatically:

rai init --detect

Your first session

Open your AI assistant (Claude Code) in the project directory. For first-time setup, run the welcome skill:

/rai-welcome

This creates your developer profile, builds the knowledge graph, and verifies everything works.

After that, start every session with:

/rai-session-start

This loads your context, memory, patterns, and proposes focused work. You work through skills — they orchestrate the CLI for you.

The story lifecycle

This is the core rhythm of working with RaiSE. Every piece of work follows six steps:

/rai-story-start     → Scope: what are we building?
/rai-story-design    → Spec: how will it work?
/rai-story-plan      → Tasks: what are the steps?
/rai-story-implement → Build: test, code, verify, commit
/rai-story-review    → Reflect: what did we learn?
/rai-story-close     → Merge: clean up and ship

Each step produces an artifact that feeds the next. The review feeds memory, which feeds future sessions. This is how learning compounds — not through magic, but through disciplined repetition.

Start with a small feature (XS or S sized). Get the rhythm first, then scale up.

→ Walk through the full lifecycle for a step-by-step guide.

End a session

When you're done working, close the session to capture what happened:

/rai-session-close

This reflects on outcomes, persists patterns, and records session data for continuity.

Build your memory

As you work, RaiSE accumulates knowledge — patterns, calibration data, governance. Build the unified memory index to make it queryable:

rai graph build

Then query it:

rai graph query "testing patterns"

What's next