payo

Generate project-tailored AI assistant rules & skills in minutes.

Payo interviews you about your stack, then writes the guidance files your AI
coding assistant reads — so Claude, Cursor, Copilot, and friends follow your
project's conventions instead of guessing.

Contents

• What is Payo?
• Why Payo?
• Who is this for?
• Quick Start
• How to use — a walkthrough
• What gets generated
• What it asks about
• AI vs. template generation
• Bootstrap prompt
• Resume anytime
• Roadmap
• Requirements
• Run locally
• Contributing
• License

What is Payo?

AI coding assistants are only as good as the context they're given. Payo is an
interactive CLI that interviews you about your project — language, framework,
database, auth, testing, conventions — and then generates the guidance files
your assistant actually reads.

It supports Claude, Cursor, GitHub Copilot, Codex, Windsurf, and Antigravity.
Where the assistant ships a headless CLI, Payo drives that tool's own AI to
write rich, project-specific docs; where it doesn't, Payo falls back to solid
templates — so you always end up with usable output.

Why Payo?

Every AI coding session starts cold. Your assistant doesn't know you use Drizzle
over Prisma, that handlers live in src/routes, that you write Vitest specs
beside the file, or that commits follow Conventional Commits. So you re-explain
it — in chat after chat — and still get code that ignores half of it.

The fix is the guidance files each tool already reads (CLAUDE.md,
.cursorrules, .github/copilot-instructions.md, AGENTS.md). But writing them
by hand is tedious, easy to get wrong, and different for every tool. Most people
never do it, or do it once and let it rot.

Payo writes them for you in minutes — tailored to your actual stack,
in each tool's native format — so your assistant follows your conventions from
the first prompt instead of guessing.

Vibe coding, without the mess

Vibe coding is fast and fun — you prompt, the AI improvises, code appears. The
problem isn't the speed, it's that the assistant has no rules to improvise
within. So it guesses: a different ORM than the rest of the repo, files
scattered wherever, its own naming, your tests and commit conventions skipped.
Fine for a throwaway demo; on a real codebase it quietly piles up inconsistency
you pay for later in reviews, bugs, and refactors — and each new chat starts the
guessing over.

Payo gives that improvisation a guardrail. It generates the guidance files your
assistant already reads, so the AI reaches for your framework, your folder
layout, your testing and git rules every time — without you stopping to explain
them. You keep vibe coding at full speed; the output just fits the project
instead of fighting it.

Who is this for?

• Devs starting a new repo who want their AI assistant productive from
  commit #1, not after a dozen "actually, we do it this way" corrections.
• Teams enforcing conventions who need every contributor's assistant to
  follow the same folder structure, naming, testing, and git rules.
• Multi-tool users who switch between Claude, Cursor, and Copilot and want
  the same project guidance expressed in each tool's native format.
• Anyone bootstrapping a stack they haven't wired up before — Payo encodes
  sensible, framework-specific defaults and can scaffold a runnable project.

If you've ever pasted the same "here's how this project works" preamble into a
chat for the third time, Payo is for you.

Quick Start

No install required — run it in any project directory:

npx @uge/payo
# or
bunx @uge/payo

The command you run after install is still payo. Install globally with
npm i -g @uge/payo (or bun add -g @uge/payo), then just run payo.

Answer a short questionnaire about your stack, and Payo drops tailored AI
guidance files straight into your repo.

How to use — a walkthrough

1. Run Payo from your project root. npx @uge/payo — it writes into the
   current directory, so cd into the repo first.
2. Answer the questionnaire. Pick your AI tool, project type, language,
   framework, and so on. Questions adapt to your answers — choose Next.js
   and you get Next.js-specific follow-ups; choose Postgres and you're asked
   about migrations and naming. Most prompts ship a recommended default, so
   you can blast through with Enter.
3. Review your stack — and edit inline. Before writing anything, Payo shows a
   summary of every answer. Choose Edit an answer to change any response — or
   re-open a section you skipped — right from the review; dependent questions are
   re-asked automatically. Pick Generate when it looks right.
4. Payo generates the guidance. It writes each tool's files in their native
   format and location (see the table below). With the tool's CLI installed,
   files are generated in parallel by the AI; otherwise solid templates are used.
5. (Optional) Get a bootstrap prompt. Payo offers to write a paste-ready
   bootstrap-prompt.md you hand to any LLM to scaffold a runnable project that
   honors the guidance it just generated.
6. Interrupted? Just rerun. Progress lives under .payo/; Payo resumes and
   only generates what's missing.

What gets generated

Each tool gets files in its own native format and location:

Rich AI generation needs the selected tool's CLI on your PATH. Without it,
Payo writes well-structured template defaults instead.

What it asks about

Payo understands 25 frameworks, 24 ORMs, and 4 databases across
TypeScript/JavaScript, Python, Go, and Rust — and tailors its follow-up
questions to whatever you pick. Dimensions covered:

• Project — type (frontend / backend / full-stack) and a short description
• Language & framework — plus framework-specific conventions
• API — REST, GraphQL, gRPC, tRPC
• Frontend — styling and state management
• Data — database and ORM/data-layer, with naming & migration conventions
• Auth — approach, session strategy, RBAC
• Validation & logging — stack-appropriate libraries
• Testing — unit / integration / component / E2E and runners
• Tooling — package manager, runtime, formatter, linter
• TypeScript — tsconfig strictness, target, module resolution, path aliases
• Conventions — folder structure, coding standards, docs, git workflow

AI vs. template generation

Payo always leaves you with output. When the chosen assistant's headless CLI
is installed, it generates each guidance file in parallel from your answers —
richer and more specific. When the CLI is missing, or every run fails, it falls
back to static templates.

A few environment variables tune AI generation:

Your data stays yours

Payo has no backend and no telemetry. Rich generation runs entirely through the
AI CLI you already have installed (claude, cursor-agent, etc.), so your
answers go only to that tool under your own account and credentials — exactly as
if you'd prompted it yourself. Payo itself sends nothing to any server; without a
CLI present it never leaves your machine at all, falling back to local templates.

Bootstrap prompt

An empty repo with great guidance is still an empty repo. After generating, Payo
offers to write a bootstrap-prompt.md — a paste-ready prompt that tells any
LLM to scaffold a runnable project using the stack's official tooling (the
framework's own create command / CLI), honor the generated conventions, and
iterate with you until it runs.

Resume anytime

Interrupt a run and pick up where you left off. Payo saves your questionnaire
answers and generation progress under .payo/; rerun and it resumes, only
generating what's missing. Finished runs clean the directory up automatically.

Roadmap

Payo works today, but it's still early. Here's where it's headed:

• First-class existing-project support. Right now Payo shines on a fresh
  repo. The next big step is making it just as good on an established codebase:
  detect the stack from what's already there (manifests, lockfiles, config,
  folder layout), auto-answer the questionnaire from that evidence, and let
  you confirm or tweak instead of typing it all out — then the normal generation
  flow continues.
• Broader stack coverage. More languages, frameworks, ORMs, databases, and
  AI tools, plus deeper, more opinionated defaults for the ones already
  supported — so the guidance fits more of the ecosystem out of the box.
• A smoother flow. Faster, clearer prompts; better defaults and grouping;
  tighter summaries and confirmations; and a generation step that's quicker and
  more transparent about what it's doing.

Have a stack you want supported or an idea to make the flow better?
Open an issue or see
Contributing.

Requirements

To run Payo: Node.js >= 18. That's it — npx @uge/payo
runs the published, Node-targeted binary, so you do not need Bun to use Payo.
If you prefer Bun, bunx @uge/payo works too.

To develop Payo: Bun >= 1.1.0 (the project builds, tests,
and runs from source with Bun — see Run locally).

Run locally

Hacking on Payo or running it from source:

git clone https://github.com/uttam-gelot/payo.git
cd payo
bun install        # Bun >= 1.1.0
bun run dev        # runs src/index.ts directly

Other useful scripts:

bun test           # run the test suite
bun run typecheck  # tsc --noEmit
bun run lint       # eslint
bun run build      # bundle to dist/ (Node target)

Contributing

Contributions are welcome — new frameworks, ORMs, AI tools, and fixes. See
CONTRIBUTING.md for setup, the project layout, how to add
a stack module, and the pre-PR checklist.

License

MIT