The Complete Guide

How Scope Works

Your AI coding tools need context. Scope captures it through conversation and delivers it via MCP—so you never repeat yourself.

Start Free View Pricing

AI Tools Start Every Session Blind

Without persistent context, your AI coding tools work with one hand tied behind their back.

Every session starts fresh

Cursor, Claude Code, and Lovable have no memory between sessions. You explain your project structure every time.

AI hallucinates details

Without context, AI invents field names, creates wrong file paths, and misunderstands your architecture.

Tokens wasted on context

Most of your prompt goes to re-explaining what you've already told it. Less tokens left for actual code.

No memory of decisions

Patterns, conventions, and architectural decisions get lost. Each session reinvents the wheel.

Step 1

Define Your Project Through Conversation

The wizard is a 7-step adaptive flow that captures everything your AI tools need to know.

Step	What's Captured	Example
Requirements	Problem statement, target audience, MoSCoW features	"A project management app for small teams with task dependencies"
Entities	Data models with typed fields and relationships	User (id, email, name), Project (id, name, owner_id), Task (id, title, status)
User Flows	Key user journeys with branching	"Create Project → Add Members → Create Task → Assign → Complete"
Pages	Frontend screens, routes, auth requirements	Dashboard (/), Project View (/projects/:id), Settings (/settings)
API Design	Endpoints with methods, paths, auth	POST /api/projects, GET /api/tasks/:id, PUT /api/tasks/:id/status
Tech Stack	AI-recommended technologies	Backend: Rust/Axum, Frontend: React/Next.js, DB: PostgreSQL
Review	Final review before generation	Confirm all specs, trigger milestone/ticket generation

Adaptive Flow

Steps adjust based on your project type:

Full Stack

All 7 steps

Backend Only

Skip Pages

Frontend Only

Skip API Design

CLI/Library

Requirements → Entities → Tech → Review

Step 2

AI Generates Implementation-Ready Tickets

When you complete the wizard, Scope generates tickets using Constitutional AI Principles.

5 Constitutional Principles

AUTONOMOUS

Completable by AI without human intervention

COMPLETE

All context needed is included

TESTABLE

Acceptance criteria are verifiable

ORDERED

Explicit dependencies between tickets

ACTIONABLE

Clear file paths and implementation steps

What's in a Ticket (32 fields)

Core

title, description, status, priority

Implementation

acceptance_criteria, implementation_plan, implementation_hints

Files

files_to_create, files_to_modify, file_conventions

Context

related_entities, related_endpoints, related_pages, entity_schema

Dependencies

dependencies (ticket IDs), next_ticket_id

Testing

test_requirements, test_file, verification_commands

Patterns

patterns_to_follow, migration_sql, mcp_tools

Git

branch_name, commit_message, pr_url

Example Ticket

{
  "title": "Create users table migration",
  "files_to_create": [
    "/migrations/001_create_users.sql"
  ],
  "entity_schema": {
    "name": "User",
    "fields": [
      {"name": "id", "type": "uuid", "is_primary": true},
      {"name": "email", "type": "string", "required": true},
      {"name": "name", "type": "string"}
    ]
  },
  "migration_sql": "CREATE TABLE users (...);",
  "verification_commands": [
    "sqlite3 dev.db '.schema users'"
  ],
  "dependencies": []
}

Step 3

Context is Stored for Semantic Search

All wizard data is embedded and stored in Qdrant (vector database) for intelligent retrieval.

What Gets Stored

entity_schemaData models with field types

api_endpointREST endpoints with methods/paths

page_definitionFrontend page structures

user_flowUser journey specifications

tech_stackTechnology choices

requirementProject requirements

learningPatterns, decisions, gotchas

How It Works

Wizard data → ContextChunks (structured text)

ContextChunks → Voyage AI embeddings (1024 dimensions)

Embeddings → Qdrant with project_id filter

Search queries → Find relevant context within token budget

WizardChunksEmbeddingsQdrantSearch

Step 4

Connect Your AI Tool via MCP

Model Context Protocol is an open standard for connecting AI tools to external services. Connect once, context flows everywhere.

One-Time Setup

// ~/.config/claude/claude_desktop_config.json

{
  "mcpServers": {
    "scope": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/scope-mcp"],
      "env": {
        "SCOPE_API_KEY": "vpm_sk_..."
      }
    }
  }
}

45 MCP Tools Available

Workflow

get_next_ticketcomplete_ticketupdate_ticket_status

Context

get_implementation_contextget_relevant_contextget_entity

Wizard Data

get_requirementsget_entitiesget_api_designget_pages

Learning

save_learningget_project_patterns

Review

review_milestoneanalyze_ticket_impact

What Your AI Receives

// Response from get_next_ticket()

{
  "ticket": {
    "title": "Create users table migration",
    "files_to_create": ["/migrations/001_create_users.sql"],
    "entity_schema": { "name": "User", "fields": [...] },
    "acceptance_criteria": ["Table exists", "All fields match schema"]
  },
  "workflow_hint": "Call get_implementation_context for entity schemas",
  "relevant_learnings": [
    "Use UUID for primary keys - project convention",
    "Add created_at/updated_at to all tables"
  ],
  "git_workflow": {
    "branch_name": "feat/001-users-migration"
  }
}

Every ticket comes with learnings from previous work, preventing repeated mistakes.

Step 5

Your AI Builds with Full Context

The complete workflow loop that enables autonomous, context-aware development.

The Workflow Loop

get_next_ticket()

Returns ticket + learnings + git_workflow

git checkout -b {branch}

Create feature branch from suggested name

get_implementation_context()

Fetch entities, tech stack, patterns

IMPLEMENT THE TICKET

Create files, write tests, run verification

complete_ticket(learnings)

Log work, capture learnings, get next action

git push + gh pr create + merge

Push, create PR, auto-merge if enabled

Loop back to step 1

What AI Gets Per Ticket

Full entity schemas (prevents field hallucination)

File paths to create/modify

Step-by-step implementation plan

Patterns to follow with example files

Verification commands to confirm completion

Relevant learnings from previous tickets

Key Benefit: Entity schemas are embedded in every ticket with explicit instructions to only reference existing fields. This significantly reduces AI hallucination of field names and incorrect relationships.

Escape Hatches When You Need Them

Real projects hit edge cases. Scope gives you the flexibility to handle them:

skip_ticket

Work already done or ticket overlaps with previous

skip_tests

Tech stack incompatibilities prevent tests

mark_blocked

External dependencies blocking progress

Ready to Stop Repeating Yourself?

Start capturing context in minutes. Free plan includes unlimited projects.

Start Free View Pricing