PlanMySaaS Just Dropped on Claude Skills: One Slash Command, A Full SaaS Blueprint

TL;DR. PlanMySaaS just dropped as a Claude Skill. Open Claude Code, type /planmysaas "your saas idea", and in about two minutes you get back nine markdown files in your project folder — refined idea, market research, business model canvas, system architecture, feature specs, frontend wireframes, phased release plan, and a decision-grade build playbook with rubric-graded steps for Claude Code. The skill is open source, MIT licensed, and runs on your own Claude tokens. No account needed. Install link · Dashboard.

What we shipped today

Today we shipped PlanMySaaS as a Claude Skill. If you have not used Claude Skills before, the simplest way to think about them is this: a skill is a small package of markdown files that lives in your ~/.claude/skills/ folder. When you talk to Claude Code, Claude reads the descriptions of every installed skill and decides which one to use based on what you are asking. You can also call a skill explicitly with a slash command.

So with the PlanMySaaS skill installed, you can do this inside Claude Code:

/planmysaas "AI tutor for JEE students, voice-first, ₹99 per month"

Two minutes later, your project folder has a fresh ./planmysaas-blueprint/ directory with nine markdown files. Each file is a stage of a real SaaS plan — not bullet points, not a one-page summary, but actual structured documents with feature flows, data models, business model canvas, risk matrix, release plan, and a deep build playbook (rubric-graded, dependency-ordered) that the user follows in Claude Code, step by step, gate by gate, leaf to root.

Same engine that powers our web dashboard at planmysaas.com. Same eight-stage pipeline. Same opinionated structure. Just compressed into a skill that lives in your editor.

Why we shipped this as a skill, not just a web app

We already have a web dashboard. Founders sign up at planmysaas.com, get 100 free credits, and generate a 14-section blueprint with charts, version history, exports, and team collaboration. It works. Real founders use it. Robopandit, Clinic Saas, JeeNova — these are real projects in the system.

But there is a problem with the web flow. The audience we care most about — vibe coders, indie hackers, solo founders who already live in Claude Code — does not want to leave their editor to plan a product. They want to type one line and stay in the flow. Switching to a browser, signing up, copying outputs back to their editor — every one of those steps is friction. And friction is where ideas die.

Claude Skills solve this. The skill lives one slash command away. Outputs land in the same project folder where the code will be written. There is no signup, no credit limit, no internet round-trip. The friction goes from twelve clicks to zero.

That is the strategic move. Make the planning surface meet the builder where they already are.

The 8-stage pipeline, visualised

Every PlanMySaaS blueprint — whether it comes from the dashboard or the skill — runs through the same eight stages, in the same order. Each stage reads from the previous stage's output. By the time stage eight runs, the build playbook references the actual feature IDs from stage five, the data models from stage four, and the wedge from stage two — every build step grounded in earlier decisions.

This sequencing matters. Most AI planning tools fail because they generate every section in parallel, with no shared context. You end up with feature lists that do not match the architecture, prompts that ignore the design system, and a release plan that contradicts the wedge. By forcing the pipeline to run sequentially, every later stage is grounded in earlier decisions.

Stage 01 · Idea refinement

Takes your one-line idea and turns it into a structured brief. Project name, problem statement, target audience (the primary buyer plus two secondary personas), business model with a price hypothesis, top five features, founder rules, success criteria, and — critically — anti-goals. The anti-goals are mandatory. They define what the product is explicitly not. They prevent every later stage from drifting into scope creep.

Stage 02 · Market research

Five to eight competitors, classified into direct, adjacent, substitute, and manual-alternative categories. Each gets an opportunity score from one to ten. Then five problem clusters with frequency and severity. Five market gaps. Five non-obvious insights. And a one-paragraph strategic direction that names the wedge — the narrowest, fastest path to the first hundred paying users.

Stage 03 · Product analysis

The biggest stage. Executive summary, overall PMF score on a hundred-point scale, full SWOT, directional TAM/SAM/SOM with confidence levels, Porter's five forces with reasoning, the complete nine-block business model canvas, competitive positioning with current strengths and near-term differentiators, a seven-row risk matrix, and a six-dimension PMF breakdown. This is the stage that catches bad ideas before you spend three months building them.

Stage 04 · System architecture

Three to five top-level containers, ten to twenty-five services or modules grouped by domain, eight to fifteen core data models with relations, the top twenty REST API endpoints, background jobs, external integrations, and a one-row-per-layer tech stack. Opinionated by default — Next.js, Postgres, Prisma, Vercel, Razorpay or Stripe — but easy to override.

Stage 05 · Feature specifications

Twelve to twenty features, each with a numeric ID (F-01, F-02 …), priority (P0–P3), effort estimate in days, primary and secondary actors, purpose, numbered user flow, testable acceptance criteria, edge cases, and telemetry events to fire. Engineers can implement these directly. PMs can read them as briefs.

Stage 06 · Frontend blueprint

Routes grouped by public/app/admin sections, page specs for the top eight routes, ASCII wireframes (yes, real wireframes you can read in a markdown file), a component tree of twelve to twenty-five reusable components with their key props, and a design system covering colors, typography, spacing scale, radius, shadow, and motion. Plus a responsive grid spec.

Stage 07 · Phases and release plan

Five phases — Foundation, MVP, Public launch, Growth, Scale — each with a single goal sentence, broken-down tasks, and observable exit criteria. The risk register from stage three is restated with phase-aware mitigations. A decision log captures the initial trade-offs (why Next.js over Remix, why Razorpay over Stripe, why deferred mobile native) so future-you remembers the reasoning.

Stage 08 · Build playbook (rubric-graded, leaf to root)

The most important artifact. Not a list of paste-ready prompts — a deep, decision-grade build instruction set structured as a dependency tree. Foundation primitives first (repo bootstrap, deploy pipeline, data layer), then services, then features in priority order, then polish, then ship. Every build step has: 🎯 goal, 📍 why this comes first, 📥 inputs, 📤 outputs, 🛠 implementation details (files, locked tech decisions, mandatory patterns), ✅ acceptance rubric (8–14 testable checkboxes), ⚠️ edge cases, ❌ common pitfalls drawn from real failed shipments, 📊 measurable quality bar, and 🛑 stop-and-review gate. The user (or their AI agent) does not advance until every rubric item passes. It reads like a senior engineer's runbook for a high-stakes deploy — not a wishlist.

How a Claude Skill actually works under the hood

If you are curious about the mechanics, here is the simple version. A Claude Skill is a folder with at least one file: SKILL.md. That file has YAML frontmatter at the top — a name and a description. The description is the most important field, because Claude reads it when deciding which skill to invoke. A good description includes the trigger phrases and the situations the skill is designed for.

When you type something into Claude Code, Claude scans every installed skill's description, picks the best match, and loads the rest of SKILL.md as instructions for the conversation. The skill body can include a workflow, operating rules, references to other files in the skill folder, and templates.

Our SKILL.md is about eighty lines. It tells Claude when to invoke (any of about ten trigger phrases), what to do (run the eight stages in order, save outputs to ./planmysaas-blueprint/), and how to behave (no placeholders, no fake numbers, real specifics, easy English). For each stage, it tells Claude to read a separate prompt file from pipeline/. Those prompt files are the actual instructions for generating each section.

This is the elegance of the skill format. Anybody can read the prompts. Anybody can fork them. If you want a stage to be longer, more opinionated, or to use a different framework, you edit one markdown file. No code. No build step. No deploy.

Time to a usable blueprint

The chart above is honest. Building a real SaaS plan manually — proper market research, structured analysis, system architecture, feature specs, release plan, and build-ready prompts — takes a serious founder roughly two weeks. Most never finish; they get to the architecture stage and then start coding.

If you use ChatGPT with generic prompts, you can compress that to about four days. The output is shallower. Sections do not reference each other. You spend the saved time fixing inconsistencies.

The PlanMySaaS web dashboard, with its specialised pipeline and dedicated AI router, takes about thirty minutes for the full fourteen-section run. You get charts, version history, and exports. This is what teams use.

The Claude Skill takes about two minutes. You get the eight core sections — no charts, no version history, no exports, but the same opinionated structure and the same Claude Code ready build playbook at the end. The trade-off is intentional. Skill is for solo builders who want to start coding today. Dashboard is for teams who will iterate on the plan over months.

What you actually get back

The skill writes a single folder, ./planmysaas-blueprint/, into your current project. Inside are nine markdown files. Each file is between three hundred and twelve hundred lines depending on how rich the idea is. The README at the bottom is the index — it links every file and explains how to use them.

You can read these files in any markdown viewer, commit them to your repo, share them with a co-founder, or paste sections into Notion. The format is portable on purpose. We want the output to outlive the skill itself. If you uninstall the skill tomorrow, your blueprint is still useful, still readable, still actionable.

Inside 08-build-playbook.md there are 9–12 build steps in dependency order. Step 01 bootstraps the repo, deploy pipeline, and basic auth scaffolding (the leaf — nothing else works without it). Step 02 builds the data layer with Prisma schema and repositories. Step 03 layers in the service repositories. Step 04 wires permissions and middleware. Steps 05–07 ship the top P0 features in priority order, each with a full rubric. Step 08 wires payments. Step 09 polishes the frontend. Step 10 ships the marketing site. Step 11 sets up production observability. Step 12 establishes post-launch ops and runbooks (the root — everything before it has to work for this to matter). Every step ends with a stop-and-review gate that the user runs before advancing to the next.

Where the skill sits in the vibe-coder ecosystem

The Claude Skill does not replace anything you already use. It composes with the rest of your stack.

Claude Code is the host. The skill runs inside it. Anthropic provides the Skills platform — the discovery mechanism, the SKILL.md format, the runtime. We just shipped the markdown.

On the editor side, after the skill runs, you open 08-build-playbook.md and start working through Build Step 01 inside Claude Code — the same session you ran the skill in. Each step is written in plain English (not tool-specific), so if you ever switch editors the playbook remains portable. But the default flow is end-to-end inside Claude Code: skill generates the playbook, then Claude Code executes against it, step by step, with the rubrics as the quality gate.

On the planning side, when your project gets serious — multiple founders, real money on the line, ongoing iteration — you graduate to the dashboard at planmysaas.com. The dashboard imports the same blueprint format, then enriches it with web-search-driven competitor research, version history, charts, and export tooling.

Skill vs Dashboard: when to use which

This is the question we get most often, so here is the honest answer. The skill and the dashboard are not competitors. They are the same product expressed at two different friction levels.

Use the skill when you are exploring an idea, when you are about to start a hackathon project, when a friend pitches you something at lunch and you want to test whether it is worth a weekend, or when you are already deep in Claude Code and do not want to context-switch. The skill is fast, free for the user, and stays out of the way.

Use the dashboard when the project is real. When you have decided to spend three months on this. When you want to share the plan with co-founders or investors. When you need version history because you will iterate on the wedge based on early customer interviews. When you want to export to PDF for a pitch deck. When you want competitor research backed by actual web searches, not just Claude's training data. When the team grows beyond you.

In practice, most serious founders use both. They start with the skill to test ten ideas in a weekend, pick the one with the best PMF score, then move that one to the dashboard for ongoing planning.

Install and use in three steps

The install is one command. The skill folder lives at ~/.claude/skills/planmysaas/. Claude Code auto-discovers any skill folder there on startup. There is no registry, no install script, no API key.

Once installed, you can call the skill in two ways. The explicit way is the slash command — /planmysaas "your idea". The implicit way is to describe what you want in plain language: "Plan a SaaS for me", or "Help me turn this idea into a structured product plan". Claude reads the skill description and picks it automatically.

If you want to customise the skill — change the default tech stack from Next.js to Remix, add a stage between architecture and features, tighten the tone in any prompt — open the relevant file in ~/.claude/skills/planmysaas/pipeline/ and edit it. Plain markdown. No build step. Save and the next invocation uses the new prompt.

Why prompt-based skills are the future

We thought about shipping this as an API-backed skill. The skill would call POST https://planmysaas.com/api/v1/generate, the server would run the same engine that powers the dashboard, and the user would need an API key. That model captures revenue per use and gives us analytics. It is the obvious move.

We chose the prompt-based path instead, deliberately. Three reasons.

First, distribution beats monetisation in v1. A skill that is free to install, runs offline after install, and uses the user's own Claude tokens has a viral coefficient roughly an order of magnitude higher than one that requires an account and a credit. We want PlanMySaaS to become the default mental model for "how to plan a SaaS" — and that needs reach, not revenue, in the first six months.

Second, open source builds trust. The prompts are MIT licensed. Every founder who uses the skill can read exactly what we tell Claude to do. There is no black box. If a section feels wrong, they can fix it themselves and even send us a pull request. That kind of transparency creates a category of advocates that paid software cannot.

Third, the dashboard is genuinely better at the long-tail. We are not worried about the skill cannibalising the dashboard, because the dashboard does things the skill structurally cannot — live web search for competitors, charts, version history, exports, team workspaces, audit logs, and a slow-burning relationship with the founder over months. People who use the skill once will graduate to the dashboard when they get serious. That is the funnel we are designing.

The deeper bet is that the most useful AI tooling of the next two years will be distributed as markdown, not as APIs. APIs lock people into a vendor. Markdown skills are forkable, customisable, and shareable on GitHub. As the Claude Skills directory grows, the skills that win will be the ones engineers can read, audit, and tweak. That is what we built.

What is in the box, exactly

The skill repository at github.com/abhiverma/planmysaas-claude-skill contains:

• SKILL.md — Frontmatter with the trigger description plus the orchestration workflow (about eighty lines).
• README.md — Install instructions, what gets generated, how to customise, MIT license notice.
• pipeline/01-idea-refine.md — Prompt for refining the idea into a structured brief.
• pipeline/02-research.md — Prompt for competitor analysis, problem clusters, gaps, insights, and strategic direction.
• pipeline/03-analysis.md — Prompt for executive summary, PMF, SWOT, TAM, Porter's, BMC, positioning, risk matrix, and GTM.
• pipeline/04-architecture.md — Prompt for containers, services, data models, API surface, jobs, integrations, and tech stack.
• pipeline/05-features.md — Prompt for the feature index plus per-feature spec template.
• pipeline/06-frontend.md — Prompt for routes, page specs, ASCII wireframes, component tree, and design system.
• pipeline/07-phases.md — Prompt for foundation through scale phases plus risk register, decision log, and initiatives.
• pipeline/08-build-playbook.md — Meta-prompt that generates the decision-grade build playbook (9–12 dependency-ordered steps, each rubric-graded).
• templates/blueprint-readme.md — Template for the final README that indexes everything.
• templates/build-prompt-pack.md — Quick-reference cheat sheet for the Claude Code build flow.

Total skill size: about one thousand one hundred lines of markdown. No JavaScript, no Python, no package.json. Just instructions for Claude.

The roadmap from here

The skill is v1. Here is what is queued.

API mode (next two weeks). We will add an optional auth.md file that lets users connect their PlanMySaaS API key. When the key is present, the skill calls the dashboard's API and saves the project to the user's account, unlocking version history, charts, and exports. When the key is absent, the skill runs the prompt-based path. Same skill, two modes.

Skill variants. We will publish three sibling skills: /planmysaas-mvp for a faster four-stage cut focused on shipping the smallest thing, /planmysaas-validate for an idea-validation-only flow that stops at stage three, and /planmysaas-redesign for taking an existing product and replanning the architecture.

MCP server. We are also exposing the same engine over the Model Context Protocol so it works in any MCP-compatible client, not just Claude Code. This is mostly written; we are waiting on the right Anthropic Skills directory submission window to land both at the same time.

Localisation. The skill prompts are in English. The dashboard already supports Hindi and Hinglish output for Indian founders. We will port the language-toggle to the skill once we have feedback on which markets pick it up first.

Why this matters for vibe coders

The vibe-coder movement has a real weakness, and everybody who has shipped a vibe-coded product knows it. Speed of generation is no longer the bottleneck. Quality of decisions is.

You can scaffold a Next.js app in thirty seconds. You can wire auth in ninety. You can ship a landing page before lunch. None of that helps if you are building the wrong product, for the wrong audience, with the wrong wedge, at the wrong price point. The market is now full of beautifully built products that nobody wants to pay for, because the founder skipped the planning stage.

PlanMySaaS exists to make the planning stage as fast and as opinionated as the building stage. The skill drop closes the loop. From now on, when you have an idea, you do not need to leave Claude Code to think it through. Type one line. Get a structured plan. Decide whether the plan is worth coding. If yes, paste the prompts back into Claude Code and start. If no, you saved yourself a weekend.

That is the whole pitch.

Try it now

One install. One command. Two minutes from idea to blueprint.

• Install — git clone https://github.com/abhiverma/planmysaas-claude-skill ~/.claude/skills/planmysaas
• Use — Open Claude Code in any project folder and type /planmysaas "your saas idea"
• Read — Open the new ./planmysaas-blueprint/README.md and follow the index
• Build — Open 08-build-playbook.md and follow Build Step 01 in Claude Code. Do not advance to Step 02 until every checkbox in Step 01's acceptance rubric passes.

If the skill saves you even one weekend, that is one weekend you can spend talking to your first ten users instead of staring at a blank planning doc. That is the whole game.

And when the project gets real — when you start charging, when a co-founder joins, when the architecture needs to evolve over six months — graduate to the dashboard at planmysaas.com. Same engine, richer surface, hundred free credits to start.

If you ship something with the skill, post it on X and tag @planmysaas. We are collecting the best blueprints from the first month and featuring them on the homepage. The earliest community projects get a free year of the dashboard's Pro tier.

Welcome to PlanMySaaS in your editor. Now go plan something.