Raindrop Code Commands

Raindrop Code provides an AI-powered development environment through slash commands. These commands guide you through creating, updating, and debugging complete LiquidMetal applications with databases, APIs, and deployment infrastructure.

Each command initiates a structured workflow that connects to the Raindrop MCP server. The workflow orchestrates AI-guided development sessions, managing state transitions and storing artifacts locally in ~/.raindrop/<session_id>/.

Commands operate on development sessions that track your application’s state, timeline, and artifacts. You can create new applications, reattach to existing sessions, add features, or debug deployed applications.

Prerequisites

• Raindrop Code installed - See Raindrop Code Quick Start
• LiquidMetal API key - Set as LM_API_KEY environment variable
• Authentication - Commands automatically run raindrop auth login when needed

Available Commands

Raindrop Code provides four primary slash commands for application development:

Command	Purpose	Arguments	Use When
/new-raindrop-app	Create new application	None	Starting a new project
/reattach-raindrop-session	Resume existing session	[session_id] (optional)	Continuing previous work
/update-raindrop-app	Add features	[session_id] (optional)	Enhancing deployed apps
/debug-raindrop-app	Debug application	[session_id] (optional)	Fixing production issues

Core Concepts

Development Sessions

Each workflow creates a development session with a unique identifier. Sessions track:

• Session ID - Unique identifier (e.g., sess_abc123)
• Timeline ID - Workflow progression tracker
• Current State - Position in development workflow
• Application Name - Associated application
• Artifacts - Generated manifests, code, and deployment info

Sessions are stored in ~/.raindrop/index.json with this structure:

{
  "applications": {
    "my-app": {
      "latest_session_id": "sess_abc123",
      "sessions": ["sess_abc123", "sess_def456"]
    }
  },
  "sessions": {
    "sess_abc123": {
      "session_id": "sess_abc123",
      "timeline_id": "timeline_456",
      "created_at": "2025-11-14T12:00:00Z",
      "current_state": "deployment_complete",
      "application_name": "my-app"
    }
  }
}

Workflow Orchestration

Commands use the Raindrop MCP server tools:

• get-prompt - Retrieves current workflow instructions
• update-state - Reports task completion and advances workflow
• jump-to-state - Jumps to specific states for feature addition or debugging

The AI follows returned instructions, completing tasks and reporting progress to advance through the workflow.

Authentication Flow

All commands authenticate before starting:

1. Command runs raindrop auth login
2. Opens browser for authentication
3. Returns when authentication completes
4. Proceeds with workflow

Note

If you see “Please check your raindrop-mcp server status”, verify your MCP server is running with the /mcp command.

Creating New Applications

/new-raindrop-app

Create a new Raindrop application from scratch through a guided workflow.

Syntax:

/new-raindrop-app

What it does:

1. Authenticates with LiquidMetal
2. Creates new development session
3. Gathers application requirements
4. Designs architecture
5. Generates raindrop.manifest configuration
6. Creates application code
7. Deploys to infrastructure
8. Provides endpoint URLs and documentation

Workflow states:

• Requirement gathering
• Architecture design
• Manifest generation
• Code generation
• Deployment
• Testing

Example usage:

# Start Raindrop Code
raindrop-code

# In Raindrop Code, create new app
> /new-raindrop-app

# AI guides you through:
# 1. "What kind of application do you want to build?"
# 2. Requirements clarification
# 3. Architecture design approval
# 4. Manifest review
# 5. Deployment

Session storage:

Your session is stored at ~/.raindrop/<session_id>/ with:

• raindrop.manifest - Infrastructure configuration
• src/ - Generated application code
• artifacts.json - Deployment info and URLs
• session.json - Workflow state

Reattaching to Sessions

/reattach-raindrop-session [session_id]

Resume an existing development session to continue work.

Syntax:

/reattach-raindrop-session [session_id]

Arguments:

• session_id (optional) - Specific session to resume. If omitted, displays interactive selection.

What it does:

1. Authenticates with LiquidMetal
2. If session_id provided, uses it directly
3. Otherwise, reads ~/.raindrop/index.json to list applications
4. Shows application picker if multiple exist
5. Retrieves current workflow state
6. Continues from where you left off

Application selection behavior:

• No applications exist - Suggests using /new-raindrop-app
• One application exists - Automatically selects latest session
• Multiple applications exist - Displays interactive picker with state and last updated time

Example with session ID:

# Reattach to specific session
> /reattach-raindrop-session sess_abc123

Example with picker:

# Let AI show you available applications
> /reattach-raindrop-session

# AI displays:
# Available applications:
# 1. my-todo-app (state: deployment_complete, last updated: 2 hours ago)
# 2. my-api (state: code_generation, last updated: 1 day ago)
# Which application would you like to reattach to?

Use cases:

• Resume interrupted workflows
• Continue development after closing terminal
• Switch between multiple projects
• Review deployed application details

Adding Features

/update-raindrop-app [session_id]

Add new features to an existing deployed Raindrop application.

Syntax:

/update-raindrop-app [session_id]

Arguments:

• session_id (optional) - Target application session. If omitted, displays application picker.

What it does:

1. Authenticates with LiquidMetal
2. Selects target application (via argument or picker)
3. Calls jump-to-state with target_state: "merge_features" and mode: "feature_addition"
4. Gathers feature requirements
5. Updates manifest and code
6. Deploys updated version
7. Tests new functionality

Example with picker:

> /update-raindrop-app

# AI asks: "Which application would you like to add features to?"
# You select: my-todo-app

# AI asks: "What features would you like to add?"
# You describe: "Add user authentication with email/password"

# AI proceeds to:
# 1. Update raindrop.manifest with auth service
# 2. Generate authentication code
# 3. Deploy updated version
# 4. Test authentication endpoints

Example with session ID:

> /update-raindrop-app sess_abc123
# What features would you like to add?

Feature workflow:

1. Feature requirement gathering
2. Architecture review and updates
3. Manifest modification
4. Code generation for new features
5. Integration with existing code
6. Deployment
7. Feature testing

Debugging Applications

/debug-raindrop-app [session_id]

Debug an existing deployed Raindrop application by examining logs, testing endpoints, and identifying issues.

Syntax:

/debug-raindrop-app [session_id]

Arguments:

• session_id (optional) - Application to debug. If omitted, displays application picker.

What it does:

1. Authenticates with LiquidMetal
2. Selects target application (via argument or picker)
3. Calls jump-to-state with target_state: "endpoint_test" and mode: "debug"
4. Retrieves deployment information
5. Tests application endpoints
6. Examines logs for errors
7. Identifies issues
8. Proposes fixes
9. Deploys corrected version

Example:

> /debug-raindrop-app

# AI asks: "Which application would you like to debug?"
# You select: my-api

# AI proceeds to:
# 1. Fetch deployment URLs from session artifacts
# 2. Test each endpoint
# 3. Use WebFetch to check responses
# 4. Query logs with raindrop CLI
# 5. Identify error patterns
# 6. Propose fixes with code changes

Debugging capabilities:

• Endpoint testing - Validates all service endpoints respond correctly
• Log analysis - Examines recent logs for errors and warnings
• Error tracing - Identifies root causes from stack traces
• Performance issues - Detects slow queries or timeouts
• Configuration problems - Validates manifest and environment variables

Debug workflow:

1. Endpoint health checks
2. Log retrieval and analysis
3. Error identification
4. Root cause analysis
5. Fix proposal and code review
6. Fix implementation
7. Deployment
8. Verification testing

Session Management

Finding Your Sessions

Sessions are tracked in ~/.raindrop/index.json. You can inspect this file to see all applications and sessions:

# View all sessions
cat ~/.raindrop/index.json | jq .

# List application names
cat ~/.raindrop/index.json | jq '.applications | keys'

# Get latest session for an app
cat ~/.raindrop/index.json | jq '.applications["my-app"].latest_session_id'

Session Directories

Each session creates a directory at ~/.raindrop/<session_id>/ containing:

• raindrop.manifest - Infrastructure configuration (HCL format)
• src/ - Generated application code
• artifacts.json - Deployment URLs, resource IDs, metadata
• session.json - Workflow state and timeline information

Example session directory:

~/.raindrop/sess_abc123/
├── raindrop.manifest      # Service definitions, resources
├── artifacts.json         # URLs, deployment info
├── session.json           # Workflow state
└── src/
    ├── index.ts           # Main application code
    ├── routes/            # API route handlers
    └── package.json       # Dependencies

Switching Between Projects

Work on multiple applications by using session IDs:

# Work on todo app
> /update-raindrop-app sess_todo_123

# Later, switch to API project
> /update-raindrop-app sess_api_456

# Debug production app
> /debug-raindrop-app sess_prod_789

Best Practices

Starting new projects:

• Use /new-raindrop-app for greenfield projects
• Provide clear requirements upfront
• Review architecture before proceeding
• Validate manifest configuration

Updating applications:

• Use /update-raindrop-app for deployed apps
• Describe features clearly and completely
• Review code changes before deployment
• Test new functionality after deployment

Debugging issues:

• Use /debug-raindrop-app for production problems
• Start by describing observed symptoms
• Let AI test endpoints and examine logs
• Verify fixes in production after deployment

Session management:

• Use descriptive application names during creation
• Keep ~/.raindrop/ directory for session history
• Use /reattach-raindrop-session to resume work
• Provide session IDs directly when known

MCP server issues:

• If commands fail with MCP errors, check server status with /mcp
• Reauthenticate if prompted
• Verify LM_API_KEY environment variable is set
• Ensure raindrop CLI is authenticated with raindrop auth login