Step 0/15 · 0%
Interactive guide · 5 minutes · works for Cursor, Claude Code, ChatGPT, Claude, Gemini and Grok

Rules generator: Set up AI your way.

Answer 15 short questions (just click) and you get finished rules: User Rules for Cursor, CLAUDE.md for Claude Code, rules for your project (AGENTS.md and core-rules.mdc), plus versions for ChatGPT, Claude, Gemini and Grok — the same rules you use everywhere. No sign-up, nothing is sent out, everything stays in your browser.

⚡ Quick start

Pick what describes you best. The form fills in with sensible choices, and you then just fine-tune what you want differently. Your name, language, system and own rules stay.

👥 Your personas

You can save several setups and switch between them any time. For example: “work”, “weekend / play”, “learning”, “creating and editing images” 🎨, “song lyrics” 🎵, “cookbook / recipes” 🍳, “letters and emails” ✉, “brainstorm” 💡. Each persona has its own style, language, length and rules. Personas are saved only in this browser. With a backup file you can move them to another computer.

No persona yet — fill in the form and click “Save as persona”.

1 What should I call you?

A short form of address at the start of answers noticeably changes the personal touch.

Optional. You can write several separated by commas — the AI will rotate them by mood.
Casual or formal?
You can fine-tune how colloquial and slangy it is in step 9 (“How the AI should come across” → Language register). 🤬 Crude = the AI may swear; 😤 blunt = tough but clean language, no fluff.
A greeting at the start of the answer
The greeting goes only into the first answer of a new conversation, not into every message.

2 Language of communication

Technical terms like “pull request” or “bundle” usually aren't translated — the AI handles that.

3 Who are you? (you can pick several roles)

Feel free to pick several options — for example “fullstack + musician” or “beginner + PM”. The AI takes them all into account.

4 Your level

The AI uses it to decide how much to explain and which abbreviations to use.

Where you are now

5 Operating system and terminalTerminalA program where you type text commands to the computer (instead of clicking with the mouse). Each system has a different one — Windows PowerShell, macOS zsh, Linux bash.

Different systems have different command syntax. For example, deleting a file: PowerShell `Remove-Item`, bash `rm`. So the AI doesn't send you things that don't work for you.

6 What you work with (stackStackThe set of tools and libraries you use together in a project. Example: React + TypeScript + Tailwind = a frontend stack.)

Pick everything you use. It's fine to tick nothing — then the AI won't assume anything. Hover / click on a name — many have an explanation. At the top is a simple menu for non-coders, below are the technical options.

🌱 Simple — for laypeople and beginners
⚙ Technical stack — for developers

7 What do you want to do with AI?

Feel free to pick several things — the AI uses them to know what interests you and what doesn't.

8 How should the AI talk to you?

This is maybe the most important setting — it affects every answer. Start with the main style, then fine-tune the working pace.

The main answer style
The working pace — how should it cooperate?
Smart (Pumpy style) 👈 recommended — the AI does small things (typos, 1 line) straight away, suggests bigger things (a refactor, several files) and waits for approval, and offers an A/B/C/D choice at a crossroads. The most balanced workflow.
Together — the AI makes sure before coding (good for beginners and bigger changes).
Plan + questions — best for projects where you don't want surprises.
Direct — for familiar tasks, saves time.
Options — when you're deciding and want to compare variants.

9 How the AI should come across

Settings for the AI itself — how it talks about itself, how relaxed it is and whether it should remember you.

How the AI refers to itself (what does this mean?)The AI's self-referenceWhether the AI talks about itself as “he”, “she”, “it” or “we”. In languages like Czech it even changes the verb endings; in English it shows in how the AI describes itself.
Language register / slang
Humour
Should the AI remember you from previous conversations?
Cursor has no long-term memory of its own. This rule tells the AI to remember your preferences during one conversation and, over time, to add notes to this document (when you ask it to).
Creativity level — how much may it “make things up”?
Recommendation: Strict for production code / payments. Balanced+ mentor 👈 for beginners and the experienced alike — the AI checks whether there's a better way and suggests it before implementing. Balanced when you want peace and fewer suggestions. Creative/Wild for UI ideas, copywriting, brainstorming, generating images.

10 Answer length

The AI will stick to this rule until you move it elsewhere with a prompt like “answer in detail / more briefly”.

🧭 Adaptive (Pumpy style) 👈 recommended — short and to the point for small things, more detail with context, headings and bullet points for complex things. A short plan before a bigger action, a short summary after it. The answer grows with the size of the problem, not out of habit.
📋 Structured — similar, but the AI always returns headings+bullet points+tables, even when you ask something simple. Good for documentation and reports.

11 How it should show code

It reduces clutter in the chat, especially with long files.

12 What the Agent may do automatically

Tick only what you're really at ease with. For everything else the Agent will ask. Unticked = safer. The first two items (🛟 safety net) are ticked by default — they help the AI remember its steps and go back safely. Terms next to the names (dotted underline) have explanations — hover / click.

🧱 A rule isn't a lock. These choices are written into the text of the rules, and the AI usually follows them. Real certainty only comes from the permission settings in Cursor or Claude Code and a hook that stops a dangerous command. You'll find both on the Guardrails and safety page.

13 Do you work with GitGitThe timeline of your code — it saves every change and lets you go back at any time, branch off experiments and compare versions. It works purely locally too; it needs no server or account. GitHub/GitLab is just an optional store on the internet for backup and sharing.?

If so, the Agent will follow a commitCommitA “photo” of the state of the code + a short message about what changed. Local — until it's pushed, nobody else sees it. style (small logical steps, sensible messages). If not, it won't talk about Git.

💡 Local git is a great choice; you don't have to push anywhere. Just git init in the project folder and you have the history on your disk — the AI can commit after every logical step, and when something breaks you go back with one command. No GitHub, no cloud, no account. Pushing to GitHub only makes sense when you want a backup off your computer, collaboration or to publish the code.

14 Do you want the Agent to write tests?

“Red-Green-Refactor” pays off with AI — when something breaks, the tests catch the regressionRegressionA situation where a new change breaks something that worked before. Tests catch a regression before the user notices it..

💸 Cost vs. benefit: Tests = more tokens right away (the AI has to write the test + the code + run it + fix it, easily 2× as much as without tests). But far fewer bugs later — the AI catches the bug in the test itself, fixes it straight away, and you don't have to hunt it down in production.

Recommendations by situation:
• Always — a production SaaS where reliability matters.
• Only for bugs 👈 the best cost/performance ratio for most people.
• Only when I say so — prototypes, MVPs, playing around.
• We don't write them — one-off scripts, static websites, learning.

15 Anything extra (optional)

Your own rules for the AI to follow. Write one sentence per line.

Don't know what to put here? Leave it empty. You can come back any time later right in Cursor (Customize → Rules).
📖 Glossary — everything AI/Git/web jargon can mean

Here you'll find quick explanations of the most common technical terms. The terms in the guide above also have tooltips — hover / click the word with the dotted underline.

Terminal
A window where you type text commands. Instead of clicking with the mouse.
PowerShell
The default terminal in Windows. A blue window with `PS C:\>`.
WSL
Linux inside Windows. Useful for web/server development.
bash / zsh
Terminals on Linux / macOS.
shell
A synonym for “terminal interpreter” — bash is a shell.
npm / pnpm / yarn
A package manager for JavaScript/TypeScript.
package
An external library you add with the command `npm install`.
build
Turning source code into its finished form (TS→JS, minification).
dev / dev server
A local development mode. It runs on your `localhost:3000`.
production
The live version users see. The opposite of dev/staging.
staging
A test environment between dev and production.
deploy
Putting an app on the internet.
Git
A versioning system — the history of code changes, going back, collaboration.
repository (repo)
A project folder tracked by Git. Typically on GitHub.
commit
A “photo” of the state of the code + a description of the change. Local.
push
Sending commits to GitHub.
pull
Downloading changes from GitHub to you.
branch
A parallel line of development (main, feat/xxx, fix/yyy).
main / master
The main branch — what runs in production.
merge
Merging one branch into another.
rebase
Rewriting history so your commits are “on top” of main.
PR (Pull Request)
A request to merge a branch into main; it goes through review.
diff
A view of only the changed lines (+/-).
regression
When a new change breaks something that worked before.
unit test
A test of a small isolated unit of code (one function).
integration test
A test of several parts together (UI + API + DB).
e2e test
End-to-end. A test of the user's whole journey through the app.
API
An interface for communication between apps (typically HTTP/JSON).
endpoint
A specific API URL (e.g. `GET /api/users/42`).
backend
The “server” part of an app — data, logic, authorisation.
frontend
The “visual” part — what the user sees and clicks.
fullstack
A developer who does both.
SaaS
Software as a Service — a monthly subscription to an app in the cloud.
landing page
A one-page website with a single goal (sign-up, sale).
dashboard
An overview screen with charts, tables, KPIs.
CMS
Content Management System — an admin for editing content (WordPress).
stack
The set of technologies you use together.
framework
A skeleton for apps (Next, Nuxt, Express, Django…).
library
A piece of code you add and call (axios, lodash).
component
A reusable piece of UI (Button, Card, Modal).
JSX / TSX
React's syntax — HTML inside JavaScript/TypeScript.
TypeScript
JavaScript + static types. Fewer runtime errors.
Node.js
An environment for running JS outside the browser (servers, CLIs).
Cloudflare Workers
Serverless JS/TS running “at the edge” of Cloudflare's network.
SQL / NoSQL
Table vs. document databases (Postgres vs. Mongo).
Docker
An app packaged together with its environment into a “container”.
secret / token
A sensitive key (for an API, a DB, OAuth). Never into Git.
.env
A file with secrets in the project root. In `.gitignore`.
.gitignore
A list of files Git ignores (node_modules, .env…).
linter
A tool that checks code style (ESLint, Ruff).
formatter
A tool that formats code automatically (Prettier, Black).
refactor
Rewriting code without changing behaviour — for better readability.
MVP
Minimum Viable Product — the smallest working version.
UX / UI
UX = how it's used. UI = how it looks.
responsive
A website that adapts to a phone and a monitor alike.
SSR / CSR / SSG
Rendering: on the server / in the browser / in advance.
cache
A cache. Faster access to what's already been computed.
AGENTS.md
A file in the project root that the AI reads — the rules for the project.
User Rules
Your global rules in Cursor (Customize → Rules) — for all projects.
Plan mode
In Cursor: the AI only plans, it doesn't change files. Safe for beginners.
Agent mode
In Cursor: the AI may change files and run commands.

🎉 Done — your personal AI setup

The guide is primarily for Cursor, but the same rules can be carried over to Claude Code, ChatGPT, Claude, Gemini and Grok too. You'll find the exact steps in the “Claude Code”, “Other AIs” and “What now” tabs.

Where to save rules in Cursor — and what survives a long chat:
🎯 Cursor (the recommended combination)
WhereScopeSurvives auto-summary?What for
User Rules
Customize → Rules		 Global (all projects) ✅ Yes Personal style, language, general prohibitions
.cursor/rules/core-rules.mdc
alwaysApply: true		 Per project ✅ Yes — the most reliable Critical project rules (prohibitions that must not drop out, conventions)
AGENTS.md
in the project root		 Per project ✅ Yes — Cursor treats it as the project rules Project details (stack, structure, commands). A simpler replacement for .cursor/rules, no settings
Chat instructions
Written in a message		 This chat only ⚠ They can get lost when a long chat is summarised One-off instructions, “this time differently”

Recommendation for Cursor: User Rules keep your style across all projects. In a project, an AGENTS.md with “where things are” is enough. Add core-rules.mdc when you want to control which rule applies when.

⌨️ Claude Code
WhereScopeWhat for
~/.claude/CLAUDE.md
in your user folder		 Global (all projects) The same text as User Rules: your style, language and boundaries
CLAUDE.md
in the project root		 Per project, goes into git The line @AGENTS.md and below it only what applies just to Claude Code

Keep the project description in a single AGENTS.md. Both Cursor and Claude Code read it, so two versions of the rules won't drift apart. More on the Rules for the agent page.

🌐 Other AIs — where to save the same rules
PlatformWhere to pasteScopeSurvives the conversation?
💬ChatGPT
OpenAI		 Settings → Personalization → Custom Instructions
or Projects → project instructions (per project)		 Global per profile / per project ✅ Yes — in every new chat
🟠Claude
Anthropic		 Settings → Your Claude → Instructions
or Projects → Project instructions (per project, paid plans)		 Global per profile / per project ✅ Yes
🔷Gemini
Google		 Settings & help → Personal context → Your instructions for Gemini
or Gems → New Gem (per persona, skills from November 2026)		 Global per profile / per Gem ✅ Yes ⚠ a smaller limit
⚫Grok
xAI		 Settings → Personalization → Custom Instructions
or Projects → Instructions (per project)		 Global per profile / per project ✅ Yes
📄API / your own UI
OpenAI API, Anthropic API, local LLMs…		 A system prompt (role: "system") at the start of every conversation Per session (you send it) ✅ Yes — as long as you send it in every request
📋Anywhere else
Perplexity, DeepSeek, a local Llama…		 Either a system prompt, or the first message of the conversation as a persona Per session / per chat ⚠ Depends on the platform

Tip: the same text, just a different field in each AI. The output in the “🌐 Other AIs” tab below is already prepared for ChatGPT / Claude / Gemini / Grok / universally — just pick the platform and copy.

📋 User Rules

Paste into Cursor: in the side panel, Customize → Rules → User Rules → empty the field → paste and save. This is a global setting — it applies to all your projects.


        


        

          

            🔒 The most reliable way. This file has alwaysApply: true in the header — Cursor mixes it into every prompt, so it even survives the summary of long chats. Use it for rules that must not “go away” in the project (prohibitions, Git, tests, project conventions).
          

          
🔒 .cursor/rules/core-rules.mdc

          

            Create the file .cursor/rules/core-rules.mdc in the project root and paste this in (the whole thing, including the YAML header at the top). After saving, Cursor automatically follows the rules in later chats, even when a chat lasts for hours.
          

          

          

            The difference from User Rules: User Rules are global (for all projects), core-rules.mdc is per project and goes into git. That's why it holds only the part for working in the project (permissions, Git, tests, your own rules). The communication style stays in User Rules, so the AI doesn't get it twice. Feel free to adjust the rules for the project, for example when the agent may do more or less here than elsewhere.
          

          

            For a beginner: If you don't have a project yet, skip this tab — User Rules alone are enough.
          

        


        

          

            👀 Don't skip this one. This is the second half of the setup! User Rules (the first tab) tell the AI how to talk to you. AGENTS.md tells it what your project is — without it, the AI will grope around in every repo. Cursor loads it by itself when it's in the project root. Once per project is enough; you fill in a few lines, and every later chat starts with the full context.
          

          
📁 AGENTS.md — for the project root

          
Create an AGENTS.md file in the project root (it complements User Rules for a specific repo). Or skip it if you're not working on a project yet.

          

          

            Tip: If you have several projects, put an AGENTS.md into each one separately and adjust the specifics (stack, deploy, domain). User Rules stay global.
          

        


        

          
⌨️ Claude Code

          
Claude Code reads rules from CLAUDE.md files. It works the same in the terminal, in VS Code and in the app. The Rules for the agent page describes it in detail.

          
1. Your rules for all projects

          
Save it as ~/.claude/CLAUDE.md, on Windows C:\Users\<your name>\.claude\CLAUDE.md. It's the same text as the User Rules for Cursor, just with a different heading.

          

          
2. Project rules

          
Save it as CLAUDE.md in the project root, next to the AGENTS.md from the “AGENTS.md” tab. The first line @AGENTS.md loads it, so you don't have to write the project rules twice.

          

          

            Check it: in Claude Code, run /context and see whether both files are under Memory files. /memory shows all the files with rules.
          

          

            Without CLAUDE.md: when you don't have a CLAUDE.md in the project, Claude Code from version 2.1.277 loads AGENTS.md by itself. What Claude Code may do without asking, you set in .claude/settings.json, not in the text of the rules. How to do it is on the Guardrails and safety page.
          

        


        

          
🌐 Your rules in other AIs

          

            The same rules you've just fine-tuned for Cursor can be poured into ChatGPT, Claude, Gemini or Grok too — they'll always “talk the same way” to you across platforms. Each one has a different place to put them:
          

          

            📝 How it differs from the Cursor version: Web AIs (ChatGPT, Claude, Gemini, Grok…) have no access to your computer — they don't run the terminal, don't work with Git, can't delete files, don't deploy. That's why this tab leaves out: OS / shell, Git, agent permissions (deploy, commit, push…), the test runner, diff vs. whole files. What stays is the communication style, how it should answer you, the AI persona, your level, goals and your own rules.
          

          

            
            
            
            
            
          


          

          
          

            
            

          

          

          

            Note: each AI has slightly different memory and length limits. If the output gets cut off somewhere, turn on the shorter version above the text or shorten your own rules. Cursor takes the longest, ChatGPT has a 5,000-character limit on paid plans, Grok around 8,000, Claude and Gemini handle even more.
          

        


        

          
🚀 Steps to finish

          
All done in ~3 minutes. Do it in this order:

          
    
          
    
            Success = a test: open the chat (Ctrl+L), write “briefly describe the structure of this project”. The answer should come in your style (form of address, length, language). If it doesn't, adjust User Rules.