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.

Prerequisites

Section titled “Prerequisites”
  • Python 3.12 or 3.13 (3.14 is not yet supported — many dependencies lack wheels)
  • Git initialized in your project
  • An AI assistant with RaiSE skills: Claude Code (recommended), Cursor, or Windsurf

Install

Section titled “Install”

The recommended method is pipx (isolates RaiSE in its own environment):

Terminal window
pipx install rai-cli

Alternatives:

Terminal window
# With pip (use a virtual environment)
pip install rai-cli


# With uv
uv tool install rai-cli

macOS note: Do not use the system Python that ships with macOS. Install Python 3.12 or 3.13 via Homebrew (brew install python@3.13) or pyenv first.

Windows: Use WSL (Ubuntu/Debian):

Terminal window
sudo apt update && sudo apt install pipx -y
pipx ensurepath
# Close and reopen terminal
pipx install rai-cli

Verify:

Terminal window
rai --version

Troubleshooting

Section titled “Troubleshooting”
ProblemCauseFix
Build errors during installPython 3.14 or missing C compilerUse Python 3.12 or 3.13
command not found: raipipx/pip bin not in PATHRun pipx ensurepath or add ~/.local/bin to PATH
Permission errorsInstalling to system PythonUse pipx instead of pip, or use a virtual environment

Initialize a project

Section titled “Initialize a project”

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

Terminal window
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:

Terminal window
rai init --detect

Your first session

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

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:

/rai-session-close

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

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 graph build

Then query it:

Terminal window
rai graph query "testing patterns"

What’s next

Section titled “What’s next”