#cursor rules
6 prompts found
Cursor Rules for Python: .mdc Rule Set From Your Repo Facts
Generate Cursor project rules for a Python repo: .mdc files with globs for source, tests, and migrations, built from your real tooling, layout, and commands.
Act as a Python tech lead who writes Cursor project rules for a team repo: short .mdc files in .cursor/rules/ that tell Cursor's Agent how this codebase is built, tested, and typed, using only facts from the repo. Inputs: - Python version, package manager, formatter, linter, and type checker as configured: [PythonToolchain] - Top-level folders and what lives in each: [RepoLayout] - Framework and the patterns the code follows (for example FastAPI routers, Django apps, plain scripts): [FrameworkPatterns] - Test runner, test folder, fixtures, and how external services are faked: [TestSetup] - Commands that exist in this repo, copied from the Makefile, pyproject scripts, or CI: [RealCommands] - Things the Agent must never do here: [NeverDo] - Mistakes the Agent has already made in this repo: [AgentMistakes] Generate: 1. A file plan: each .mdc file name, its rule type (Always Apply, Apply to Specific Files, Apply Intelligently, or Apply Manually), and why. 2. python-core.mdc: frontmatter with globs for source files and alwaysApply false, then rules for typing, imports, error handling, logging, and style that match PythonToolchain (point to the formatter instead of restating style). 3. tests.mdc: globs for the test folder only; how to write and name tests, use fixtures, and fake services per TestSetup. 4. One more file for the riskiest area in RepoLayout (for example migrations or the API layer), with a description so the Agent can pull it in when relevant. 5. A short always-apply file with the RealCommands and the NeverDo list. 6. A check list: every command, path, and tool named in the rules, each traced to an input, so nothing was invented. 7. Two test prompts to paste into Agent to confirm the rules load and change its behavior. Rules: - Name only tools, paths, and commands that appear in the inputs. - Keep each file under 60 lines; the whole set well under 500 lines. - Each line in AgentMistakes becomes one direct rule.
Cursor Rules for React: .mdc Rule Set From Your Own Repo
Generate Cursor rules for a React app from your real package.json and folders: scoped .mdc files for components, data fetching, forms, styling, and tests.
Act as a senior React and TypeScript engineer who writes Cursor project rules (.mdc files in .cursor/rules) for React codebases, so Cursor's Agent follows this repo's real patterns instead of generic React habits. Inputs: - package.json dependencies and scripts, pasted as is: [PackageJson] - Folder structure of src/ two levels deep: [FolderTree] - tsconfig.json strictness settings and the lint config in use: [TsconfigAndLint] - Styling approach and state or data fetching libraries actually used: [StylingAndState] - Test runner, test library, and where tests live: [TestingSetup] - Team conventions that are not written down yet: [TeamConventions] - Mistakes the agent keeps making in this repo: [AgentMistakes] Generate: 1. Evidence check: every library, script, and folder you will mention in the rules, with where it came from (PackageJson, FolderTree, TsconfigAndLint, or my notes). Anything you cannot find stays out of the rules. 2. A rule plan table of 4 to 6 .mdc files: file name, Cursor rule type (Always Apply, Apply to Specific Files, Apply Intelligently, or Apply Manually), the globs or description that trigger it, and a one line purpose. Keep only one Always Apply rule. 3. The Always Apply core rule, under 30 lines: what the app is, the folder map from FolderTree, and the exact scripts from PackageJson to run after edits (lint, type check, tests). 4. A components rule scoped with globs to the component folders: export style, props typing, file naming, and where logic goes, from TeamConventions. 5. A data fetching and state rule for the exact libraries in StylingAndState: where queries or stores live, loading and error states, and what never goes in a component. 6. A testing rule scoped to test files using TestingSetup: query style, what to mock, and the command to run one file. 7. An Apply Intelligently rule (description only) for one task that comes up often in TeamConventions or AgentMistakes. 8. Each item in AgentMistakes as a short do and do not pair, placed in the rule where it belongs. 9. Full contents of every .mdc file with front matter (description, globs, alwaysApply), ready to save. Constraints: - Mention only packages present in PackageJson and paths present in FolderTree. - Short, specific rules; no generic React tutorials and no style guide the linter already enforces. - Do not change the React version or suggest new libraries.
Cursor Rules for Java Spring Boot: .mdc Rule Set Generator
Generate Cursor .mdc rules for a Java Spring Boot repo from your build file and conventions: layering, JPA, tests, security, and what the agent must not touch.
Act as a senior Java Spring Boot engineer who maintains Cursor project rules (.cursor/rules/*.mdc files) so the Cursor agent writes code that matches an existing codebase instead of generic tutorial Spring. Inputs: - My build file (pom.xml or build.gradle), pasted: [BuildFile] - Java version and Spring Boot version from that file, or "read it from BuildFile": [Versions] - Package layout and layering, for example controller, service, repository, domain, dto: [PackageLayout] - Persistence choices: JPA or JDBC, database, migration tool (Flyway or Liquibase), naming rules: [Persistence] - Testing stack and conventions: JUnit 5, Mockito, Testcontainers, slice tests, naming: [TestingRules] - Things the agent must never change or add (dependencies, generated code, secrets, config files): [NoTouch] - Output format: [Format] Generate: 1. A short read of BuildFile: the Java and Spring Boot versions, the starters in use, and anything that changes how code should be written (for example jakarta vs javax imports, Lombok present or not, WebFlux vs MVC). Only report what is actually in BuildFile. 2. A rule file plan: 4 to 6 .mdc files, each with a filename, one line purpose, and whether it is always applied or attached by globs. 3. The full text of each .mdc file with frontmatter (description, globs, alwaysApply) and a body of short, testable rules. Suggested split: a. spring-core.mdc (alwaysApply): versions, constructor injection only, no field injection, configuration via @ConfigurationProperties, logging style. b. web-layer.mdc (globs on controller packages): request and response DTOs, validation annotations, error handling through the existing exception handler, status codes. c. persistence.mdc (globs on repository and entity packages): entity rules from Persistence, transaction boundaries in services, migrations through the named tool only, no schema auto update. d. testing.mdc (globs on src/test): which test type to write for which layer, from TestingRules, naming pattern, no real network calls. e. guardrails.mdc (alwaysApply): NoTouch items, ask before adding a dependency, never commit secrets, keep changes small. 4. For each rule file, two "bad vs good" Java snippets of three to eight lines showing the rule in this codebase's style. 5. A conflict check: rules that contradict each other or contradict BuildFile, with a suggested fix. 6. A test plan for the rules: three small tasks to give the Cursor agent and what correct output should look like. Constraints: - Do not invent libraries, starters, or plugins that are not in BuildFile. If a rule depends on something missing, say "add only if the team agrees". - Keep each rule one line and checkable. No essays inside .mdc files. - Do not claim Cursor features beyond rule files with description, globs, and alwaysApply frontmatter.
Cursor Rules for Flutter: Project .mdc Rule Set Generator
Generate Cursor rules for a Flutter app from your real pubspec and folder layout: scoped .mdc files for widgets, state, routing, tests, and generated code.
Act as a senior Flutter engineer who writes Cursor project rules (.mdc files in .cursor/rules) for Flutter and Dart codebases, so the Cursor agent follows the team's real architecture instead of generic Flutter habits. Inputs: - pubspec.yaml dependencies and dev_dependencies, pasted as is: [Pubspec] - analysis_options.yaml, pasted as is: [AnalysisOptions] - Folder structure of lib/ and test/ two levels deep: [FolderTree] - State management, routing, and data layer the app actually uses (for example Riverpod, Bloc, Provider; go_router; Dio, http, Drift): [ArchitectureChoices] - Code generation in use (freezed, json_serializable, build_runner) and which files are generated: [Codegen] - Team conventions that are not written down anywhere yet: [Conventions] - Things the agent keeps getting wrong in this repo: [AgentMistakes] - Output format: [Format] Generate: 1. An evidence check: list every package and convention you will reference and where it came from (Pubspec, AnalysisOptions, FolderTree, or my notes). Anything not found is left out of the rules, not guessed. 2. A rule plan: a table of 5 to 7 .mdc files with file name, rule type (always apply, auto attached by globs, agent requested by description, or manual), globs, and a one line purpose. 3. The always apply core rule (under 40 lines): project summary, folder map from FolderTree, the commands to run after edits (flutter analyze, dart format, flutter test) and the build_runner command if Codegen uses it. 4. A widgets rule scoped to the UI folders: composition over deep widget trees, const constructors where possible, no business logic in build methods, and context use after await only behind a mounted check. 5. A state management rule written for the exact library in ArchitectureChoices, with the file naming and provider or bloc placement used in FolderTree. 6. A routing and navigation rule for the routing package in Pubspec, or skip it if there is none. 7. A data and models rule that covers Codegen: never hand edit generated files, regenerate after model changes, and where models and repositories live. 8. A testing rule scoped to test/: where tests go, naming, which test types the repo uses, and what to mock. 9. A rule for AgentMistakes: each mistake turned into a short do and do not pair. 10. Full .mdc file contents for every rule with front matter (description, globs, alwaysApply), ready to save. Constraints: - Only reference packages present in Pubspec and lints present in AnalysisOptions. - Keep each rule short and specific; no generic Dart style guide filler. - Do not invent folder paths; use FolderTree exactly. - No em dashes.
Cursor Rules File from Repo Conventions (No Invented Paths) (Domain Pack)
Draft a Cursor rules file from repo conventions. No invented paths or tool claims.
Act as a Cursor rules librarian who only uses locked repo conventions. You draft a Cursor rules file the conventions already support. You do not invent filesystem paths, tool claims, or commands not in Inputs. You work only from Inputs. Do not invent stats, citations, quotes, URLs, names, IDs, or records that are not in Inputs. Inputs: - Repo conventions I lock (dirs, style, review rules): [Conventions] - Paths allowlist I lock: [Paths] - Commands allowlist I lock (or NONE): [Commands] - Stack I lock: [Stack] - Cursor rules filename I may quote (or UNKNOWN): [RulesFile] - Section cap I lock: [Cap] - Words I must not use: [Banned] - What I must never invent (paths, commands, tools, secrets): [Never] - Output format: [Format] - Language: [Lang] Generate: 1. Honesty ledger: Conventions nouns, Paths, Commands, Stack, RulesFile, Cap, Lang. Forbidden: invented paths, commands, tools, secrets. 2. Rules outline: at most Cap sections grounded in Conventions. 3. Path and command tables: only Paths and Commands rows. Missing write NOT IN INPUTS. 4. Cursor rules body: paste-ready rules scoped to Paths; RulesFile UNKNOWN stays unknown. 5. Refuse list: inventing rule file paths not listed, inventing scripts not in Commands, inventing undeclared dirs. 6. Compliance pass: quote Banned and Never hits. Cut them. Print counts. Format as Format. Constraints: - Rules from Conventions only. No invented paths. - Honor Cap. No emojis.
Cursor Rules (.cursorrules) from a Repo Brief (Never-List, No Invented Paths)
Draft .cursorrules from a repo brief with a never-list. No invented file paths, commands, or secrets.
Act as an editor for this job: Cursor Rules (.cursorrules) from a Repo Brief (Never-List, No Invented Paths). Goal: Draft .cursorrules from a repo brief with a never-list. No invented file paths, commands, or secrets. You work only from Inputs. Do not invent stats, citations, quotes, URLs, names, IDs, or records that are not in Inputs. Inputs: - Source packet I lock: [Source] - Cap I lock: [Cap] - Words I must not use: [Banned] - What I must never invent: [Never] - Output format: [Format] - Language: [Lang] - Escalation or UNKNOWN field: [Extra] Generate: 1. Honesty ledger: Source nouns, Cap, Extra, Lang. Forbidden items from Never. Add any required not-advice banner for the domain. 2. Main draft: deliver the titled job using Source only. Honor Cap. 3. Allowlist or checklist of items present in Source; missing items NOT IN INPUTS. 4. Escalation/gaps: quote Extra or UNKNOWN; list five owed fields. 5. Refuse list: inventing identifiers, inventing fees, inventing stats, inventing paths, exceeding Cap. 6. Compliance pass: quote Banned and Never hits. Cut them. Print counts. Format as Format. Constraints: - Stay inside the job boundary of Cursor Rules (.cursorrules) from a Repo Brief (Never-List, No Invented Paths). - No invented evidence. Honor Cap. No emojis.