The RAISE Manifesto
We believe software development is entering a new era—one where powerful AI assistants are partners in creation, not mere tools. But left unchecked, AI veers off course, dilutes clarity, and creates unmaintainable systems. We created RAISE to do the opposite: amplify the creator's intent, enforce quality, and move fast without breaking things.
RAISE emerges from the ongoing evolution of software development. From the early days of machine code and assembly, through the development of procedural, functional, and object-oriented paradigms, each advancement has provided new ways to manage complexity and express human intent. AI-assisted development, when grounded by rules and driven by artifacts of intention, represents a new chapter in this ongoing story of abstraction and empowerment.
Rules provide structure. AI amplifies execution. Intention guides purpose.
RAISE—Rules and AI for Intention-driven Software Engineering—is a pre-development methodology that transforms human vision into structured artifacts. Think of RAISE as a compiler for intention: it takes your ideas and compiles them into clear, actionable documentation that any coding agent can understand and build from.
Great engineering has always been rooted in understanding user needs and clear intentions. RAISE operationalizes these principles by providing a disciplined framework that harnesses large language models effectively. This approach enables teams to translate intention into high-quality code with unprecedented speed and consistency—turning what was once aspirational into achievable reality.
Core Principles
1. Vision comes first, before code
Every project begins with a clear Vision Document that articulates what we're trying to build and why it matters. This high-fidelity expression of purpose guides all subsequent decisions.
2. Human-first, always
People are at the center of everything we build. Code should be clear, documentation should be welcoming, and the project should be accessible to new contributors.
3. AI is a partner, not just a tool
AI collaborates in the creative process while following human guidance. The human—whether creator, entrepreneur, designer, or product visionary—retains ultimate creative ownership of the product's direction, voice, and priorities, but AI actively contributes as a partner in the development journey.
4. Stories are the atomic unit of progress
User stories, derived directly from the vision, define the features that will bring it to life. They align all stakeholders around user experience and needs.
5. Living artifacts guide development
Documentation isn't an afterthought—it's a living expression of intent. Artifacts are versioned, revisable, and part of a coherent whole.
6. Clarity drives quality
Clear expression of intent in human terms leads to more focused and coherent technical implementation.
7. Intentional iteration
We value progress that reinforces our vision. Each iteration is an opportunity to learn and realign.
Methodology
RAISE is an artifact-driven methodology where living documentation guides the development process. From vision to implementation, every step is grounded in clear intention.
Core Artifacts: The Rules That Guide Development
These artifacts collectively form the rules that govern your project—not rigid constraints, but living guidelines that align human intent with AI execution:
- Vision Document - The foundation that articulates what we're building and why it matters.
- Values - Core principles guiding all decisions and trade-offs.
- User Stories - User-centered narratives that define features and acceptance criteria.
- Site Map - Structural representation of navigation and content flow.
- Architecture Decision Records - Documented rationale for significant technical choices.
- Designs - Visual and interaction blueprints for the user experience.
- Commit Messages - Structured records of changes using Conventional Commits, capturing the "why" behind each modification.
Together, these artifacts create a comprehensive rule set: Vision rules what gets built, Values rule how decisions are made, Stories rule what features matter, and so on. This is how RAISE transforms abstract intention into concrete guidance that both humans and AI can follow.
Development Practices
Version Control with Intention
Every change is made with purpose, using our core artifacts as guides. Commit messages reference relevant artifacts and decisions.
Iterative Implementation
- Vertical Slices: Each story is implemented as a complete, testable unit of value.
- Focused Execution: One story at a time, fully completed before moving on.
- Continuous Refinement: Regular review of artifacts to ensure coherence.
- Incremental Validation: Each story validates assumptions and informs adjustments.
AI Collaboration Principles
RAISE is designed around AI collaboration in two distinct phases:
Phase 1: Artifact Creation
- Ideation: AI should help articulate and refine the initial vision
- Design: AI should generate and iterate on design concepts
- Documentation: AI should help structure and polish the core artifacts
Phase 2: Implementation & Alignment
Once your RAISE artifacts are complete, any coding agent can use them as input—whether it's GitHub Copilot, Claude Code, Cursor, or future tools. The RAISE methodology envisions ongoing AI assistance to:
- Monitor Alignment: Detect when code drifts from documented intentions
- Suggest Updates: Propose artifact updates when requirements evolve
- Maintain Coherence: Keep the living documentation synchronized with implementation
This approach makes RAISE tool-agnostic while ensuring your original intent remains visible and actionable throughout development—whether you're a seasoned developer or someone with a great idea and no coding experience.
Fighting Documentation Rot
The Problem: Traditional software documentation suffers from entropy—it grows stale as code evolves, creating a widening gap between stated intention and actual implementation. Teams face a perpetual choice between delivering features and maintaining artifacts, often sacrificing the latter.
The RAISE Approach: The methodology envisions AI serving as a documentation guardian, continuously monitoring the relationship between artifacts and implementation. The ideal workflow:
- Proactive Detection: AI should identify when code changes drift from documented intentions
- Update Suggestions: AI should propose specific documentation updates that align with implementation changes
- Human Validation: Creators review and approve these changes, ensuring artifacts remain accurate while preserving human ownership
- Continuous Alignment: This creates a virtuous cycle where documentation evolves alongside code without requiring manual overhead
This approach transforms documentation from a static liability into a dynamic asset that reflects current reality while preserving clear intention. By delegating the mechanical aspects of documentation maintenance to AI while keeping humans as the arbiters of correctness, RAISE addresses one of the fundamental tensions in software engineering.