API Documentation Prompt
Overview, Authentication, Endpoints, Error Handling, Rate Limits — endpoint docs in an identical structure, with parameter tables and runnable examples forced.
View Resource →Structured Output
Markdown Output Builder
Stop documents that reorder themselves every run. Define the document type and its section skeleton, set the table, code, and consistency rules — and get a markdown prompt that returns the same structure every time. READMEs, PRDs, docs, reports. Runs entirely in your browser.
What gets produced, and for whom? E.g. "Create consistent product requirement documents."
Document Sections *
The document's heart: every section with a title and the job it must do. Reorder with ↑ ↓.
Suggested for Custom
Document Preview (live skeleton — not the output)
Markdown Output Prompt
Changelog Prompt — User-Readable Change Logs
Added, Changed, Fixed, Removed, Security — changelog entries written as user-visible changes, not commit messages.
View Resource →Database Migration Plan Prompt
Ship a schema change without downtime or data loss — an expand-migrate-contract migration plan with backward compatibility, ordering, and a reversal path.
View Resource →Deployment Runbook Prompt
Turn a deploy into a runbook anyone can execute — ordered steps, preconditions, verification at each gate, and the rollback hook, instead of tribal knowledge.
View Resource →FAQ Documentation Prompt
Every entry a "## Question?" heading with a self-contained answer — FAQs grouped by topic, phrased the way users actually ask.
View Resource →Feature Flag Release Prompt
Decouple deploy from release — a feature-flag rollout plan with the flag's default, targeting, kill switch, and the cleanup that stops flags becoming permanent debt.
View Resource →Markdown Output Prompt — Lock the Document Structure
The contract that stops AI documents from restructuring themselves: a pinned section skeleton, forced tables, and strict consistency rules.
View Resource →Markdown Report Prompt
Purpose, Highlights, Details, Recommendations, Next Steps — recurring business reports with conclusions first and numbers in context.
View Resource →Meeting Notes Document Prompt
Attendees, Decisions, Discussion, Action Items, Next Meeting — the notes document every meeting fills the same way.
View Resource →Monitoring & Alerting Plan Prompt
Decide what to watch before you ship — the signals, thresholds, and alerts for a release, so a silent failure pages you instead of surfacing in a support ticket.
View Resource →Post-Deploy Smoke Test Prompt
Confirm a deploy is actually healthy — a short, ordered smoke-test checklist of the critical paths to verify in the first minutes after shipping.
View Resource →PRD Prompt — Consistent Product Requirement Documents
Problem, Goals, Non-Goals, numbered Requirements, Risks, Timeline — PRDs identical in structure across every author and feature.
View Resource →README Prompt Template
Overview, Installation, Usage, Examples, Configuration — the README skeleton with required, runnable code examples.
View Resource →Release Readiness Checklist Prompt
A go/no-go checklist for a release — config, secrets, migrations, comms, rollback, and monitoring all confirmed ready before you ship, ending in a clear GO or NO-GO.
View Resource →Research Brief Prompt
Objective, Background, Findings, Recommendations, Open Questions — briefs where what was found and what to do stay clearly separated.
View Resource →Rollback Plan Prompt
Turn a deploy into a deploy you can undo — a step-by-step rollback plan with triggers, the reverse of every forward step, and the point of no return named.
View Resource →Staged & Canary Rollout Prompt
Ship to a few before the many — a canary/staged rollout plan with cohorts, the metrics that gate each stage, and the auto-rollback condition.
View Resource →Technical Documentation Prompt
Overview, Key Concepts, How It Works, Usage, Troubleshooting — docs pages with the same shape for every feature, and code in every usage section.
View Resource →Zero-Downtime Deployment Prompt
Ship without a maintenance window — a deployment strategy (blue-green or rolling) that keeps the service up, handles in-flight requests, and stays compatible across versions.
View Resource →AI Project Architecture Workflow
Design a system's architecture on its real trade-offs instead of a confident diagram — put the model in an architect's seat, work the decisions one at a time, and write down the why.
View Playbook →AI Database Design Workflow
Design a schema on its data, not a hunch — model the entities and relationships, set the constraints that protect integrity, plan indexes around real queries, then document the schema and migration.
View Playbook →AI Auth & Identity Workflow
Design access control before you build it, not after a breach — choose the authentication approach, model the roles and permissions, review the design for gaps, then document the identity model.
View Playbook →AI Integration & Webhook Workflow
Connect systems so they don't break each other — map the integration boundaries, design the event and webhook contracts, plan retries and failure handling, then document the integration.
View Playbook →AI Production Incident Workflow
Work a live production incident in the right order — triage and stabilize first, then find the cause, then write the summary and postmortem — so the fire is out before the writeup begins.
View Playbook →AI Deployment & Release Workflow
Cross the gap between 'tests pass' and 'safe in production' — assess release readiness, plan the deploy and its rollback, and set up the monitoring and launch checks before you ship, not after.
View Playbook →AI Data Pipeline & ETL Workflow
Design a pipeline that moves data without corrupting it — map the sources and ingestion, design the transformation stages, set validation and quality gates, then document the pipeline and monitoring.
View Playbook →AI Meeting Notes Workflow
Turn a meeting transcript into notes people actually use — a faithful summary, the action items pulled out and assigned, and a clean shareable format.
View Playbook →AI Code Documentation Workflow
Generate documentation that matches the code instead of drifting from it — have AI explain what the code really does, write it up as structured docs, then validate the format holds.
View Playbook →AI Product Requirements Workflow
Turn a fuzzy business need into requirements a team can build from — interrogate the need into concrete requirements, shape them as user stories, and write the PRD.
View Playbook →AI Content Strategy Workflow
Decide what to publish and why before you write a word — set the business goals and audience, map needs to topics, brief the priority pieces, then turn it into a content plan you publish against.
View Playbook →AI Website Structure Workflow
Organize a site so people and crawlers find things — inventory the content, group it into a real hierarchy, design the sitemap and navigation, then document the information architecture for the build.
View Playbook →AI UI & Component Design Workflow
Structure a UI so it stays consistent as it grows — inventory the screens, break them into reusable components, specify the component system and its rules, then review the structure for drift.
View Playbook →Build a SaaS MVP with AI
The full path from idea to a shipped SaaS MVP — define and scope the requirements, design the architecture, API, and data model, then build it reviewed, tested, secured, cost-controlled, and deployed.
View Blueprint →Build an API Backend with AI
The full path to a backend you can put clients on — define the requirements, design the architecture, API contract, data model, and access control, then build it reviewed, tested, secured, and shipped.
View Blueprint →Build a Company Website with AI
The full path to a business website that holds together — plan the content, structure the site, design the components, write the page copy, then ship it as one coherent whole.
View Blueprint →Modernize a Legacy Codebase with AI
The full path to taming an inherited codebase — understand it, document its architecture, pin its behavior with tests, then refactor, modernize, review, speed up, and ship it without breaking what works.
View Blueprint →Build a Documentation Website with AI
The full path to docs people can actually navigate — plan the doc set, structure the site, write the guides and the API reference, then ship it as a coherent documentation site.
View Blueprint →Build an AI Content Engine with AI
The full path to a content operation that runs, not a pile of posts — set the editorial strategy, research the topics, build a reusable template, then produce and QA structured pieces on repeat.
View Blueprint →Build an AI Workflow Automation System with AI
The full path to automation that survives the real world — wire the integrations and triggers, design the control API, move the data through validated stages, evaluate the AI steps, then deploy.
View Blueprint →Build a Customer Support System with AI
The full path to a support operation, not just a bot — stand up the knowledge base, route the tickets, add the AI agent, integrate your stack, close the feedback loop, evaluate, and deploy.
View Blueprint →Build a Knowledge Base with AI
The full path to knowledge that's findable by people and AI — plan the taxonomy, structure it for search, write the articles, tag the metadata, make it retrievable, then ship it maintainable.
View Blueprint →Build a Marketplace with AI
The full path to a two-sided platform — define the buyer-and-seller requirements, model the data, design the API, build roles and permissions, wire integrations, design the UI, then test, secure, and ship it.
View Blueprint →Build a CRM with AI
The full path to a CRM that fits your sales process — define the contacts, deals, and pipeline, model the data that ties them together, then build the roles, integrations, and pipeline UI, and ship.
View Blueprint →Build an E-commerce Store with AI
The full path to a store you own end to end — model the catalog and orders, design the storefront and checkout, add customer accounts and payments, then secure it, test it, and ship.
View Blueprint →Build a Data Pipeline with AI
The full path to a pipeline that moves data without corrupting it — design the ingestion and transforms, extract and structure the sources, gate the quality, store it, then deliver and ship it monitored.
View Blueprint →How it works
Describe the document goal, pick the document type — README, PRD, technical documentation, report, FAQ, changelog, meeting notes, research brief, blog outline, or custom — and build the section skeleton: every section with a title and the job it must do. The document type adds type-specific rules to the prompt (FAQs force the "## Question?" format, PRDs number their requirements) and suggests the sections that type usually carries — add them with one click. Set the table mode (Required forces real markdown tables for comparisons), code block handling (Require suits READMEs and tech docs), and the consistency level — the tool's core value, with Strict pinning every section, the exact order, and the exact heading text. The live preview shows the document skeleton your prompt will enforce. Click Generate Markdown Prompt and reuse the result for every document of that type. Nothing leaves your browser.
Use cases
- READMEs and technical docs with the same structure across every project
- PRDs whose sections never go missing between authors
- Reports and research briefs that look identical every cycle
- Changelogs and FAQs that keep their format at volume
Pro tips
- Section descriptions are contracts, not labels: "Decisions made, one per bullet" produces a different document than a bare "Decisions" heading. Write what the section must contain — and what it must not.
- Use Strict consistency when documents get compared or diffed — identical structure is what makes ten PRDs reviewable in one sitting.
- Required Tables earns its keep on comparisons: models love collapsing tables into prose, and the "never collapse a table into prose" rule is the counterweight.
- For API docs and READMEs, pair Require Code Examples with Strict: "usable as written — no pseudo-code" stops the placeholder-snippet habit.
FAQ
Does this tool generate the document?
No — it generates the markdown PROMPT. You define the document's structure once (sections, tables, code, consistency), generate, and reuse the prompt every time that document type gets written. The payoff is consistency: the model returns the same skeleton every run instead of reinventing the structure.
How is this different from the Structured Summary Prompt?
Direction. The Structured Summary Prompt compresses an EXISTING source — every rule it has exists because there's a text to stay faithful to. This tool structures NEW documents the model writes from scratch: there's no source, so the rules are about structure, format, and consistency instead of fidelity. Same family, opposite direction.
And how is it different from the Prompt Formatter?
The Prompt Formatter restructures the PROMPT itself — your messy instructions become organized instructions. This tool defines the structure of the AI's ANSWER. One works on what you send; the other contracts what comes back.
What does the consistency level actually change?
The CONSISTENCY RULES block. Flexible treats your sections as a guide. Standard requires every section in order and bans new top-level sections. Strict adds the full pin: no omitted headings even when short, no merged sections, and the exact heading text as defined — the level you want when documents get compared, diffed, or templated.
When should I force tables?
Whenever the content compares things: feature matrices, option comparisons, parameter lists, PRD requirement tables. Models habitually collapse tables into paragraphs; Required Tables makes the table a contract — header row, separator row, one row per item, same columns throughout, "—" for empty cells.
Why does the document type matter if I define my own sections?
Because the type carries rules that aren't sections: an FAQ must format every entry as a "## Question?" heading, a changelog writes user-visible changes instead of commit messages, a PRD numbers its requirements so reviews can reference them. The type also suggests the standard sections — but your section list always wins; the suggestions are one-click additions, not impositions.