Browse

App Development .cursorrules strategies

Filters

Tech

Clear

RBAC

obsidian

Discord.py

Loguru

VCRPy

Pytest

CliRunner

Pytest-Recording

Clear

Database Design

Deployment and Scaling

Personal Website

Minimalist Design

3D Graphics

Entrepreneurship

Design System

Laravel development

TALL stack

Alpine.js integration

Laravel 11 changes

Livewire components

Contract Development

Decentralized Applications (DApps)

Coding

Nuxt-specific Guidelines

Formatting

UI

Composition API

Key Conventions

ES6

Bun

GraphQL

Unix Philosophy

Behavior-Driven Development

Data Engineering

JavaScript Code Style

Static Generation

Async/Await

React Functional Components

JavaScript ES6

component libraries

frontend development

database integration

code maintainability

Async Ecosystem

Rust Best Practices

Concurrency

TypeScript coding standards

Web development

Error handling and validation

React best practices

Programming principles

AI Modeling

Village Simulation

Data Structures and Algorithms

Programming Paradigms

Prompting Guidance

AI Behavior Guidelines

Styling Guidelines

Web Scraping

Data Extraction

Software Best Practices

Mobile Development

Component Libraries

Software development

Code best practices

Debugging and Troubleshooting

Material UI Usage

iterative refinement

full-stack development

authentication

system thinking

clean code practices

data fetching

testing and documentation

User-Friendly Tools

README Generator

Software Projects

data science

software testing

command line applications

JavaScript naming conventions

Programming best practices

Code Improvement

Data Analysis

Medical Imaging

Code Reproducibility

document authoring

asynchronous operations

serverless architecture

Adobe Edge Delivery Services

accessibility

lazy loading

responsive design

GitHub integration

spreadsheet integration

semantic HTML

block-based development

metadata handling

content management

Cross-Platform Development

Scripting

Software Documentation

Programming Languages

Cross-platform applications

Schema validation

Monorepo management

Mobile development

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

React Native Expo Ignite .cursorrules prompt file

// React Native Expo Ignite .cursorrules

// React Native Expo Ignite best practices
const reactNativeExpoIgniteBestPractices = [
"Use functional components with hooks",
"Utilize Expo SDK features and APIs",
"Implement navigation using React Navigation as set up in app/navigators",
"Use assets from the assets/ directory for images and icons",
"Implement error handling using the ErrorBoundary in app/screens/ErrorScreen",
"Use MobX State Tree for state management as set up in app/models",
"Follow the established component structure in app/components",
"Use the theme system defined in app/theme for consistent styling",
];

// Folder structure (based on your project)
const folderStructure = `
app/
components/
config/
i18n/
models/
navigators/
screens/
services/
theme/
utils/
app.tsx
assets/
icons/
images/
ignite/
templates/
test/
`;

// Additional instructions
const additionalInstructions = `

Use TypeScript for all new files
Implement styling using the typography and spacing from app/theme
Utilize the Icon component for vector icons
Use Expo's SecureStore for sensitive data (implement in app/utils if needed)
Implement API calls using the api service in app/services/api
Follow the established patterns for creating new screens and components
Use the translate function from app/i18n for internationalization
Extend models in app/models for new data structures
Add new navigation routes in app/navigators/AppNavigator.tsx
Use Expo's OTA updates for quick deployments
Write tests for new functionality in the test/ directory
`;

// Specific rules for this project
const projectSpecificRules = `

Use the Screen component from app/components for new screens
Extend the RootStore in app/models/RootStore.ts for new global state
Use the Button component from app/components for consistent button styling
Implement new forms using the TextField component from app/components
Use the ListView component for optimized list rendering
Follow the established patterns in app/screens for creating new screens
Use the ErrorBoundary component for catching and displaying errors
Implement new API endpoints in app/services/api/api.ts
`;

stack:

React Native Expo Ignite .cursorrules prompt file

Salman Hussain

0

NEW

Next.js Supabase Todo App .cursorrules prompt file

Project Specification & Guidelines

Use the project specification and guidelines to build the Todo app.

Overview

Todo is a web app that allows you to manage your todos.

Tech Stack

Frontend: Next.js, Tailwind, Shadcn, Framer Motion
Backend: Supabase, Drizzle, Server Actions
Auth: Clerk
Payments: Stripe

Specification

Guidelines

Follow these rules:

All components should go in /components and be named like example-component.tsx unless otherwise specified
All actions should go in /actions and be named like example-actions.ts unless otherwise specified
All schemas should go in /db/schema and be named like example-schema.ts unless otherwise specified
All queries should go in /db/queries and be named like example-queries.ts unless otherwise specified

stack:

Next.js Supabase Todo App .cursorrules prompt file

Mckay Wrigley

3

NEW

Tailwind React Firebase .cursorrules prompt file

Here are some best practices and rules to follow for creating a high-quality, mobile-first web app with excellent UI/UX using Tailwind, React, and Firebase:

Mobile-First Design:

Always design and implement for mobile screens first, then scale up to larger screens.
Use Tailwind's responsive prefixes (sm:, md:, lg:, xl:) to adjust layouts for different screen sizes.

Consistent Design System:

Create a design system with consistent colors, typography, spacing, and component styles.
Utilize Tailwind's configuration file (tailwind.config.js) to define your custom design tokens.

Performance Optimization:

Use React.lazy() and Suspense for code-splitting and lazy-loading components.
Implement virtualization for long lists using libraries like react-window.
Optimize images and use next/image for automatic image optimization in Next.js.

Responsive Typography:

Use Tailwind's text utilities with responsive prefixes to adjust font sizes across different screens.
Consider using a fluid typography system for seamless scaling.

Accessibility:

Ensure proper color contrast ratios using Tailwind's text-* and bg-* classes.
Use semantic HTML elements and ARIA attributes where necessary.
Implement keyboard navigation support.

Touch-Friendly UI:

Make interactive elements (buttons, links) at least 44x44 pixels for easy tapping.
Implement touch gestures for common actions (swipe, pinch-to-zoom) where appropriate.

USE THE IMAGES IN THE MOCKUPS FOLDER AS EXAMPLE OF HOW TO STYLE THE APP AND CREATE THE LAYOUT

WHEN CREATINGA FILE DON'T CONFLICT IT WITH .TSX AND .JSX FILES

Firebase Best Practices:

Implement proper security rules in Firebase.
Use Firebase SDK's offline persistence for better performance and offline support.
Optimize queries to minimize read/write operations.

Error Handling and Feedback:

Implement proper error boundaries in React.
Provide clear feedback for user actions (loading states, success/error messages).

Animation and Transitions:

Use subtle animations to enhance UX (e.g., page transitions, micro-interactions).
Utilize Tailwind's transition utilities or consider libraries like Framer Motion.

Form Handling:

Use libraries like Formik or react-hook-form for efficient form management.
Implement proper form validation with clear error messages.

Code Organization:

Follow a consistent folder structure (e.g., components, hooks, pages, services).
Use custom hooks to encapsulate and reuse logic.

Native-like Features:

Implement pull-to-refresh for content updates.
Use smooth scrolling and momentum scrolling.
Consider using libraries like react-spring for physics-based animations.

Here’s a concise prompt for a language model to help you with the logic for creating AI-powered medication insights in your app:
Prompt:
Design a feature for a pill management app that tracks user interactions with medications (Take/Skip) and generates monthly adherence reports.
The app should:
User Interface: Display pills for "Morning," "Afternoon," and "Night" with buttons for "Take" and "Skip." Show a confirmation modal for user actions.
Data Collection: Log user interactions (pill ID, action, timestamp, notes) in a database.
Monthly Report: Aggregate data to calculate total pills scheduled vs. taken, adherence percentage, and trends (e.g., frequently skipped pills).
AI Insights: Use basic statistical analysis to generate personalized suggestions based on user feedback (e.g., side effects, missed doses).
Dashboard: Create a section for users to view their monthly reports, including adherence percentage, trends, and AI-generated suggestions.
This prompt provides a clear and structured request for assistance in developing the feature, focusing on key components and functionality.

stack: