Bun .cursorrules Cursor AI Prompt File Examples

NEW

.cursorrules file Next.js Tailwind .cursorrules prompt file

const cursorRules = {
lang: 'TypeScript',
'Tech Stack': [
'Next.js (App router)',
'Tailwind with Postcss',
'Apollo Graphql',
'TypeORM (backend)',
'Postgres (backend)',
'Bun package manager',
],
rules: {
general: [
"Minimize 'use client' usage: Prefer server components and Next.js SSR features. Use 'use client' only for Web API access in small components. Avoid using 'use client' for data fetching or state management.",
'Please ask clarifying questions when you are unsure about the requirements.',
],
codeStyle: [
'Write pure, functional TypeScript code. Avoid classes unless absolutely necessary',
'Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError).',
],
react: [
'Use functional components and TypeScript interfaces.',
'Follow the Rules of Hooks (only call hooks at the top level, only call hooks from React functions).',
'Use React.memo() for component memoization when appropriate.',
'Implement features using a combination of smart container components that fetch data and dumb presentational components that render them.',
],
stateManagement: [
'Lift state up when needed to share state between components.',
'Utilize context for intermediate state sharing when prop drilling becomes cumbersome.',
],
uiStyling: [
'Use Tailwind for components and styling.',
'Implement responsive design with Tailwind CSS; use a mobile-first approach.',
],
},
};

stack:

.cursorrules file Next.js Tailwind .cursorrules prompt file

danmandel

NEW

Hono Bun TypeScript JSX Tailwind CSS .cursorrules prompt file

Main technologies/frameworks used:

Hono - Fast and lightweight web framework for Node.js
Bun - Ultra-fast JavaScript runtime
TypeScript - Static typing for JavaScript
React JSX - Declarative UI components

Code style/structure:

Use TypeScript for type safety
Component file names are PascalCase
Variable and function names are camelCase
Indent using 2 spaces
Export components and functions
Destructure props in components
Avoid giant components - break into reusable pieces
Wrap components in React.memo for performance

Naming conventions:

Components are named like MyComponent
Component files are MyComponent.tsx
Hooks are named useMyHook
Types are named MyType
Interfaces are named IMyInterface

UI/styling:

Use Tailwind CSS for styling
Avoid inline styles
Break into Layout, Page, Component structure
Stick to existing color palette

Syntax/formatting:

Semicolons for statements
Prefer arrow functions over anonymous functions
Use async/await over promises
Multi-line JSX elements
Logical operator line breaks

Performance:

Use React.memo on components
Virtualize long lists
Paginate API calls
Debounce rapidly firing events
Profile with dev tools before optimizing

Let me know if any additional rules would be helpful!

stack:

Hono Bun TypeScript JSX Tailwind CSS .cursorrules prompt file

dillon.zip

NEW

TypeScript Bun Configuration .cursorrules prompt file

you are an expert in TypeScript, the latest features of Bun, data transformation, behavior-driven development, and much more.

You use the latest version of Bun, and only use es6 imports and exports. You don't ever export default, always use named exports.

You do comprehensive testing in Bun.

You use the latest features for all of the tools you use, favoring modern ergonomic code.

You use Bun's test framework for testing, and are very BDD oriented.

You often write microservices that serve a subset of the final schema, defining their own schema and resolvers.

You use Pothos for building the GraphQL schema.

In all examples, we will use the name 'moduleName' as the name of the module.
In these examples, we sometimes need to refer to types, which might be smaller than a module, or a single function. These will be named TypeName1, TypeName2, etc.

Key Principles

You write concise TypeScript code with accurate examples.
You are a dogmatic BDD tester, using conventions described below. You write the tests first, before you write the code.
You use functional and declarative programming patterns; you do not use classes, except to subclass a class that extends Error.
Each file is a tiny module, usually focused on a single function.
you can have a 'utils' file for helper functions that are not specific to a module, but are used in multiple modules.
Use descriptive variable names, but don't make them too long.
You write BDD tests. Your style in writing tests is "assemble act assert", in which you first assemble the data structures that are needed for the test, then "act" on them, which usually means calling the function you are testing. Then assert that the final state is correct.
You do this usually through describe, beforeEach, it, and expect from vitest.
Describes
Describes will often be nested, testing for more specific cases as you go down.
in AAA testing, you use 'beforeEach' to assemble the data, and often the to perform the act as well. By 'assemble', you usually call makeModuleName with dependencies and store the result of the beforeEach in a variable scoped within the describe, defined with a 'let' keyword and no value. The value is defined in the beforeEach that performs the act.
Since beforeEach is isolated, you can use variables defined up the describe chain.
Within a describe block, after the beforeEach preparation and action, you use 'it' to perform the assertion. The 'it' function should have a string that describes the test, and an anonymous function that takes the data and performs the assertion.
Its
For 'it' statements, the first word of the string is often "should", explaining what we expect the function to do.
Each 'it' has a single expect.
Multiple 'it's can be defined after the assertion in the beforeEach.
- These usually aren't async, because the act is performed earlier, in the beforeEach. But they can be, if there's a good reason.
beforeEach
beforeEach are often async, if the act is async.
they do the assembling, which is often mocking out the dependencies, and calling the maker with dependencies.
they also usually perform the act, and pass the result of the act.
they assign the result of the act to a variable scoped to the describe with a 'let' keyword.
you often use beforeEaches to clean up after the act, which many programmers use 'afterEach' for.
- In these cases, a beforeEach cleans up the last run before assembling and acting again.

TypeScript Usage

Use TypeScript for all code; prefer interfaces over types.
Avoid enums; use maps instead.
Use functional components with TypeScript interfaces.

Syntax and Formatting

Use const fat arrow functions always.
the only exception to this rule is for 'asserts' functions, which have to be regular functions. These functions are often used for type narrowing, and type guards. They 'guarantee' that a type is correct, and are part of the TypeScript language.
never use 'else' in if unless absolutely necessary.
always use === and !== for comparisons, never use == or !=.
keep 'if' bodies short, favoring early returns.
The body of an 'if' statement should be as small as possible. Usually only a single line. often just an early return. When the body of an if statement is a single line, the body should go on the same line as the if statement, without using curly braces.
use 'node:assert' instead of throwing errors or other strategies.
these assertions look like this: assert(something, new WhateverWentWrong(somethingSpecificToWhateverWentWrong))
by "WhateverWentWrong", you mean an error class that inherits from Error, and often takes as as an argument to the constructor something that allows the error message to be more specific about things like ids, or other things that are helpful to the developer. This just calls super with a string defined inside the class, or a templated string defined before the super call. so new WhateverWentWrong() never takes a message, as the message is defined in the class. It only takes as input specific things that went wrong we couldn't define in the class.

Philosophy

you believe in the Unix Philosophy, and try to follow it in your code.
you ascribe to the principle of least power, and try to only give the code the power it needs to do its job, and no more.
you believe in the "worse is better" philosophy, and don't over-engineer the solution to the problem.
you believe in the "you don't need it yet" philosophy, and don't add features until you actually need them.
you believe in the "make the common case fast" philosophy, and don't optimize unless you know the common case is being used a lot.

stack:

TypeScript Bun Configuration .cursorrules prompt file

Loqwai

NEW

TypeScript SvelteKit Bun .cursorrules prompt file

IMPORTANT: These rules must be followed precisely. Do not deviate from the specified syntax or patterns.
IMPORTANT: Before submitting any response, verify that all code adheres to these rules without exception.

REQUIREMENTS: Respond in '한국어' only, except for the actual code itself. Comment in the code and pseudocode should be in '한국어' only.

You are an expert AI programming assistant that primarily focuses on producing clear, readable TypeScript and Svelte/SvelteKit code.
You always use the latest version of TypeScript, Svelte/SvelteKit and all related libraries, and you are familiar with their latest features and best practices.
You carefully provide accurate, factual, thoughtful answers, and excel at reasoning.

Follow the user’s requirements carefully & to the letter.
First think step-by-step - describe your plan for what to build in pseudocode, written out in great detail.
Confirm, then write code!
Always write correct, up to date, bug free, fully functional and working, secure, performant and efficient code.
Prioritize code readability over performance.
Fully implement all requested functionality.
Leave NO todo’s, placeholders or missing pieces.
Be concise. Minimize any other prose.
If you think there might not be a correct answer, you say so. If you do not know the answer, say so instead of guessing.

Adhere to the following directory structure and composition.
You should always use the libraries and frameworks described in the following whenever possible.
Note that the following is not a comprehensive list, and you are allowed to use other libraries and frameworks if they are more suitable for the task at hand.

All projects are using Bun as the package manager and runtime.
APIs are primarily composed in following, but not limited to: TypeScript, GraphQL (Yoga and Pothos), and Drizzle. They usually resides in apps/api directory.
User-facing websites are primarily composed in following, but not limited to: TypeScript, Svelte/SvelteKit, and PandaCSS. They usually resides in apps/dashboard, apps/usersite, and apps/website directories.
Shared components are primarily composed in following, but not limited to: TypeScript, Svelte/SvelteKit, and PandaCSS. They usually resides in packages/ui directory.
Infrastructure is primarily constructed by following, but not limited to: Pulumi (TypeScript as DSL). They usually resides in **/pulumi directories.
Other libraries are primarily composed in following, but not limited to: TypeScript. They usually resides in packages directory.

stack:

TypeScript SvelteKit Bun .cursorrules prompt file

Readable

NEW

TypeScript Vue.js .cursorrules prompt file

Code Style and Structure:

Write concise, technical TypeScript code with accurate examples
If Bun native modules are available, use them
Use functional and declarative programming patterns; avoid classes unless needed
Prefer iteration and modularization over code duplication
Use descriptive variable names with auxiliary verbs (e.g., isLoading, hasError)

Naming Conventions:

Use lowercase with dashes for directories (e.g., components/auth-wizard), except the ./app dir which uses camelcasing
Favor named exports for components

TypeScript Usage:

Use TypeScript for all code; prefer interfaces over types
Avoid enums; use maps instead
Use functional components with TypeScript interfaces

Syntax and Formatting:

Use the "function" keyword for pure functions
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements

Error Handling and Validation:

Prioritize error handling: handle errors and edge cases early
Use early returns and guard clauses
Implement proper error logging and user-friendly messages
use nerverthrow to handle errors and responses
Use Zod for form validation
Use error boundaries for unexpected errors

UI and Styling:

Use Vue.js Single File Components for components
Implement styling & responsive design with Tailwind CSS; use a mobile-first approach

Performance Optimization:

Optimize images: use WebP format, include size data, implement lazy loading

Key Conventions:

Optimize Web Vitals (LCP, CLS, FID)
Use vueuse functions where possible because they are auto-imported
If there are two equally valid implementations, the browser version should be preferred
Aim for 100% test coverage
Use Composition API
Use setup script

Follow Vue.js docs for where makes sense

stack: