# draftlytic-mcp [Health: Active]

**Category:** 📋 Product Management  
**Repository:** https://github.com/rbsoftwaresystems/draftlytic-mcp  
**GitHub Stars:** 0  
**npm Downloads (last month):** 154  
**Views:** 1  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/draftlytic-mcp

## Description
Offline MCP server for planning structured project specs — validate, render, and checklist tools.

## Tools
Capabilities this server exposes over MCP:

- **validate_spec** — Validate a project spec against the schema and return structured issues. A project spec: name, overview, target_audience, platforms[], tech_stack[], features[] ({title, description, priority: must-have|nice-to-have|future, acceptance_criteria?[]}), screens[]? ({name, purpose}), data_model[]? ({entity, fields[]: {name, type, notes?}}), constraints[]?, non_goals[]?, revenue_model?. Checks for missing/empty required sections, placeholder text (e.g. "TBD", "lorem ipsum", "fixme"), and features without a priority — all reported as errors. Also returns non-blocking quality hints, e.g. "none of your must-have features have acceptance_criteria" or "no non_goals listed".
- **render_prd** — Render a project spec into a deterministic, Draftlytic-style Markdown PRD. A project spec: name, overview, target_audience, platforms[], tech_stack[], features[] ({title, description, priority: must-have|nice-to-have|future, acceptance_criteria?[]}), screens[]? ({name, purpose}), data_model[]? ({entity, fields[]: {name, type, notes?}}), constraints[]?, non_goals[]?, revenue_model?. Output includes: title, overview, target audience, platforms, tech stack, features grouped by priority (must-have / nice-to-have / future) with acceptance-criteria checklists, screens & navigation, data model tables, constraints, and non-goals. Run validate_spec first — this tool renders whatever it's given, even an incomplete spec.
- **spec_checklist** — Return a planning checklist grouped by category (platform, tech stack, target audience, features, competitors, revenue, constraints, data model, notifications, external services, design & UX), each with 2-4 concrete questions. Use this to interview the user before drafting a spec — you don't need to ask every question, just enough per category to fill in the schema meaningfully. Each question is an object: `prompt` is the question text; when it also has `options` (a short list of suggested answers), present it as a selectable choice question rather than asking the user to type — with `multiSelect: true`, let them pick several. Always leave a free-text escape so the user can answer in their own words; questions with no `options` are open-ended and stay free-text.
- **open_in_draftlytic** — Build a link that opens this idea in the full Draftlytic app (free account, no card), which runs its own guided flow: AI-tailored questions, full project generation, an editable structured spec, and PRD export (plus scan-for-gaps, logo drafts, and GitHub push on paid plans). Pass either the spec drafted here (it gets compressed into a starting brief) or a plain-text idea. Show the returned URL to the user as a clickable link — this tool only builds it; nothing is sent anywhere.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "draftlytic-mcp": {
    "command": "npx",
    "args": ["-y","draftlytic-mcp"]
  }
}
```

## Documentation

## What draftlytic-mcp does

draftlytic-mcp MCP server provides local planning tools for turning a rough project idea into a structured specification. It is designed to work inside Claude Code, Cursor, or another MCP-compatible editor, where the connected model can ask planning questions, compose the spec, validate it, and produce a Markdown PRD.

The server does not write the project plan independently or call an AI service. The editor's model supplies the writing and uses the server's schema, checklist, validation rules, and renderer to organize the work. Specs can include a project name, overview, audience, platforms, technology choices, prioritized features, screens, data entities, constraints, non-goals, and a revenue model.

## How it works

The `plan_project` prompt gives the model a suggested workflow for interviewing the user, drafting a specification, checking the result, correcting problems, and rendering the final document. `spec_checklist` supplies categories such as platform, technology, audience, features, competitors, revenue, constraints, data, notifications, external services, and design. Each category contains concrete questions; some include selectable options while others remain open text.

A typical flow keeps the specification in the conversation. The model sends the resulting JSON object to `validate_spec`, addresses returned issues, and then calls `render_prd`. The renderer produces deterministic Markdown sections covering the title, overview, audience, platforms, stack, prioritized features, acceptance criteria, screens, navigation, data model, constraints, and non-goals. It refuses to render when structural validation errors remain.

## Setup and configuration

The draftlytic-mcp MCP server is launched through `npx` and does not require environment variables, an API key, an account, or network access. Claude Code can add it with:

```bash
claude mcp add draftlytic -- npx -y draftlytic-mcp
```

For Cursor, add a `draftlytic` entry to the project's `.cursor/mcp.json` or the global `~/.cursor/mcp.json`, using `npx` as the command and `-y`, `draftlytic-mcp` as its arguments. Other MCP hosts can use the same generic `mcp.json` server entry.

## Tools and capabilities

The draftlytic-mcp MCP server exposes four tools:

- `validate_spec` checks the JSON spec with Zod and returns structured errors for missing or empty required content, common placeholder text, and features without a priority. It also reports non-blocking quality hints, such as missing acceptance criteria for must-have features or absent non-goals.
- `render_prd` converts a structurally valid spec into Markdown and stops with an error when structural problems are present.
- `spec_checklist` returns categorized planning questions, with optional choices and single- or multi-select metadata.
- `open_in_draftlytic` accepts a plain-text idea or an optional full or partial spec and builds a local link to the Draftlytic application. The link pre-fills a starting brief; the application provides its own guided flow, editor, richer generation, and PRD export.

The server also includes the `plan_project` prompt, which coordinates the checklist, drafting, validation loop, and rendering steps.

## Limitations and notes

The draftlytic-mcp MCP server is synchronous and offline. It does not persist specs between calls, so saving the result requires asking the editor model to write it to a file. Its checks are heuristics: placeholder detection matches patterns such as `TBD`, `lorem ipsum`, and `fixme`, but does not judge whether a statement is substantively vague. A passing validation result therefore does not guarantee a sound plan.

The server is a planning aid rather than a project manager. It provides no collaboration, versioning, or export formats beyond Markdown. The local link builder sends nothing by itself, while the full Draftlytic application is where its additional guided editing and generation features live.

_Full upstream README: https://allmcps.com/mcp/draftlytic-mcp/readme_