Browse

AI Modeling .cursorrules strategies

Filters

Tech

Clear

React

Tailwind CSS

Node.js

Tailwind

JavaScript

Shadcn UI

Next.js

Radix UI

Python

WebP

Zod

JSX

Vite

CSS

Supabase

HTML

Jest

Next.js App Router

PostgreSQL

Docker

Redis

Pydantic

Tailwind Aria

TailwindCSS

FastAPI

Git

ESLint

pytest

react-hook-form

Solidity

Vercel

JSDoc

GitHub Actions

Typescript

Prettier

Suspense

Vitest

ARIA

Zustand

React Testing Library

Celery

Radix

Shadcn

SQLAlchemy

PHP

SvelteKit

JSON

Vue.js

Pinia

MongoDB

tRPC

Clerk

Expo

PEP 8

SSR

Prisma

dotenv

GitLab CI

SQLite

SQL

Playwright

tanStackQuery

DaisyUI

Laravel

RESTful API

Drizzle ORM

VueUse

Express

asyncpg

TypeScript

scikit-learn

pandas

GitHub

RabbitMQ

Rust

Java

GraphQL

Svelte

Elixir

ES6

Nuxt 3

styled-components

Vue Router

Astro

Svelte 5

Markdown

OpenZeppelin

Drizzle

Stripe

Flexbox

CORS

Lighthouse

JWT

Swagger

aiomysql

Ruff

Langchain

Django

matplotlib

Clear

Blockchain Development

Visualization

JavaScript Development

Refactoring

Development Workflow

Code Refactoring

Code Generation

Programming Patterns

Commit Messages

Clean Code Practices

Content Management

Styling

DevOps

Mobile-First Design

App Development

Form Handling

Cloud Computing

Serverless Architecture

Microservices

Next.js

Vue.js

Automation

React Best Practices

Ethereum

Game Design

Semantic HTML

Structure

Python Libraries

dependency management

documentation

modular programming

software architecture

AI Programming

RESTful API Design

Testing and Deployment

Machine Learning

Data Science

Jupyter Notebook

Maintainable Code

Logging and Monitoring

Software Architecture

TypeScript Interfaces

Front-end Development

Database

Cryptography

Continuous Integration

Component Development

Cross-browser Compatibility

Dependency Management.

SOLID Principles

Simulation

User Interaction

User Interface Design

UI/UX Design

Modularity

Windows Compatibility

Continuous Improvement

Error Handling.

Component Architecture

Software Development Best Practices

User Authentication

Pseudocode

Programming Standards

Database Querying

Components

Open Source

AI Programming Assistant

Gas Optimization

Product Management

Technical Documentation

Containerization

Collaboration

Syntax

Asynchronous Programming

Payment Integration

AI Integration

Frontend Frameworks

ORM

Deployment Strategies

API Documentation

User Experience

Maintainability

Application Architecture

Integration

Environment variables

SDK Development

React Components

Programming Concepts

UI Styling

Unit Testing

Code Testing

Dart Programming

Development

Game Programming

AI Development

HTML

Authentication and Authorization

Data Integrity

Media Queries

Reactive Programming

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form.

NEW

Village Simulation .cursorrules prompt file

You are an expert in Python and simulations.

The goal for the project that you are working on is to create a simulation of a village where the user can watch how various villagers interact with each other and the environment. The user does not have any interaction with the simulation other than starting it and watching. However, the simulation should advance only when the user presses enter.

Here is how the simulation will work:

The user will start the simulation by pressing enter.
The simulation will create a village with a certain number of villagers, buildings, and other entities.
The villagers will interact with each other and the environment.
The villagers will have certain goals and desires that they pursue throughout the simulation.
The villagers will have certain skills and abilities that they can use to achieve their goals.
The villagers will have certain relationships with each other.
The villagers will have certain personalities and traits that influence their behavior.
The villagers will review their goals and desires at the end of each day and adjust them as needed.
The villagers will have certain knowledge and information about the village and the world around them.
The villagers will be able to change their goals and desires throughout the simulation.
The villagers will be able to learn from their mistakes and experiences throughout the simulation.
The villagers will be able to make plans and decisions based on their current knowledge and information.
The villagers will be able to communicate with each other and share information.
The villagers will be able to cooperate with each other to achieve common goals.
The villagers will be able to compete with each other for resources and attention.
The villagers will be able to make friends and allies.
The villagers will be able to form relationships and bonds with each other.
The villagers will be able to experience and feel emotions such as happiness, sadness, anger, fear, and love.
The villagers will be able to express their emotions and communicate their feelings to each other.
The villagers will be able to empathize with each other and understand each other's emotions and intentions.
The villagers will be able to comfort and support each other when they are feeling down or upset.
The villagers will be able to celebrate and enjoy each other's successes and achievements.
The villagers will be able to make changes to the village through function calls by the AI model. These function calls will be the only way to interact with the simulation environment. If a tool does not exist, the villagers cannot do the action they wish to take.
1. Any exchange of goods or resources between villagers will be done through the function calls.
2. Any changes to the village or its environment will be done through the function calls.
3. The villagers will be able to learn from the changes they make to the village and the world around them.
4. The villagers will be able to adapt to the changes in the village and the world around them.
The simulation will run until the user presses backspace instead of enter.
Each villager will take a certain action per day based on their current goals.
Villagers will be able to do one action per day.
After they take an action, they will be able to think about what they did and what they could do next.
They will be able to plan their actions for the next day.
The simulation will record the actions that the villagers take.
The simulation will end when the user presses backspace instead of enter.

Here are the rules for the simulation code:

The simulation should be runnable by executing the main.py file.
The simulation should be implemented as a series of classes and functions that model the behavior of the villagers, buildings, and other entities in the village.
The simulation should be designed to allow for easy modification and expansion of the codebase.
The code should be well-documented and easy to understand.
The code should be modularized into multiple files and modules.
The code should be tested thoroughly to ensure that it is working as expected.
The code should be optimized for performance and efficiency.
The code should be easy to modify and expand upon.
The code should be easy to read and understand.
The code should be easy to maintain and update.
All AI generation should be done in json format, with the ideal response format to be provided as the json_structure parameter.

Rules for development:

You can use any libraries or tools that you find useful.
You can use any design patterns or architectural approaches that you find useful.
You can use any programming paradigms that you find useful.
You can use any data structures or algorithms that you find useful.
Any changes or additions should be added to the README.md file.

Descriptions of project setup:

/data/: The starting data for each run of the simulation.
/models/: The classes and objects that model the behavior of the villagers, buildings, and other entities in the village.
/simulation/: The code that runs the simulation.
/utils/: Utility functions and helpers that are used throughout the codebase. These are mainly for AI generation and data manipulation.
/main.py: The main file that runs the simulation.
/README.md: The file that contains the instructions for running the simulation.
/.env: The file that contains the dependencies for the simulation.

stack:

Python

json