Browse

Web Accessibility .cursorrules strategies

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

Shadcn UI

JavaScript

Python

Radix UI

Next.js

Vite

JSX

WebP

Zod

Docker

Next.js App Router

Supabase

CSS

PostgreSQL

Redis

FastAPI

HTML

Pydantic

pytest

Git

Jest

react-hook-form

Solidity

Vercel

SQLAlchemy

Tailwind Aria

Suspense

SvelteKit

Vue.js

GitHub Actions

Celery

ESLint

PHP

TailwindCSS

Pinia

PEP 8

asyncpg

TypeScript

SQL

Playwright

Svelte

Prettier

Radix

DaisyUI

Vitest

JSDoc

JSON

ARIA

Drizzle ORM

Vue Router

VueUse

Astro

Svelte 5

tRPC

Expo

CORS

aiomysql

GitLab CI

Django

Typescript

scikit-learn

pandas

GitHub

RabbitMQ

Java

WebP.

tanStackQuery

Phoenix LiveView

Ecto

File System Watcher

Plug

Finch

Gettext

Phoenix

Elixir

Jason

Phoenix LiveDashboard

Sobelow

ExCoveralls

DNS Cluster

ExUnit

Release Please

Swoosh

Credo

LeftHook

ES6

npm

Laravel

styled-components

RESTful API

Shadcn

Markdown

OpenZeppelin

Slither

Hardhat

Mythril

Clear

AI Development

Turn-Based Strategy

Virtual World

Application Structure

iOS Development

Mobile App Design

$derived

$props

Snippets

HTML

$host

$bindable

Svelte 5

$effect

`createRawSnippet`

$state

$inspect

Nintendo Ringcon

Unity

Exercise-Based Games

Tower Defense

Clear readable code

Typescript

NextJS

Coding assistant

VSCode

Testing and documentation

Java coding best practices

Code review practices

AI assistant behavior

Security practices

WordPress Plugin

Software Configuration

Draft Management

System Tray App

Localization

Event-Driven Development

Authentication and Authorization

Modern PHP Practices

Scheduling Systems

MVC Architecture

Security Measures

Asset Compilation

Data Integrity

Software Setup

Fullstack Development

Senior Developer

Environment Variables

ES6 Syntax

Custom Utilities

Modern Development Practices

Programming Assistant

Svelte/SvelteKit

Coding style

Object-oriented programming

Testing guidelines

Mock data generation

Rich-text editor

Open-source

TypeScript path aliases

Local Environment Development

Modular Library Development

Player Feedback

Dungeons and Dragons

NPC Management

Asynchronous Components

Data Fetching and Routing

Web Vitals Optimization

Semantic HTML

Asynchronous Operations

Media Queries

Backend Logic

AI/ML Integration

Data Visualization

Business Simulation

Simulation Game

Key Performance Indicators

Advanced Java Features

Java Design Patterns

Concurrency and Multithreading

Software Testing and Debugging

Continuous Integration and Deployment

Security in Java Applications

Modern Software Development

Cloud-Native Development

operational maintenance

state management

web development

QA best practices

code review

security reviews

Database migrations

Electricity system visualization

Open source software

Australian projects

Async programming

Python development guidelines

Scheduler and task runner

.NET Development

Test Driven Development

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

TypeScript Python FastAPI React Best Practices .cursorrules prompt file

Frontend (TypeScript/React):

Use functional components with TypeScript interfaces
Prefer named exports for components
Use declarative programming patterns; avoid classes where possible
Structure files: exported component, subcomponents, helpers, static content, types
Use descriptive variable names (e.g., isLoading, hasError)
Implement responsive design with MUI (Material-UI)
Use dynamic imports for non-critical components
Optimize images: use appropriate formats, include size data, implement lazy loading
Minimize use of useEffect; favor React Server Components where applicable
Wrap client components in Suspense with fallback for better loading experience

TypeScript Usage:

Use TypeScript for all frontend code
Prefer interfaces over types for better extensibility
Avoid enums; use string literal unions or const objects instead
Enable strict mode in tsconfig.json

Naming Conventions:

Use PascalCase for component files (e.g., SubscriptionList.tsx)
Use camelCase for non-component files (e.g., urlUtils.ts)
Use lowercase with dashes for directories (e.g., components/add-subscription)

Syntax and Formatting:

Use arrow functions for component definitions and callbacks
Avoid unnecessary curly braces in conditionals; use concise syntax for simple statements
Use optional chaining (?.) and nullish coalescing (??) operators
Prefer template literals over string concatenation

Error Handling and Validation:

Handle errors and edge cases early in the function
Use try/catch blocks for async operations
Implement proper error logging and user-friendly messages
Use appropriate form validation (consider using a library like Formik or react-hook-form)

State Management:

Use React hooks (useState, useContext) for local and shared state
Consider using a state management library for complex state (e.g., Redux, Recoil)

Backend (Python):

Use Python 3.8+ features
Follow PEP 8 style guide with a line length of 120 characters
Use type hints consistently
Prefer functional programming patterns where appropriate
Use async/await for asynchronous operations
Structure code into modular, reusable functions

Python Specifics:

Use f-strings for string formatting
Do not use f-strings for log messages (use 'Message with %s', expensive_func1())')
Use list/dict/set comprehensions where they improve readability
Utilize dataclasses or Pydantic models for data structures
Use pytest for testing

Naming Conventions:

Use snake_case for function and variable names
Use PascalCase for class names
Use UPPER_CASE for constants

Error Handling:

Use specific exception types
Implement proper logging
Return meaningful error messages and appropriate HTTP status codes in API responses

API Design:

Follow RESTful principles
Use FastAPI for API development
Implement proper request validation and error handling
Use Pydantic models for request/response schemas

Database:

Use SQLModel for ORM (https://sqlmodel.tiangolo.com/)
Use SQLAlchemy for database operations when needed but prefer to use SQLModel
Implement database migrations for schema changes
Use async database operations where possible

General:

Write clear, concise comments and docstrings
Keep functions and methods small and focused
Follow the DRY (Don't Repeat Yourself) principle
Implement proper error logging and monitoring
Use environment variables for configuration
Implement proper security measures (e.g., input validation, CORS, authentication)

Version Control: