The draftlytic-mcp server helps you turn rough project ideas into structured, validated PRDs — running entirely locally with no API keys or network calls required.
spec_checklist: Returns a categorized interview checklist (platform, tech stack, target audience, features, data model, etc.) with concrete questions to guide spec creation.
validate_spec: Checks a spec JSON against a schema, reporting errors (missing sections, placeholder text like "TBD"/"lorem ipsum", missing feature priorities) plus non-blocking quality hints (e.g. missing acceptance criteria).
render_prd: Converts a validated spec into a clean, deterministic Markdown PRD with features grouped by priority, acceptance-criteria checklists, data model tables, constraints, non-goals, and more.
open_in_draftlytic: Generates a URL (built entirely locally) to open an idea or partial spec in the full Draftlytic web app for richer AI-guided generation, editing, and export.
plan_project (prompt): Orchestrates the full flow — interviews you using the checklist, drafts a spec, validates and fixes it in a loop, then renders a final PRD ready to drop into a coding agent or SPEC.md.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@draftlytic-mcp plan a habit tracker with SMS reminders"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP server that turns a rough project idea into a structured spec — right inside Claude Code, Cursor, or any MCP-compatible editor. No API key, no account, no network calls. It runs entirely on your machine and hands your editor's model a schema to write into, a checklist of what to ask about, a validator that catches gaps before you start coding, and a renderer that turns the result into a clean Markdown PRD.
This exists because "vibe coding" from a one-line prompt tends to produce a plausible-looking app that's missing half the decisions you actually needed to make — what's in scope for v1, what the data model looks like, what "done" means for a feature. draftlytic-mcp doesn't generate any of that for you; it structures the conversation so your model asks the right questions, then checks its own homework before you start building.
claude mcp add draftlytic -- npx -y draftlytic-mcpAdd to .cursor/mcp.json in your project (or the global ~/.cursor/mcp.json):
{
"mcpServers": {
"draftlytic": {
"command": "npx",
"args": ["-y", "draftlytic-mcp"]
}
}
}Most MCP hosts read a generic mcp.json with the same shape:
{
"mcpServers": {
"draftlytic": {
"command": "npx",
"args": ["-y", "draftlytic-mcp"]
}
}
}Related MCP server: MCP SDD Server
Once connected, ask your editor's model something like:
Use the plan_project prompt for "a habit tracker that reminds me by text message"
It'll walk through spec_checklist with you (platform, tech stack, audience, features, competitors, revenue, constraints, data model, notifications, external services, design & UX — a handful of concrete questions per category, many offered as click-to-pick single/multi-select choices rather than blank prompts, with a free-text escape always available), draft a spec, run it through validate_spec, fix what comes back, and hand you a rendered PRD in Markdown you can drop straight into a coding-agent prompt, a SPEC.md, or a GitHub issue.
You can also call the tools directly if you already have a spec drafted (by hand, or from another source) and just want it checked and rendered.
Tool | Input | What it does |
|
| Zod-validates the spec and returns structured issues: errors for missing/empty required sections, placeholder text ( |
|
| Renders a validated spec into deterministic Markdown: title, overview, target audience, platforms, tech stack, features grouped by priority with acceptance-criteria checklists, screens & navigation, data model tables, constraints, and non-goals. Refuses to render (returns an error) if the spec has structural errors. |
| — | Returns the planning checklist grouped by category, each with 2-4 concrete questions. Each question is |
|
| Builds a link that opens your idea in the full Draftlytic app with the brief pre-filled — its guided AI question flow, richer generation, an editable spec editor, and PRD export live there. Compresses a spec (even a partial one) into a starting brief, or takes a plain-text idea. Builds the URL locally; sends nothing anywhere. |
Plus one prompt:
Prompt | Args | What it does |
|
| Instructs the model to interview the user with |
{
name: string
overview: string
target_audience: string
platforms: string[]
tech_stack: string[]
features: Array<{
title: string
description: string
priority: "must-have" | "nice-to-have" | "future"
acceptance_criteria?: string[]
}>
screens?: Array<{ name: string; purpose: string }>
data_model?: Array<{
entity: string
fields: Array<{ name: string; type: string; notes?: string }>
}>
constraints?: string[]
non_goals?: string[]
revenue_model?: string
}This is v1 and purely local. There's no Draftlytic API behind it — every tool runs synchronous, offline logic against whatever spec JSON your editor's model hands it. It doesn't call any AI itself.
The model does the writing, this just structures it. validate_spec and spec_checklist are heuristics, not a substitute for actually knowing what you're building. A spec that passes validation can still be a bad plan.
Placeholder detection is pattern-based, not semantic. It catches TBD/lorem ipsum/fixme-style filler, not "this description is vague but technically real words."
No persistence. Nothing is saved between calls — the spec JSON lives in the conversation. If you want it saved, ask your model to write it to a file.
No collaboration, no versioning, no export formats beyond Markdown. It's a planning tool, not a project manager.
draftlytic-mcp is the offline sibling of draftlytic.com — the full editor adds AI generation, logo drafts, scan-for-gaps, and GitHub push.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| idea | No | Plain-text idea to hand off when there is no spec yet. | |
| spec | No | A spec object (may be partial) to compress into the handoff brief. Takes precedence over `idea`. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description carries the full burden. It explains the behavior: builds a link, compresses spec or passes plain-text idea, and returns a URL. It does not contradict any annotations. Additional details like the external flow (guided questions, PRD export) add context, but some aspects like rate limits or authentication are not mentioned.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is relatively long but well-structured, front-loading the main purpose. Each sentence adds information about functionality or constraints. Minor redundancy ('free account, no card' could be streamlined) but overall efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, the description explicitly states what the tool returns (a URL to show as a clickable link) and explains the external flow. It covers both parameters and provides enough context for an agent to understand the purpose and outcome. Highly complete for a tool with simple parameters.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are described. The description adds value by explaining that spec takes precedence over idea and that spec gets compressed into a starting brief. This clarifies the interaction between the two parameters beyond the schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool builds a link to open an idea in the Draftlytic app. It specifies the verb 'build a link' and the resource 'Draftlytic app', which distinguishes it from sibling tools like render_prd or validate_spec that operate within the current environment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use this tool: to hand off to the Draftlytic app. It mentions that it only builds a URL and nothing is sent, which sets expectations. However, it does not explicitly state when not to use it or provide alternatives beyond implicit differentiation from siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| spec | Yes | The spec object to render, as a JSON value (not a JSON string). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description details the output structure comprehensively: sections like title, overview, features grouped by priority, data model tables, etc. States determinism and Draftlytic-style. Does not mention side effects or authentication, but for a render tool with no side effects, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Description is approximately 5 sentences, each providing essential information. Front-loaded with the primary action ('Render a project spec...'), followed by input format, output details, and a usage note. No redundancy or unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 1-parameter tool with no output schema and no annotations, the description is thorough. It explains the input structure, output format, and a prerequisite. A minor gap: it does not explicitly state that the output is a Markdown string (though implied by 'Markdown PRD'), but overall it is quite complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has 100% coverage with a single 'spec' parameter described as a JSON value. Description adds substantial meaning by enumerating the expected fields of the spec (name, overview, target_audience, platforms, tech_stack, features with detailed subfields, screens, data_model, constraints, etc.). This goes far beyond the schema's minimal description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool's purpose: rendering a project spec into a deterministic Draftlytic-style Markdown PRD. It specifies input (project spec with detailed fields) and output (structured PRD with sections). Differentiates from siblings (validate_spec, spec_checklist, open_in_draftlytic) by focusing on rendering.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises to run validate_spec first, which guides the agent on proper sequencing. Also notes that the tool accepts incomplete specs, setting expectations. Does not fully specify when 'not' to use it, but provides clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description fully explains the tool's behavior (returns a checklist grouped by categories with questions). No annotations contradict this. It could mention if the output is static or dynamic, but overall transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first describes output, second explains usage. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description fully covers what the tool returns and how to use it. With no parameters or output schema, it provides all necessary information for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so description adds no param info; baseline 4 applies. The description's focus on the output is appropriate given zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool returns a planning checklist grouped by specific categories with concrete questions. It distinguishes itself from sibling tools (open_in_draftlytic, render_prd, validate_spec) by focusing on planning before drafting.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly says 'Use this to interview the user before drafting a spec' and advises not needing to ask every question, providing clear when-to-use and how-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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".
| Name | Required | Description | Default |
|---|---|---|---|
| spec | Yes | The spec object to validate, as a JSON value (not a JSON string). |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description adequately discloses validation behaviors and return types (errors and hints), though it does not mention side effects or resource consumption.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single dense paragraph that conveys essential information but could be more concise or structured for quicker scanning.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of output schema, the description usefully explains the types of issues returned but could be more precise on the output format.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage but only a brief description; the tool description compensates by detailing the expected spec structure, which is valuable for parameter specification.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool as a validator for project specs, listing the spec structure and the checks performed, which distinguishes it from siblings like render_prd or spec_checklist.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains what the tool does but does not explicitly state when to use it versus alternatives or when not to use it, leaving some ambiguity for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.2.0open_in_draftlyticrender_prdspec_checklistvalidate_specEach tool has a clear, distinct purpose: generating links, rendering PRDs, providing checklists, and validating specs. No overlap or confusion.
Names use underscores but mix verb_noun (render_prd, validate_spec), verb_preposition_noun (open_in_draftlytic), and noun_noun (spec_checklist), lacking a uniform pattern.
Four tools cover the essential workflow of gathering requirements, validating, rendering PRD, and linking to external app. No extraneous tools; each earns its place.
The surface covers the key stages from requirements gathering to PRD generation and external integration. A minor gap is the lack of a tool to edit or update a spec, but the pipeline is functional.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
MCP server for generating rough-draft project plans from natural-language prompts.
Official DevSpeak MCP server — translate technical text into formal specs from any AI IDE or agent
A MCP server built for developers enabling Git based project management with project and personal…
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/rbsoftwaresystems/draftlytic-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
