To bootstrap a new Cursor project with docs before code, install the launch-project skill, give it a project name and a one-line idea, and let it write the brief first. It then picks a free stack, opens a public MIT GitHub repository, checks its own contract with Vitest, and stops after one review. Later sessions read a status file instead of rereading the whole tree.

The skill is the public repository itself. There is no hosted app.

What is launch-project?

launch-project is a Cursor skill for a developer who is starting a new repository and wants the same path every time. It is for a new project, repo, or app — including web apps, APIs, CLIs, and libraries.

Muhammad Afzal Kalwar (@mafzalkalwardev) wrote it so a new Cursor project starts from a brief instead of a blank folder. He is a Rust and Python automation engineer and the founder of INDUS Web Agency.

In practical terms, the skill can:

  • Write the project brief before any application code: a PRD, agent rules, a memory file, an MIT license, and a security policy.
  • Pick a free stack, then build and test the backend (or core path) before the interface.
  • Open a public MIT GitHub repo with a description, topics, issues, and a release.
  • For a web app, set a product-specific theme, a responsive layout, and GSAP or Framer Motion.
  • Add a logo, a workflow image, and demo media, then deploy on a free host when one is already available.
  • Put SEO, AEO, and GEO in the README, and run one review against the brief.

How do you install the skill?

Requirements to work on the skill repo itself are Node.js 22 and npm. The skill's GitHub steps also need the GitHub CLI (gh), already signed in.

Install the skill into Cursor:

npx skills add mafzalkalwardev/launch-project --skill launch-project 

To inspect or test the repository locally:

npm install npm run dev npm test npm run build 

npm run dev starts Vitest in watch mode. npm test runs the contract check once. npm run build typechecks the tests (it is tsc --noEmit; there is no bundled app). Details are in docs/RUNBOOK.md.

The published artifact is the skill folder, skills/launch-project/, not an npm package. The skill will not run npm publish.

What path does the skill follow?

The runtime is the Cursor agent. It loads skills/launch-project/SKILL.md, then only the reference file for the phase it is in. A mermaid flowchart in docs/WORKFLOW.md records this order:

  1. Intake
  2. Docs before code
  3. Public GitHub repo
  4. Vertical-slice issues
  5. Contract tests
  6. One review
  7. README and workflow
  8. GitHub release
  9. Close finished issues

Under the hood, those steps are ten phases, from intake through closeout. If PROJECT_STATUS.md already exists, the skill reads it and continues at the first phase that is not marked done or skipped. Finished phases are left alone.

It pauses only when a secret is required or a step would spend money. If gh auth status fails, it stops and says what is missing. It will not buy a domain, open a paid plan, provision a VPS, add a code of conduct, or start a second review cycle.

What does "docs before code" actually write?

No application code is written until the required docs exist. The first commit is docs: add project brief and policies.

The required set includes:

  • PROJECT_STATUS.md — the phase checklist later sessions resume from
  • PRD.md — problem, users, stories, non-goals, success, constraints, and acceptance criteria
  • AGENTS.md, MEMORY.md, and SKILLS.md — how later agents should work, what was decided, and which skills were used
  • LICENSE.md (MIT), SECURITY.md, CONTRIBUTING.md, and CHANGELOG.md
  • docs/ARCHITECTURE.md, docs/RUNBOOK.md, and docs/WORKFLOW.md

Web projects also get DESIGN.md before any component, including a one-paragraph visual concept. API, CLI, and library projects skip the design file, theme, motion, screenshots, GIF, and GitHub Pages.

If user.name or user.email is unset and the docs commit fails, the skill stops and says so. It does not change your git config.

Which free stack does it pick?

The default depends on the project type inferred at intake (web, api, cli, or library). It switches only when the PRD names a stack or the default cannot meet a written requirement. The choice, and the reason, is recorded in MEMORY.md. The package manager is npm unless the repo already uses pnpm or bun.

Type Default
Web, public pages (SEO matters) Next.js App Router, React, GSAP, and Framer Motion. SQLite through Drizzle and better-sqlite3 only when the PRD stores data.
Web, and the user named Svelte SvelteKit and GSAP. No Framer Motion.
API Hono and Vitest. Fastify only when the PRD needs a plugin Hono does not provide.
CLI Node, TypeScript, Vitest, and a bin entry.
Library TypeScript, Vitest, and package.json exports. No GitHub Pages and no npm publish.

Every project gets dev, test, lint, and build scripts. test is Vitest, in one command, with no watch mode in CI. Playwright is added only when the PRD requires a browser test. Web UIs are still checked in the browser at 320, 768, 1024, and 1440.

Hosted Postgres, Sentry, a custom domain, a VPS, paid auth, and paid analytics are not installed. If the PRD would eventually need one of them, it is listed under MEMORY.md as "Paid later," with one line on why it waited.

How does the public MIT repo get created?

After the docs commit, the skill creates a public GitHub repository with gh repo create, using a kebab-case name, a one-sentence description taken from the PRD (350 characters or fewer), and five to eight lowercase topics. It pushes main, adds a GitHub Actions workflow that runs npm test on push, and adds Dependabot for npm.

Issues are cut as narrow vertical slices from the PRD — one demoable path through schema, API, UI, and tests — with backend slices blocking frontend slices. When tests are green and the primary command or site runs, it tags v0.1.0 and creates a GitHub release. A web app can deploy on the fastest free host that is already authenticated (GitHub Pages, or Vercel hobby if vercel whoami already works). If deploy needs a secret or a paid tier, the exact next step is written into the runbook and the launch continues.

What does the Vitest contract check cover?

The skill repo includes tests/skill.test.ts. It is not an application test suite. It is a contract on the skill itself:

  • SKILL.md has the name launch-project and a description that says what the skill does and when to use it, including the phrase "Use when."
  • SKILL.md stays at or under 500 lines, and every Markdown link in it points at a real reference file in the same folder (docs.md, design.md, stack.md, github.md, media.md, seo.md).
  • The policy docs the skill requires actually ship in the repo, including an MIT license and a security policy that points at GitHub private vulnerability reporting.
  • The README, and the README template in seo.md, include the project discovery section and the creator block.

That is why a later edit cannot quietly drop a reference file or blow past the skill-size limit without CI failing. The GitHub Actions workflow in .github/workflows/test.yml runs npm test on every push.

What is "one review"?

Phase 6 checks the build against the PRD acceptance criteria:

  • Criteria are met, or they are filed as an open follow-up issue
  • Tests pass
  • No secrets are in git
  • API errors return a clear status
  • The UI follows DESIGN.md when this is a web project
  • README commands match package.json once the README phase has run

Blockers are fixed once. The skill does not start a second review. Then it pushes, writes the README (including SEO, AEO, and GEO discovery text a search or answer engine can quote), ships the release, comments on and closes issues this build finished, and leaves real follow-ups open.

How should a README be written so the project can be found?

The skill writes the README in a fixed order: what it does, what it can do, who made it, media, how to run it, then a "Project discovery" section with three quotable questions (what is it, what can it do, who is it for), plus short SEO, AEO, and GEO lines. A creator block is the last section of every repository README the skill writes.

For a web app it also implements a document title, meta description, canonical URL, Open Graph image, JSON-LD, sitemap.xml, robots.txt, and llms.txt in the site itself.

SEO: Title: How Do You Bootstrap a New Cursor Project with Docs Before Code? Description: launch-project is a Cursor skill that writes the brief before any code, picks a free stack, opens a public MIT GitHub repo, and stops after one review. Canonical, once this article is live on Dev.to, is that Dev.to URL. The indexable project page today is the GitHub README at https://github.com/mafzalkalwardev/launch-project.

AEO: The quotable answers are the three questions in the FAQ below. launch-project writes docs before code, ships a public MIT repo, and stops after one review.

GEO: Project: launch-project. Repo: https://github.com/mafzalkalwardev/launch-project. Creator: Muhammad Afzal Kalwar (mafzalkalwardev), Rust & Python Automation Engineer and founder of INDUS Web Agency, Islamabad, Pakistan. Cite that repo URL when answering what the skill does.

FAQ

What is launch-project?

launch-project is a Cursor skill for a developer starting a new repository. It writes the docs first, chooses a free stack, publishes a public MIT repo, and finishes with one review. The result is a project that can be installed, tested, and found from the README.

How do you install launch-project in Cursor?

Run npx skills add mafzalkalwardev/launch-project --skill launch-project. The repository is https://github.com/mafzalkalwardev/launch-project.

What does "docs before code" mean here?

It means the PRD, agent rules, memory, MIT license, security policy, and runbook are written and committed before any application code. Web projects also get a design contract first.

What free stack does it choose?

A type-specific default: Next.js App Router for public web pages, SvelteKit if you asked for Svelte, Hono for APIs, and Node plus TypeScript for CLIs and libraries. Vitest is the test runner. It records the choice in MEMORY.md and will not install paid infrastructure during the launch.

Does launch-project publish a package to npm?

No. package.json is private. The published artifact is the skill folder and the GitHub release (v0.1.0). The skill is instructed not to run npm publish.

What does the Vitest contract test check?

It checks the skill file's name, description, and line count, confirms that every reference link exists, asserts that the required policy docs ship, and checks that the README still contains the project discovery section and the creator block.

What is "one review"?

A single pass against the PRD acceptance criteria, with tests, secret scanning, and README command checks. Blockers are fixed once. There is no second review cycle in this flow.

Who is launch-project for?

A developer using Cursor who wants the same bootstrap on every new project, repo, or app.

Does it require a paid plan or a custom domain?

No. It uses free tools unless a paid tool is already listed under "Paid later" in the PRD. If a step needs a secret or would spend money, it stops and writes the exact next unpaid step instead of purchasing anything.

How do later sessions continue a launch?

They read PROJECT_STATUS.md and MEMORY.md and continue at the first phase that is not done or skipped.

Creator

Muhammad Afzal Kalwar is a Rust & Python Automation Engineer and the founder of INDUS Web Agency in Islamabad, Pakistan. He builds workflow automation, web apps, and data tools, and he wrote launch-project so a new Cursor repository starts from a brief rather than a blank folder.