Skip to content
RaiSE Framework RaiSE Docs

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

Section titled “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.

Install

Section titled “Install”
Terminal window
pip install rai-cli

Verify:

Terminal window
rai --version

Initialize a project

Section titled “Initialize a project”
Terminal window
cd your-project
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:

Terminal window
rai init --detect

Your first session

Section titled “Your first session”

Set up your developer profile (first time only):

Terminal window
rai session start --name "Your Name" --project .

After that, start sessions with a context bundle:

Terminal window
rai session start --project . --context

The --context flag outputs a token-optimized bundle (~150 tokens) with your developer profile, session state, and memory patterns. Pass it to your AI assistant — it gives full awareness of where you are and what you’re working on.

The story lifecycle

Section titled “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

Section titled “End a session”

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

Terminal window
rai session close --summary "What I accomplished" --type feature --project .

Build your memory

Section titled “Build your memory”

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

Terminal window
rai memory build

Then query it:

Terminal window
rai memory query "testing patterns"

What’s next

Section titled “What’s next”