Learn how to manage your billing information and view your invoices.

Billing


## Managing Your Subscription

Your Cutline subscription gives you unlimited access to AI-powered pre-mortems, persona simulations, and document generation tools. This guide covers everything you need to know about managing your subscription and billing.

## Current Plans

### Premium Plan

The Cutline Premium plan includes:

- **Unlimited Pre-Mortems**: Run as many product validation analyses as you need
- **Persona Simulations**: Generate and interact with AI personas representing your target users
- **Document Generation**: Create Wikis, PRDs, and MRDs from your pre-mortem analysis
- **Full Results Access**: View complete risk assessments, market analysis, and pricing recommendations
- **Priority Support**: Get help when you need it

## Viewing Your Subscription

To view your current subscription status:

1. Navigate to **Settings** from the user menu
2. Click on **Subscription** in the left sidebar
3. Your current plan, billing cycle, and next billing date will be displayed

## Updating Payment Information

Keep your payment method up to date to ensure uninterrupted service:

1. Go to **Settings > Subscription**
2. Click **Manage Billing** to open the Stripe customer portal
3. Update your payment method, billing address, or other details
4. Changes take effect immediately

## Billing Cycle

Subscriptions are billed monthly on the anniversary of your signup date. For example, if you subscribed on the 15th of the month, you'll be billed on the 15th of each subsequent month.

## Invoices and Receipts

All invoices are automatically emailed to your registered email address after each billing cycle. You can also access past invoices:

1. Go to **Settings > Subscription**
2. Click **Manage Billing**
3. View and download invoices from the billing portal

## Upgrading Your Plan

Currently, Cutline offers a single Premium tier. As we introduce new plans and features, you'll be able to upgrade or change your plan from the subscription settings page.

## Canceling Your Subscription

You can cancel your subscription at any time:

1. Navigate to **Settings > Subscription**
2. Click **Manage Billing**
3. Select **Cancel Subscription**
4. Confirm the cancellation

**Important Notes:**
- You'll retain access to Premium features until the end of your current billing period
- Your data and pre-mortems will be preserved
- You can reactivate your subscription anytime by visiting the subscription page
- After cancellation, you can still access the platform with limited features

## What Happens After Cancellation

When your subscription ends:

- ✅ You can still **view** all your existing pre-mortems and documents
- ✅ You can still **run new pre-mortems** with limited results
- ❌ Full risk assessments, market analysis, and document generation require an active subscription
- ❌ Persona simulations are not available without a subscription

## Reactivating Your Subscription

To reactivate a canceled subscription:

1. Sign in to your account
2. Navigate to any Premium feature (e.g., Pre-Mortem page)
3. Click **Subscribe** or **Upgrade** when prompted
4. Complete the checkout process

Your previous data and pre-mortems will be immediately accessible.

## Payment Security

All payments are processed securely through Stripe, a PCI-compliant payment processor trusted by millions of businesses worldwide. Cutline never stores your credit card information.

## Billing Support

If you have questions about billing, charges, or need assistance:

- **Email**: support@thecutline.ai
- **Response Time**: Within 24 hours on business days

For urgent billing issues, include "BILLING" in your email subject line.

## Frequently Asked Questions

### Can I get a refund?

We offer refunds on a case-by-case basis within 14 days of your initial subscription. Contact support@thecutline.ai with your refund request.

### Do you offer annual plans?

Annual billing is coming soon! Subscribe to our newsletter to be notified when annual plans become available.

### Can I pause my subscription?

Currently, we don't offer subscription pausing. You can cancel and reactivate anytime, and your data will be preserved.

### What payment methods do you accept?

We accept all major credit cards (Visa, Mastercard, American Express, Discover) through our payment processor, Stripe. For large accounts or enterprise arrangements, we prefer ACH (bank transfer) payments. Contact support@thecutline.ai to set up ACH billing.

### Will my price change?

Your subscription price is locked in at the time of signup. If we introduce price changes, existing subscribers will be notified at least 30 days in advance.


Manage your Cutline subscription, billing, and payment methods. Compare Premium vs Enterprise plans, upgrade or cancel anytime, and access AI-powered pre-mortems and persona simulations.

Subscription & Billing - Plans, Pricing & Payment

Connect Cutline to your AI-powered IDE using the Model Context Protocol (MCP).

MCP Integration


Connect Cutline's constraint-aware development workflow directly to your IDE using the [Model Context Protocol (MCP)](https://modelcontextprotocol.io). Free accounts get engineering audits; Premium unlocks product-specific constraint graphs and RGR workflows.

## Watch the Demo

<div style={{ position: 'relative', paddingBottom: '56.25%', height: 0, marginBottom: '2rem' }}>
  <iframe
    src="https://www.youtube.com/embed/rM36f1YcpdA"
    title="Cutline MCP Demo"
    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
    allowFullScreen
    style={{
      position: 'absolute',
      top: 0,
      left: 0,
      width: '100%',
      height: '100%',
      border: 'none',
      borderRadius: '8px'
    }}
  />
</div>

## What You Get

| | Free | Premium |
|---|---|---|
| Engineering audit (security, reliability, scalability) | ✓ (3/month) | Unlimited |
| Active issue detection with fix guidance | 1 detailed finding | All findings |
| RGR remediation plans | — | ✓ |
| Product-specific constraint graph | — | ✓ |
| `.cutline.md` agent directive | — | ✓ |
| Pre-mortem analysis | — | ✓ |
| AI persona feedback | — | ✓ |

## Prerequisites

1. **Node.js 18+** — [Download Node.js](https://nodejs.org)
2. **An MCP-compatible client** — Cursor, Claude Code, Windsurf, or similar

No account needed upfront — the CLI creates one with just your email.

## Step 1: Install

```bash
npm install -g @vibekiln/cutline-mcp-cli@latest
```

This package installs both the core Cutline MCP servers and **SlopBurn** (the product quality engineering roguelike RPG mode) in one CLI.

If you prefer a dedicated SlopBurn-only onboarding/config flow, install the standalone CLI:

```bash
npm install -g @vibekiln/slopburn-cli
slopburn setup
```

### Option: Install via Smithery

If you prefer marketplace install/discovery, you can install from Smithery once the listing is live:

1. Open Smithery and search for `vibekiln/cutline-mcp-cli`
2. Click **Install** and follow the client-specific prompts
3. If prompted for an MCP Server URL, use the public HTTPS endpoint for the Cutline HTTP bridge (for example `https://mcp.thecutline.ai/mcp`)

Notes:
- The bridge health endpoint is `GET /health` on the same host
- The MCP endpoint must be HTTPS and should accept `POST` requests at `/mcp`

## Step 2: Setup

Navigate to your project root and run:

```bash
cutline-mcp setup
```

This single command handles everything:

1. **Authenticates** — opens your browser for a quick email-based sign-in (skipped if you're already logged in)
2. **Configures your IDE** — merges Cutline MCP servers into `~/.cursor/mcp.json` and `~/.claude.json` automatically, preserving your existing servers
3. **Generates IDE rules** — writes `.cursor/rules/` files and `CLAUDE.local.md` with RGR workflow guidance tailored to your tier
4. **Prints next steps** — shows what you can ask your AI agent

That's it. Restart your IDE and you're ready to go.

### Options

| Flag | Description |
|---|---|
| `--skip-login` | Skip authentication (use existing credentials) |
| `--project-root <path>` | Project root for IDE rules (default: current directory) |
| `--staging` | Use staging environment |

## IDE-Specific Notes

<div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '1rem', marginTop: '1rem' }}>
<div style={{ padding: '1rem', borderRadius: '8px', border: '1px solid rgba(0,255,65,0.2)', background: 'rgba(0,0,0,0.2)' }}>

### Cursor

`cutline-mcp setup` auto-writes `~/.cursor/mcp.json`.

Restart Cursor and verify servers in Settings → Features → MCP Servers.

</div>
<div style={{ padding: '1rem', borderRadius: '8px', border: '1px solid rgba(0,200,255,0.2)', background: 'rgba(0,0,0,0.2)' }}>

### Claude Code

`cutline-mcp setup` auto-writes `~/.claude/settings.json`.

Or use `claude mcp add`:

```bash
claude mcp add cutline-constraints -- npx -y @vibekiln/cutline-mcp-cli serve constraints
claude mcp add cutline-premortem -- npx -y @vibekiln/cutline-mcp-cli serve premortem
claude mcp add cutline-tools -- npx -y @vibekiln/cutline-mcp-cli serve tools
claude mcp add cutline-exploration -- npx -y @vibekiln/cutline-mcp-cli serve exploration
```

</div>
<div style={{ padding: '1rem', borderRadius: '8px', border: '1px solid rgba(255,0,255,0.2)', background: 'rgba(0,0,0,0.2)' }}>

### Windsurf

Open Command Palette → "Preferences: Open Settings (JSON)" and add server entries under `"mcp.servers"`.

Copy the config from `~/.cursor/mcp.json` after running setup.

</div>
</div>

## Start Using Cutline

### Use the Magic Phrase

Ask your AI assistant:

```
use cutline
```

Cutline infers intent and routes automatically:
- Natural variants also work: `use cutline to ...`, `using cutline, ...`, `with cutline ...`
- Free/default requests route to `code_audit`
- Premium product-linked requests route to `engineering_audit`

You can still be explicit:

```
Run a code audit on this codebase.
```

### Premium: RGR Workflow

Your AI agent will now follow the RGR cycle automatically:

1. **Plan** — calls `rgr_plan` before implementing features
2. **Implement** — addresses constraints from the plan
3. **Verify** — runs `engineering_audit` to check product-linked constraint coverage
4. **Complete** — marks phases done with `rgr_complete_phase`

Try it:

```
I want to add rate limiting to the /api/upload endpoint. 
Check the constraint graph first.
```

### Premium: Pre-mortem Analysis

```
Generate a premortem for launching a B2B SaaS analytics platform
targeting mid-market companies with a 3-month timeline.
```

### Premium: Persona Feedback

```
What does my persona Debra think about adding a mobile app?
```

## Available MCP Servers

| Server | Purpose | Key Tools |
|--------|---------|-----------|
| **cutline-constraints** | Constraint graph, audits, RGR workflow | `engineering_audit`, `code_audit`, `rgr_plan`, `constraints_auto`, `generate_cutline_md` |
| **cutline-premortem** | Pre-mortem generation & management | `premortem_run`, `premortem_list`, `premortem_status` |
| **cutline-tools** | Personas, wikis, templates, AI chat | `personas_chat`, `wiki_load`, `template_create` |
| **cutline-exploration** | Guided product exploration & framing | `exploration_start`, `exploration_chat` |
| **cutline-output** | PDF generation and Q&A | `premortem_render_pdf`, `premortem_qa` |
| **cutline-integrations** | External tool connections | `integrations_create_issues` |

For most users, **cutline-constraints** is the essential server — it powers engineering audits and the RGR workflow.

## Troubleshooting

### "Authentication required" error

```bash
cutline-mcp login
```

### "Premium subscription required" error

Some tools require Premium. [Upgrade your account](/upgrade). Free users can still use `engineering_audit` (3 scans/month).

### MCP servers not appearing

1. Verify: `cutline-mcp --version`
2. Check paths in your MCP config
3. Restart your IDE completely
4. Check IDE logs for errors

### Token expired

Tokens auto-refresh, but if issues persist:

```bash
cutline-mcp logout
cutline-mcp login
```

### "Command not found: npx"

Ensure Node.js 18+ is installed:

```bash
node --version
```

## Individual Commands

If you prefer to run steps separately:

| Command | Description |
|---|---|
| `cutline-mcp login` | Authenticate only |
| `cutline-mcp init` | Generate IDE rules only |
| `cutline-mcp status` | Check authentication status |
| `cutline-mcp upgrade` | Upgrade to Premium |

## Getting Help

- **Documentation:** [thecutline.ai/docs](https://thecutline.ai/docs)
- **Email:** [support@thecutline.ai](mailto:support@thecutline.ai)
- **Feedback:** [cutline.canny.io](https://cutline.canny.io)

## Next Steps

- [Tool Reference](/docs/tools) — Complete API documentation
- [Examples](/docs/examples) — Common workflows and use cases


Connect Cutline to Cursor, Claude Code, Windsurf, and other AI-powered tools using MCP. Works with free and premium accounts.

MCP Setup Guide


Complete documentation for all Cutline MCP tools available through the Model Context Protocol.

## Audit Tools

These tools scan your codebase for active issues — real vulnerabilities and anti-patterns in your code as written today.

### engineering_audit

🔓 **FREE** — Engineering audit that evaluates your codebase against a stack-aware constraint graph covering security, reliability, and scalability. No deep dive or product_id required. 3 scans/month on free tier.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `project_root` | string | Yes | Absolute path to the workspace root |
| `task_description` | string | No | Context about what you're building |
| `max_file_bytes` | number | No | Max bytes per file (default: 50000) |

**Response:** Readiness scores (engineering, security, reliability, scalability), binding coverage, top finding with fix guidance, and SCA vulnerability summary.

---

### code_audit

🔒 **PREMIUM** — Security-focused code audit that cross-references the product constraint graph, runs LLM extraction for security gaps, and builds an RGR remediation plan.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID from `.cutline/config.json` |
| `project_root` | string | Yes | Absolute path to workspace root |
| `file_paths` | string[] | No | Specific files to audit |
| `task_description` | string | No | What you're building |
| `audit_mode` | string | No | `security` (default) or `full` |
| `max_file_bytes` | number | No | Max bytes per file (default: 50000) |
| `auto_start` | boolean | No | Queue a deep dive job (default: true) |

**Response:** RGR plan, security gaps, extracted risks, checklist summary, SCA findings, constraint graph updates, and next-step RGR instructions.

---

## Constraint Tools

These tools are available through the `cutline-constraints` server. They power the constraint graph, NFR boundary enforcement, and the adaptive Red-Green-Refactor workflow.

### rgr_plan

Assess constraint complexity for a file and return an adaptive execution plan. Call this before implementing any feature.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID |
| `file_path` | string | Yes | File path to assess (e.g., `src/api/upload.ts`) |
| `depth` | number | No | BFS traversal depth (default: 2) |
| `auth_token` | string | No | Firebase ID token |

**Response:** Returns `strategy` (`"full"` or `"phased"`), an array of `phases` with names, categories, and constraint counts, plus a `rationale` string.

---

### graph_get_boundaries

Get constraint boundaries for a specific file path. Returns functional context (features, components, data types) and applicable NFRs. Supports RGR phased delivery.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID |
| `file_path` | string | Yes | File path to look up constraints for |
| `depth` | number | No | BFS traversal depth (default: 2) |
| `max_tokens` | number | No | Token budget for output (default: 2000) |
| `phase` | string | No | RGR phase filter: `test_spec`, `functional`, `security`, `performance`, `economics`, `full`, or `auto` (default: `full`) |
| `auth_token` | string | No | Firebase ID token |

**Response:** Imperative Markdown with functional context and NFRs, formatted for the requested phase.

---

### constraints_auto

Proactive constraint injection. Analyzes your current file/code context and automatically surfaces relevant constraints.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID |
| `file_paths` | string[] | No | Files you're working on |
| `code_snippet` | string | No | Current code context (500 char max) |
| `task_description` | string | No | What you're trying to accomplish |
| `mode` | string | No | Output mode: `silent`, `advisory`, `blocking`, `deep`, `auto` (default: `auto`) |
| `max_constraints` | number | No | Max constraints to return (default: 5) |
| `phase` | string | No | RGR phase filter (same options as `graph_get_boundaries`) |
| `auth_token` | string | No | Firebase ID token |

---

### rgr_complete_phase

🔒 **PREMIUM** — Mark an RGR phase as complete. Updates the constraint graph and recomputes readiness scores with the phase bonus.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID |
| `phase` | string | Yes | Phase to complete: `test_spec`, `functional`, `security`, `performance`, or `economics` |

**Response:** Updated readiness scores and completed phases list.

---

### generate_cutline_md

🔒 **PREMIUM** — Generate and write Cutline config files. Creates `.cutline.md` (constraint routing engine), Cursor rules, Claude Code config, and RGR workflow rules. If `project_root` is provided, files are written directly to disk.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `product_id` | string | Yes | Product ID |
| `product_name` | string | No | Human-readable product name |
| `project_root` | string | No | Workspace root — writes files directly when provided |
| `project_type` | string | No | Primary framework/stack (auto-detected if omitted) |
| `mcp_server` | string | No | MCP server name to reference (default: `cutline-constraints`) |
| `max_embedded_constraints` | number | No | Max critical constraints to embed (default: 7) |

**Response:** When `project_root` is set, returns list of files written. Otherwise returns content for manual saving.

---

## Pre-mortem Tools

These tools are available through the `cutline-premortem` server.

### premortem.run

Generate a complete pre-mortem analysis synchronously.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `input` | object | Yes | Pre-mortem input configuration |
| `input.productName` | string | Yes | Name of the product or feature |
| `input.productDescription` | string | Yes | 2-3 sentence description |
| `input.referenceClasses` | string[] | No | Industry/domain references |
| `input.pessimism` | number | No | Pessimism level (0.0 - 1.0, default: 0.5) |
| `auth_token` | string | No | Firebase ID token (auto-filled by CLI) |

**Example:**

```json
{
  "input": {
    "productName": "Mobile Analytics Dashboard",
    "productDescription": "A mobile app that provides real-time analytics for e-commerce stores, helping merchants track sales and customer behavior on the go.",
    "referenceClasses": ["Mobile apps", "Analytics tools", "E-commerce"],
    "pessimism": 0.6
  }
}
```

**Response:** Full pre-mortem document with assumptions, risks, experiments, and recommendations.

---

### premortem.list

List all pre-mortems for the authenticated user.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `limit` | number | No | Maximum results (default: 10) |
| `auth_token` | string | No | Firebase ID token |

**Example:**

```json
{
  "limit": 5
}
```

**Response:** Array of pre-mortem summaries with IDs, names, status, and dates.

---

### premortem.queue

Queue an asynchronous pre-mortem job for longer/complex analyses.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `input` | object | Yes | Same as `premortem.run` |
| `auth_token` | string | No | Firebase ID token |

**Response:** Job ID for tracking progress.

---

### premortem.status

Check the status of a queued pre-mortem job.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `jobId` | string | Yes | Job ID from `premortem.queue` |
| `auth_token` | string | No | Firebase ID token |

**Response:** Job status, progress percentage, and current stage.

---

### premortem.kick

Execute or resume a queued pre-mortem job.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `jobId` | string | Yes | Job ID to execute |
| `auth_token` | string | No | Firebase ID token |

---

### premortem.regen_assumptions

Regenerate the assumptions section of an existing pre-mortem.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `input` | object | Yes | Original input parameters |
| `doc` | object | Yes | Existing pre-mortem document |
| `auth_token` | string | No | Firebase ID token |

---

### premortem.regen_experiments

Regenerate the experiments section of an existing pre-mortem.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `input` | object | Yes | Original input parameters |
| `doc` | object | Yes | Existing pre-mortem document |
| `auth_token` | string | No | Firebase ID token |

---

## Persona Tools

These tools are available through the `cutline-tools` server.

### personas.list

List all personas for the authenticated user.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `productId` | string | No | Filter by product ID |
| `auth_token` | string | Yes | Firebase ID token |

**Response:** Array of persona objects with demographics, personality, and behaviors.

---

### personas.get

Get a specific persona by ID.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `personaId` | string | Yes | Persona ID |
| `auth_token` | string | Yes | Firebase ID token |

**Response:** Complete persona object.

---

### personas.chat

Have a conversation with a persona about your product or feature.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `persona` | object | Yes | Persona object |
| `userMessage` | string | Yes | Your message to the persona |
| `conversationHistory` | array | No | Previous messages for context |
| `product` | object | No | Product context |
| `auth_token` | string | Yes | Firebase ID token |

**Example:**

```json
{
  "persona": {
    "name": "Debra",
    "description": "Technical solopreneur running multiple SaaS businesses",
    "role": "Founder",
    "segment": "Startup"
  },
  "userMessage": "What do you think about adding a mobile app to our analytics platform?",
  "product": {
    "name": "Cutline",
    "brief": "AI product management suite"
  }
}
```

**Response:** Persona's response in character, based on their profile.

---

## Wiki Tools

These tools are available through the `cutline-tools` server.

### wiki.load

Load the wiki/documentation for a project.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `projectId` | string | Yes | Project ID |
| `auth_token` | string | No | Firebase ID token |

**Response:** Wiki content in markdown format.

---

### wiki.save

Save updated wiki content.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `projectId` | string | Yes | Project ID |
| `markdown` | string | Yes | Wiki content in markdown |
| `auth_token` | string | No | Firebase ID token |

---

### wiki.apply_edits

Apply specific edits to wiki content.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `edits` | array | Yes | Array of edit operations |
| `auth_token` | string | No | Firebase ID token |

---

## Agent Tools

### agent.chat

Chat with the Cutline AI assistant about your wiki or product.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `prompt` | string | Yes | Your question or request |
| `wikiMarkdown` | string | No | Wiki context for the chat |
| `auth_token` | string | No | Firebase ID token |

**Example:**

```json
{
  "prompt": "What are the main risks identified in my product wiki?",
  "wikiMarkdown": "# My Product\n\n## Risks\n- Market timing..."
}
```

---

### trial.generate

Generate a trial run scenario for testing.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `prompt` | string | Yes | Description of what to test |

**Example:**

```json
{
  "prompt": "Generate a trial run for testing our checkout flow with 100 users"
}
```

---

## Output Tools

These tools are available through the `cutline-output` server.

### premortem.render_pdf

Generate a PDF from a pre-mortem document.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `doc` | object | Yes | Pre-mortem document |
| `store` | boolean | No | Store PDF in cloud (default: false) |
| `auth_token` | string | No | Firebase ID token |

**Response:** Signed URL to download the PDF.

---

### premortem.qa_answer

Answer questions about a pre-mortem document.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `doc` | object | Yes | Pre-mortem document |
| `question` | string | Yes | Question to answer |

**Example:**

```json
{
  "doc": { ... },
  "question": "What are the top 3 risks identified?"
}
```

---

## Integration Tools

These tools are available through the `cutline-integrations` server.

### integrations.create_issues

Create issues in an external issue tracker from pre-mortem results.

**Parameters:**

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| `schema_json` | object | Yes | Issue schema and data |
| `limit` | number | No | Maximum issues to create |
| `auth_token` | string | No | Firebase ID token |

---

## Error Handling

All tools may return errors in this format:

```json
{
  "error": "MCP error -32600: Permission denied"
}
```

**Common Error Codes:**

| Code | Meaning | Solution |
|------|---------|----------|
| `-32600` | Permission denied | Check authentication |
| `-32601` | Method not found | Verify tool name |
| `-32602` | Invalid params | Check required parameters |
| `-32603` | Internal error | Contact support |

## Rate Limits

| Tier | Engineering Audits | Code Audits | Pre-mortems |
|------|-------------------|-------------|-------------|
| Free | 3/month | — | — |
| Premium | Unlimited | Unlimited | Unlimited |
| Enterprise | Unlimited | Unlimited | Unlimited |

## Next Steps

- [Setup Guide](/docs/setup) - Get started with MCP
- [Examples](/docs/examples) - Common workflows



Complete API reference for all Cutline MCP tools including pre-mortem analysis, AI persona feedback, wiki management, and product validation. Includes parameters, examples, and response formats.

MCP Tool Reference


Real-world examples and workflows for using Cutline MCP in your daily development.

## Magic Phrase

Use this first in most sessions:

```
use cutline
```

Cutline routes by intent and tier:
- Natural variants also work: `use cutline to ...`, `using cutline, ...`, `with cutline ...`
- Free/default -> `code_audit`
- Premium product-linked -> `engineering_audit`
- Feature work -> `rgr_plan` + `constraints_auto`

---

## Install via Smithery

If you install Cutline from Smithery (instead of local CLI setup), use:

- **Namespace / Server ID:** `vibekiln / cutline-mcp-cli`
- **MCP Server URL:** your public HTTPS bridge endpoint, e.g. `https://mcp.thecutline.ai/mcp`

Bridge checks:
- Health endpoint: `GET https://<your-host>/health`
- MCP endpoint: `POST https://<your-host>/mcp`

If you self-host the bridge with the CLI:

```bash
cutline-mcp serve constraints --http --host 0.0.0.0 --port 8080 --path /mcp
```

---

## Code Audit (Free)

The fastest way to get value from Cutline. No deep dive or product ID required.

### Scan Your Codebase

```
Run a code audit on this codebase.
```

This calls `code_audit` and returns:
- Readiness scores for security, reliability, and scalability
- Your top actionable finding with fix guidance
- SCA vulnerability summary for your dependencies

### Fix the Finding and Re-scan

After addressing the issue, re-scan to verify:

```
I've fixed the rate limiting issue. Run another code audit 
to verify it's resolved.
```

---

## RGR Workflow (Premium)

The Red-Green-Refactor cycle is the core premium workflow. Your AI agent follows it automatically when `cutline-mcp init` has been run.

### Start a New Feature with Constraints

```
I want to add file upload to the /api/documents endpoint. 
Check the constraint graph first.
```

The agent will call `rgr_plan`, get phased constraints, implement accordingly, then verify with `engineering_audit`.

### Run a Full Engineering Audit

```
Run an engineering audit for my product. Focus on security.
```

Returns an RGR remediation plan with phased fixes. The agent will walk you through each phase.

### Complete an RGR Phase

After fixing all issues in a phase:

```
Mark the security phase as complete for my product.
```

This calls `rgr_complete_phase` and updates your readiness scores.

---

## Quick Start Examples

### Generate a Pre-mortem

Validate a product idea before building:

```
Generate a premortem for a mobile app that helps remote teams 
track their daily standups asynchronously. Target audience is 
engineering teams of 5-20 people. We plan to launch in 3 months.
```

The AI will use the `premortem.run` tool to generate:
- Key assumptions to validate
- Potential risks and failure modes
- Recommended experiments
- Market analysis
- Success criteria

---

### Get Persona Feedback on a Feature

Ask your AI personas what they think:

```
I want to add a dark mode to our analytics dashboard. 
What does my persona Debra think about this feature?
```

Or get feedback from all personas at once:

```
Ask all my personas: Would you pay $10/month for a feature 
that automatically generates weekly reports?
```

---

### Load and Update Your Wiki

Work with your project documentation:

```
Load the wiki for my project and summarize the current roadmap
```

Then make updates:

```
Add a new section to the wiki called "Q1 2025 Goals" with 
these three objectives: 1) Launch mobile app, 2) Reach 1000 users, 
3) Achieve $10K MRR
```

---

## Development Workflows

### Feature Validation Workflow

Before starting any new feature, run through this workflow:

**Step 1: Generate Pre-mortem**
```
Generate a premortem for adding Slack integration to our 
product management tool. The feature would allow users to 
receive notifications and run quick commands from Slack.
```

**Step 2: Get Persona Reactions**
```
What does each of my personas think about this Slack 
integration feature? Who would use it most?
```

**Step 3: Identify Experiments**
```
Based on the premortem, what are the top 3 experiments 
we should run before building this feature?
```

**Step 4: Document Decision**
```
Update the wiki with our decision on the Slack integration, 
including the premortem findings and planned experiments.
```

---

### Sprint Planning Workflow

Use Cutline to validate your sprint backlog:

**Review Backlog Items**
```
I have these 5 features planned for the sprint:
1. User profile page
2. Email notifications
3. Export to CSV
4. Team invitations
5. Dashboard widgets

Ask my personas to rank these by importance and explain why.
```

**Identify Risks**
```
Generate a quick risk assessment for implementing 
team invitations this sprint. What could go wrong?
```

---

### Code Review Enhancement

Get product perspective on your code changes:

```
I'm about to merge a PR that adds a new onboarding flow 
with 5 steps. Here's what each step collects:
1. Name and email
2. Company size
3. Role
4. Goals
5. Invite teammates

What would my persona Zach (technical founder) think 
about this onboarding experience?
```

---

## Product Strategy Examples

### Competitive Analysis

```
Generate a premortem that specifically focuses on competitive 
risks for our analytics product. Main competitors are Mixpanel, 
Amplitude, and PostHog. What are the biggest threats?
```

### Pricing Validation

```
We're considering three pricing tiers:
- Free: 1,000 events/month
- Pro: $29/month for 100K events
- Business: $99/month for 1M events

Ask my personas if they would upgrade from Free to Pro, 
and what would convince them.
```

### Market Expansion

```
Generate a premortem for expanding our US-based SaaS product 
to the European market. Consider GDPR, localization, 
payment methods, and go-to-market strategy.
```

---

## Integration Examples

### Create Linear Issues from Pre-mortem

After generating a pre-mortem, create action items:

```
Take the experiments from my latest premortem and 
create Linear issues for each one, tagged with "validation"
```

### Generate Documentation

```
Based on my premortem for the mobile app feature, 
generate a PRD that I can share with my engineering team
```

### Export to PDF

```
Export my most recent premortem as a PDF that I can 
share with stakeholders
```

---

## Advanced Prompts

### Multi-Persona Debate

```
I want to see a debate between my personas about whether 
we should build a native mobile app or a progressive web app.
Have Debra and Zach argue both sides.
```

### Assumption Testing

```
From my latest premortem, identify the riskiest assumption 
and design a quick experiment I could run this week to 
test it with less than $500 budget.
```

### Historical Analysis

```
Show me all my premortems from the last 3 months and 
identify common themes in the risks that were identified.
What patterns do you see?
```

### Persona Calibration

```
Compare what my persona Debra predicted about our 
onboarding feature vs. the actual user feedback we got. 
How accurate was she? What should we adjust in her profile?
```

---

## Tips for Better Results

### Be Specific About Context

❌ **Too vague:**
```
Generate a premortem
```

✅ **Good:**
```
Generate a premortem for a B2B SaaS tool that helps 
marketing teams schedule social media posts. Target 
customers are marketing agencies with 5-50 employees. 
We have $200K runway and need to hit $10K MRR in 6 months.
```

### Include Constraints

```
Generate a premortem for our mobile app launch, considering:
- We only have 2 developers
- Budget is limited to $50K
- Must launch before Q2
- Need to support both iOS and Android
```

### Ask Follow-up Questions

After getting initial results:

```
That's helpful. Can you go deeper on risk #3 about 
user adoption? What specific experiments would validate 
whether users will actually change their workflow?
```

### Iterate on Personas

```
My persona Zach seems too optimistic. Based on this feedback 
from a real customer interview, update his profile to be 
more skeptical about new tools: "[interview quote]"
```

---

## Troubleshooting Examples

### Token Expired

If you see authentication errors mid-session:

```bash
# In terminal
cutline-mcp logout
cutline-mcp login
```

Then retry your request in the AI chat.

### Tool Not Found

If a tool isn't available:

```
What Cutline MCP tools do you have access to?
```

This will list all available tools and help diagnose configuration issues.

---

## Next Steps

- [Setup Guide](/docs/setup) - Configure your environment
- [Tool Reference](/docs/tools) - Complete API documentation



Real-world examples and workflows for using Cutline MCP with Cursor, Claude Desktop, and other AI tools. Learn pre-mortem analysis, persona feedback, and product validation patterns.

Documentation

Explore our guides and examples to start building your app.

Canonical documentation citation sources

Billing

MCP Integration

Billing

MCP Integration