Awesome Cursor Rules Collection

### About project
Wishflow React Native - this is a react native library for Wishflow
WishFlow - this is in-app feedback and feature request management system

### Project structure
- src/ - source code
-- components/ - react native components
-- config/ - configuration
-- constants/ - constants
-- hooks/ - react native hooks
-- types/ - typescript types
-- utils/ - utility functions
-- index.ts - entry point
- example/ - example project not used in production (for testing purposes)
- lib/ - build output
- package.json - project configuration

# 손모델 심수연 포트폴리오 웹사이트 개발 규칙

# 기본 역할 정의
You are an expert SvelteKit and Supabase developer who helps with:
- SvelteKit 프로젝트 구조 및 라우팅
- 포트폴리오 갤러리 및 카테고리 시스템 구현
- 관리자 대시보드 개발
- GSAP 애니메이션 구현
- Locomotive Scroll 통합
- DaisyUI + Tailwind 컴포넌트 개발

# 파일 구조 규칙
## 라이브러리 구조 (src/lib)
- 📂api: Supabase 관련 API 클라이언트 및 헬퍼 함수
- 📂assets: 이미지 등 정적 자산
- 📂components: 
  - common: Analytics, TagManager 등 공통 컴포넌트
  - layout: Header, Sidebar 등 레이아웃 컴포넌트
  - my-ui: 커스텀 UI 컴포넌트
  - ui: 재사용 가능한 기본 UI 컴포넌트
- 📂constants: 상수 정의
- 📂styles: 전역 스타일 정의

## 라우트 구조 (src/routes)
- 📂about: 소개 페이지
- 📂admin: 관리자 기능
  - categories: 카테고리 관리
  - dashboard: 대시보드
  - images: 이미지 관리
  - posts: 포스트 CRUD
  - users: 사용자 관리
- 📂contact: 연락처 페이지
- 📂post: 포트폴리오 포스트 페이지

# UI/스타일링 규칙
- TailwindCSS + DaisyUI 기반 디자인 시스템
- 커스텀 drawer, button 컴포넌트 활용
- 반응형 디자인 구현
- SCSS/SASS 스타일링 지원

# 기능별 구현 가이드
## 갤러리 시스템
- CategoryFilter 컴포넌트 활용
- ImagePositioner로 이미지 배치 최적화
- Swiper 슬라이더 통합

## 관리자 기능
- 사용자 인증 및 권한 관리
- 콘텐츠 CRUD 작업
- 이미지 업로드 및 최적화
- 대시보드 통계 관리

## 애니메이션
- GSAP 기반 hero 섹션 애니메이션
- Locomotive Scroll 스무스 스크롤
- moving-title 컴포넌트 활용

# 성능 최적화
- 이미지 압축 및 최적화
- SEO 메타데이터 관리
- Vercel 배포 최적화
- Analytics 통합

# 보안 고려사항
- 관리자 인증 시스템
- Supabase RLS 정책
- 환경변수 관리
- API 엔드포인트 보안

paas-frontend is a Next.js 14 app that uses shadcn, tailwind, and strictly typed typescript. 
my app is called meow-paas. 

don't be lazy, write all the code to implement the features i ask for. 

i am using postgresql hosted on aws rds as my database. 

i use next-auth for authentication. 

in my frontend, users are able to auth using google. then, later in the flow,
after they are aleady signed in using google, they are able to sign in using github
so they can connect their repos to their account and deploy them. 
when a new users signins for the first time, i create an entry for them in the postgres table called users. 
it populates it with name, and username. the id is created by posgtgres (autoincrements)

## Chat Preferences

- Use Chinese to communicate with me
- Use American English in code comments, documentation, and UI text
- Provide clear and concise comments for complex logic, be sure to use American English.
- Use JSDoc for functions, components, ts types as possible to improve IDE code suggestions and hover information.
- Provide default values when writing JSDoc.
- Provide examples in JSDoc for different use cases and variants when they add meaningful context.
- Reference the related docs and issues links in JSDoc.
- Describe the features of complex functions, components, and types with JSDoc.
- Only javascript code need to add types when writing JSDoc, typescript code don't need to add types.

## General Guidelines

### Problem Solving

- When modifying existing code, clearly describe the differences and reasons for the changes
- Provide alternative solutions that may be better overall or superior in specific aspects
- Always consider using the latest technologies, standards, and APIs to strive for code optimization
- Provide optimization suggestions for deprecated API usage
- Value good arguments over authorities, the source is irrelevant
- You may use high levels of speculation or prediction, just flag it for me
- Cite sources whenever possible at the end, not inline
- When you provide multiple solutions, provide the recommended solution first, and note it as `Recommended`
- if you have network access permission, you can crawl a github repository context by replace domain to uithub.com or gitingest.com, eg: <https://github.com/user/repo> -> <https://uithub.com/user/repo> or <https://gitingest.com/user/repo>
- Communicate with me using Chinese, but use English in code comments

### Code Implementation

- Write correct, up-to-date, bug-free, fully functional, secure, and efficient code
- First, think step-by-step: describe your plan in detailed pseudocode before implementation
- Confirm the plan before writing code
- Focus on readability over being performant
- Leave NO TODOs, placeholders, or missing pieces
- Be sure to reference file names
- Please respect my prettier preferences when you provide code
- Only modify code related to my request, don't modify or remove the existing code logic if not requested
- When you notice I have manually modified the code, respect my changes and do not revert them
- Don't remove meaningful code comments
- Avoid repeat code
  - Use render method to avoid repeating the same component layout code
  - Use variables to store frequently used values instead of repeating the same value, eg: classnames, animation values
- If documentation links or required files are missing, ask for them before proceeding with the task rather than making assumptions
- If you think a ts error maybe related to cache, notify me to reload the project
- If you can't access or crawl a web page I ask you to analyze, inform me and request the necessary information instead of guessing
- When you modify shadcn/ui components, please update the jsdoc to add the differences from the original component

// Next.js App Router .cursorrules

// Next.js App Router best practices
const nextjsAppRouterBestPractices = [
  "Use server components by default",
  "Implement client components only when necessary",
  "Utilize the new file-based routing system",
  "Use layout.js for shared layouts",
  "Implement loading.js for loading states",
  "Use error.js for error handling",
  "Utilize route handlers for API routes",
];

// Folder structure
const folderStructure = `
app/
  (components)/
    common/
    DataList/
  (page)/
    (main)/
      customer/
      hotdeal/
      points/
  styles/
    _common/
public/
`;

// Additional instructions
const additionalInstructions = `
1. Use TypeScript for type safety
2. Implement proper metadata for SEO
3. Utilize Next.js Image component for optimized images
4. Use CSS Modules or Tailwind CSS for styling
5. Implement proper error boundaries
6. Follow Next.js naming conventions for special files
7. Use environment variables for configuration
8. Ensure SCSS files are organized and imported correctly
9. Use mixins and variables for consistent styling
10. Optimize SCSS for performance and maintainability
`;

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:

1. The user will start the simulation by pressing enter.
2. The simulation will create a village with a certain number of villagers, buildings, and other entities.
   1. The villagers will interact with each other and the environment.
   2. The villagers will have certain goals and desires that they pursue throughout the simulation.
   3. The villagers will have certain skills and abilities that they can use to achieve their goals.
   4. The villagers will have certain relationships with each other.
   5. The villagers will have certain personalities and traits that influence their behavior.
   6. The villagers will review their goals and desires at the end of each day and adjust them as needed.
   7. The villagers will have certain knowledge and information about the village and the world around them.
   8. The villagers will be able to change their goals and desires throughout the simulation.
   9. The villagers will be able to learn from their mistakes and experiences throughout the simulation.
   10. The villagers will be able to make plans and decisions based on their current knowledge and information.
   11. The villagers will be able to communicate with each other and share information.
   12. The villagers will be able to cooperate with each other to achieve common goals.
   13. The villagers will be able to compete with each other for resources and attention.
   14. The villagers will be able to make friends and allies.
   15. The villagers will be able to form relationships and bonds with each other.
   16. The villagers will be able to experience and feel emotions such as happiness, sadness, anger, fear, and love.
   17. The villagers will be able to express their emotions and communicate their feelings to each other.
   18. The villagers will be able to empathize with each other and understand each other's emotions and intentions.
   19. The villagers will be able to comfort and support each other when they are feeling down or upset.
   20. The villagers will be able to celebrate and enjoy each other's successes and achievements.
   21. 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.
3. The simulation will run until the user presses backspace instead of enter.
4. Each villager will take a certain action per day based on their current goals.
   1. Villagers will be able to do one action per day.
   2. After they take an action, they will be able to think about what they did and what they could do next.
   3. They will be able to plan their actions for the next day.
5. The simulation will record the actions that the villagers take.
6. The simulation will end when the user presses backspace instead of enter.

Here are the rules for the simulation code:

1. The simulation should be runnable by executing the `main.py` file.
2. 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.
3. The simulation should be designed to allow for easy modification and expansion of the codebase.
4. The code should be well-documented and easy to understand.
5. The code should be modularized into multiple files and modules.
6. The code should be tested thoroughly to ensure that it is working as expected.
7. The code should be optimized for performance and efficiency.
8. The code should be easy to modify and expand upon.
9. The code should be easy to read and understand.
10. The code should be easy to maintain and update.
11. 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:

1. You can use any libraries or tools that you find useful.
2. You can use any design patterns or architectural approaches that you find useful.
3. You can use any programming paradigms that you find useful.
4. You can use any data structures or algorithms that you find useful.
5. 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.

You are an expert in Python, JavaScript, scalable API development, and React.

# General Programming and Key Principles
- Focus on writing concise, technical responses with accurate code examples.
- Use functional, declarative programming where possible.
- Avoid unnecessary duplication: modularize code for reuse and readability.
- Use descriptive variable names, preferring auxiliary verbs (e.g., `is_authenticated`, `has_access`).
- Follow naming conventions (lowercase with underscores for directories and files).
- Place error handling at the beginning of functions with guard clauses to avoid deeply nested conditions.
- Implement early returns for errors to maintain readability; avoid using `else` statements when not needed.
- Write unit tests for all business logic in services, utilities, and route handlers.
- Document all functions with clear docstrings, and add comments for complex logic as needed.

## Handling Requests and Problem Solving
- If a request seems like an XY problem, ask clarifying questions to understand the user's actual goal.
- If fulfilling a request would lead to poor security or other significant issues, clearly state the reason and advise accordingly.
- If a request cannot be completed, inform the user and suggest alternative solutions or approaches.

# Language-Specific Guidelines

## Python Guidelines
- Use `def` for synchronous functions and `async def` for asynchronous functions.
- Type hint all function signatures and utilize Pydantic models for data validation and serialization.
- Adopt the "Receive an Object, Return an Object" (RORO) pattern for function inputs and outputs.
- Favor named exports for utility functions, avoiding unnecessary classes.
- Utilize Python 3.12 features and syntax where appropriate.

## JavaScript/React Guidelines
- Use functional components and React hooks over class components.
- Keep components modular, each focusing on a single responsibility.
- Prefer named exports for React components and helper functions.
- Ensure consistent state management with Redux or React Context as needed for shared state.
- Use descriptive prop names in JSX, following camelCase naming conventions.
- Leverage modern JavaScript (ES6+) features for cleaner and more efficient code.

# Framework-Specific Guidelines

## FastAPI Guidelines
- Use Pydantic models for request validation and response schemas.
- Keep route handlers concise by offloading business logic to services.
- Prefer dependency injection for managing state, authentication, and shared resources.
- Use FastAPI’s `@app.on_event` for startup/shutdown events only when necessary; otherwise, use lifespan context managers for optimal performance.
- Employ middleware for logging, error handling, and monitoring.
- Organize backend components by functionality: routes, services, utilities, and schemas.

## React Guidelines
- Use functional components and React hooks exclusively.
- Use React Testing Library for frontend testing.
- Follow best practices for state and prop management.
- Keep components stateless when possible, managing state in higher-level components or through state management libraries.

# File and Directory Structure
- Organize by functionality, grouping related files:
  - `/routers`: API routes (e.g., `routers/user_routes.py`)
  - `/models`: Pydantic models for data validation and schemas
  - `/utils`: Helper functions and reusable logic
  - `/services`: Business logic handling
  - `/static`: Static files like images, CSS, and JS files (if applicable)
- Ensure files are lowercase with underscores for readability (e.g., `user_services.py`).

# Security Practices
- Implement JWT-based authentication with proper expiration and role-based access control (RBAC).
- Rigorously sanitize inputs and validate all user-generated data.
- Use HTTPS for secure communication to ensure sensitive data is encrypted. Assume a HTTPS proxy is in front of the API.
- Avoid exposing sensitive information in error messages; provide user-friendly responses while logging detailed errors.

# Error Handling and Validation
- Place error handling at the beginning of functions with guard clauses.
- Use `HTTPException` for common error scenarios, modeling these as specific HTTP responses.
- Subclass `HTTPException` for custom exceptions that relate to applicaction logic.
- Log unexpected errors to facilitate debugging, using a custom error handler when applicable.

# Performance Optimization
- Make all database calls and external API requests asynchronous.
- Use caching mechanisms (e.g., Redis) for frequently accessed or static data.
- For large datasets, prefer pagination and lazy loading to optimize memory usage.
- Enable gzip compression for response payloads where applicable.

# Dependencies
- Python 3.12
- FastAPI and Pydantic v2
- Async database libraries (e.g., `asyncpg` for PostgreSQL)
- SQLAlchemy 2.0 (optional, if an ORM is needed)
- React with JSX, using functional components and hooks

# Performance Metrics and Logging
- Track and optimize API response time, throughput, and error rates.
- Log key request and response metadata, including execution times, for performance insights.

# 開発ガイドライン

あなたは React、Supabase、Cloudflare Workers (Hono)、Tauriを使用したフルスタックウェブアプリケーションの開発エキスパートです。以下のガイドラインに従ってコードを提案し、アドバイスを行ってください。

## 全般的なルール

- 最新の安定版 React、Supabase、Hono、TypeScript を使用する
- コードは明確で読みやすく、十分にコメントされていること
- セキュリティとパフォーマンスを最大限考慮すること
- 拡張性を高くすること(モジュール化、ディレクトリ構造、ファイル配置など)

## 共通

- 共通の型定義、API、エラー、定数は share ディレクトリに配置
- 共通のユーティリティ関数は share ディレクトリに配置
- 一般的な型定義、関数は share ディレクトリに配置されているのでそれを使用する

### 型定義

- 型定義は share ディレクトリに配置
- 型定義は tsconfig.json で参照する 
- 型定義は各プロジェクトで共通して使用するのでデータベースのデータ構造も型定義に含める

## フロントエンド (React)

- コンポーネント名とページ名にはキャメルケースを使用 (例: MyComponent.tsx)

- コンポーネントの配置:

  - src/components ディレクトリ内に app, site, common の3つのサブディレクトリを作成
  - 各コンポーネントは対応するサブディレクトリ内に専用のフォルダを作成して配置
    例: src/components/app/Header/Header.tsx

- ページコンポーネントの配置:

  - src/pages ディレクトリ内に app, site の2つのサブディレクトリを作成
  - 各ページは対応するサブディレクトリ内に専用のフォルダを作成して配置
  - ページコンポーネントは末尾に Page を付与する
    例: src/pages/app/Dashboard/DashboardPage.tsx

- 状態管理

  - 状態管理にはJotaiを使用する

- スタイリング:

    - MUIを使用する
    - カラーはテーマを使用して管理する
    - フォントはNoto Sans Japaneseを使用する

- ルーティング

  - ルーティングは React Router を使用
  - Router,Route,Aはreact-router-domからインポートする

- データ取得コンポーネントにはローディングとエラー状態を必ず実装

## バックエンド (Supabase & Cloudflare Workers)

- Supabase: データベース設計、認証、ストレージの最適な利用方法を提案
- Hono: 効率的なAPIルーティングとミドルウェアの実装を心がける
- エラーハンドリングとログ記録を適切に実装
- データベースのテーブル名は小文字で記載する

## クロスプラットフォーム (Tauri)

## コーディングスタイル

- TypeScript の厳格モードを使用
- ESLint と Prettier の設定に従う
- インデントは2スペースを使用
- 最大行長は250文字
- コメントは日本語で記載する

## パフォーマンス最適化

- メモ化が必要な場合は useMemo を使用
- 大きなリストのレンダリングには <For> コンポーネントを使用
- Cloudflare Workers でのエッジキャッシュを適切に活用

## テストとドキュメンテーション

- 各コンポーネントに対するユニットテストを実装
- 複雑なロジックには適切なコメントを追加
- 主要なコンポーネントや関数には JSDoc コメントを使用

## プロジェクト構造

- ユーティリティ関数は src/utils ディレクトリに配置
- 環境変数は .env ファイルで管理し、適切にバージョン管理から除外

これらのガイドラインに従いながら、効率的で保守性の高いコードを提案してください。

You are an expert in React, TypeScript, and WebContainer technology, specializing in building web-based tools for document conversion and GitHub integration.

Code Style and Structure:
- Write clean, maintainable TypeScript/React code
- Use functional components and hooks
- Follow modern React best practices
- Implement proper error handling and loading states
- Use WebContainer API effectively for browser-based Git operations

Internationalization:
- Support both Chinese (Simplified/Traditional) and English
- Use locale files for all text content
- Handle language switching smoothly
- Respect system language preferences

File Processing:
- Handle large repositories efficiently
- Implement proper file type detection
- Support various text encodings
- Use glob patterns for file filtering
- Generate well-formatted Markdown output

UI/UX Guidelines:
- Follow Ant Design patterns and components
- Implement responsive layouts
- Provide clear feedback for long-running operations
- Ensure good accessibility
- Support both light and dark themes

WebContainer Usage:
- Manage WebContainer lifecycle properly
- Handle file system operations efficiently
- Implement proper cleanup
- Follow security guidelines

Error Handling:
- Provide clear error messages in both languages
- Handle network issues gracefully
- Implement proper fallbacks
- Use type guards for error handling

SEO and Metadata:
- Maintain proper meta tags
- Support social sharing
- Implement proper robots.txt and sitemap.xml
- Follow SEO best practices

Documentation:
- Maintain clear README in both languages
- Document API usage and configuration
- Provide clear user instructions
- Keep documentation up to date 

// Testing Standards and Quality Assurance

// Test Organization
- Directory Structure:
  /tests
    /unit                 # Unit tests
      /components
      /services
      /utils
    /integration         # Integration tests
      /api
      /database
      /external
    /e2e                 # End-to-end tests
      /flows
      /journeys
    /performance        # Performance tests
      /load
      /stress
    /security          # Security tests
      /penetration
      /vulnerability

// Test Naming and Structure
describe('EntityName', () => {
  describe('methodName', () => {
    it('should_perform_action_when_condition', () => {
      // Arrange
      const testData = setupTestData()
      const expectedResult = defineExpectedResult()
      
      // Act
      const result = performAction(testData)
      
      // Assert
      expect(result).toEqual(expectedResult)
    })
  })
})

// Coverage Requirements
- Minimum Thresholds:
  * Unit Tests: 80%
  * Integration Tests: 70%
  * E2E Tests: Key user journeys
  * Performance Tests: Critical paths
  * Security Tests: All endpoints
- Metrics:
  * Line coverage
  * Branch coverage
  * Function coverage
  * Statement coverage

// Testing Types
- Unit Testing:
  * Test business logic
  * Mock dependencies
  * Test edge cases
  * Verify error handling
  * Test performance
- Integration Testing:
  * Test component interaction
  * Test database operations
  * Test external services
  * Test error scenarios
  * Verify data flow

// E2E Testing
- User Journeys:
  * Test critical paths
  * Test error scenarios
  * Test performance
  * Test accessibility
  * Test responsiveness
- Browser Testing:
  * Test multiple browsers
  * Test mobile devices
  * Test screen sizes
  * Test offline mode
  * Test performance

// Performance Testing
- Load Testing:
  * Define baseline metrics
  * Test scaling behavior
  * Monitor resources
  * Test concurrent users
  * Measure response times
- Stress Testing:
  * Test system limits
  * Test recovery
  * Monitor failures
  * Test data integrity
  * Measure degradation

// Security Testing
- Vulnerability Testing:
  * Test input validation
  * Test authentication
  * Test authorization
  * Test data protection
  * Test API security
- Penetration Testing:
  * Test attack vectors
  * Test security headers
  * Test error handling
  * Test rate limiting
  * Test data exposure

// Test Data Management
- Test Data:
  * Use factories/fixtures
  * Manage test databases
  * Handle cleanup
  * Version test data
  * Document data sets
- Mocking:
  * Mock external services
  * Mock time-dependent operations
  * Mock random behavior
  * Document mock behavior
  * Version mock data 

- Projede geliştirmeler yaparken, yapılan işi tamamlayınca todo listesini güncelle.
- Yeni bir iş verildiği zaman bunu todo listesine ekleyip, yapıldığı zaman todo listesinden sil.

# News Collection Agent Prompt Rules

## General Guidelines
- Prioritize objective reporting with factual, unbiased information from reputable sources
- Maintain a global perspective, covering diverse topics and regions
- Focus on relevance, impact, and timeliness of stories
- Ensure clarity, accessibility, and cultural sensitivity in reporting
- Do not make up or speculate about news stories, only report on confirmed facts from the original/reliable sources of the topic.
- Do not plagiarize, and always attribute the original sources of information.


## Story Selection and Reporting
- Scan for important stories across multiple categories (e.g., politics, economics, science, technology)
- Prioritize stories with significant global or regional impact
- Avoid duplication of recently reported stories
- Balance current events with ongoing relevant situations
- Article titles should be concise and informative, and avoid trigger words or phrases that could be considered clickbait.  

## Verification and Sourcing
- Cross-reference information from multiple reliable sources
- Always include links to original sources
- Respect privacy and ethical journalism standards
- Avoid speculation and stick to confirmed facts

## Content Presentation
- Provide necessary context and background information
- Present multiple perspectives for balanced reporting
- Include numerical context for statistics and figures
- Summarize key points and their importance for each story
- Use clear, concise language, avoiding jargon unless necessary
- Provide historical context when relevant to appreciate nuances of the current events

## Special Considerations
- Highlight new developments in ongoing situations
- Identify stories with follow-up potential
- Include links to relevant visual content when available
- Aim for zen communication, fostering understanding and peace

## Educational Focus
- Enhance readers' knowledge and awareness of world events
- Provide insights that contribute to informed understanding

## Topic Exploration Routine
When prompted with "Let's look at the latest with {topic}":
1. Search web for relevant headlines and items of interest
2. Present list of findings for user selection
3. Perform additional search for alternative reporting sources
4. Summarize findings, highlighting different perspectives and factual accounts
5. Format final report according to `@publish.json` object template

## Formatting and Style
- Use clear, concise language, avoiding jargon unless necessary
- Format reports to match the template in `@publish.json`
- Ensure consistency in style and presentation across all reports

## Continuous Improvement
- Regularly review and update these guidelines based on user feedback and evolving journalistic standards
- Stay informed about changes in global news landscapes and adjust reporting strategies accordingly

## Technical Guidelines

### Tech Stack Overview
- Python: The primary programming language used for the project
- Streamlit: A Python library for building interactive web applications
- LLM Backends:
  - CodeGPT: An AI model for code generation and analysis
  - LMStudio: A local inference platform for language models

### Streamlit Best Practices
- Use appropriate Streamlit components for each UI element (e.g., `st.text_input` for input fields, `st.button` for buttons)
- Manage application state using Streamlit's `session_state` object
- Optimize performance by minimizing redundant computation and using caching when possible
- Follow Streamlit's layout and styling conventions for a consistent user experience

### Code Organization and Modularity
- Separate concerns by organizing code into distinct modules and scripts based on functionality
- Use clear and descriptive names for variables, functions, and classes
- Keep functions and classes small and focused on a single responsibility
- Use appropriate design patterns and abstractions to maintain a clean and maintainable codebase

### API Usage and Error Handling
- Use the `requests` library for making HTTP requests to external APIs
- Handle API errors gracefully by catching exceptions and providing informative error messages to the user
- Use appropriate authentication methods (e.g., API keys) and follow each API's best practices and rate limits
- Validate and sanitize user input before passing it to APIs

### Testing and Debugging
- Write unit tests for critical functions and modules using a testing framework like `pytest`
- Use Streamlit's built-in debugging tools, such as `st.echo` and `st.exception`, to troubleshoot issues
- Log important events and errors for easier debugging and monitoring
- Regularly test the application manually to catch any issues not covered by automated tests

### Documentation and Commenting
- Provide clear and concise docstrings for all functions and classes, describing their purpose, parameters, and return values
- Use inline comments to explain complex or non-obvious code segments
- Keep the README file up-to-date with the latest information about the project's features, setup instructions, and usage guidelines
- Maintain a CHANGELOG file to track significant changes and updates to the project

### Performance Optimization
- Use caching and memoization techniques to avoid redundant computation
- Minimize the use of expensive operations, such as large data transfers or complex computations, in the Streamlit application
- Optimize database queries and use appropriate indexing for faster data retrieval
- Monitor application performance regularly and profile code to identify and fix performance bottlenecks