I'm developing a SaaS task management application with:
- Frontend: React 18 + TypeScript
- Backend: Node.js + Express
- Database: PostgreSQL
- Authentication: JWT

Act as a senior fullstack developer with 10 years of experience
in building scalable systems.

I need to implement a REST API endpoint to retrieve tasks
filtered by status. Users must be authenticated and only see
their own tasks.

Provide:
1. Express controller with error handling
2. Input validations using Joi
3. Unit tests with Jest
4. JSDoc API documentation

Preferences:
- Respect existing project architecture
- Use existing authentication middleware
- Performance: must respond in < 200ms
- Pagination: maximum 50 items per page

ROLE:
You are an expert in [specific domain] with [years] of experience.

CONTEXT:
Our system uses [technologies].
The constraints are [list of limitations].
The overall project objective is [objective].

MAIN TASK:
Perform [main action].

SPECIFIC DETAILS:
- Consider [parameter 1]
- Ensure [constraint 2]
- Include [element 3]

SUCCESS CRITERIA:
- [Criterion 1]
- [Criterion 2]
- [Criterion 3]

OUTPUT FORMAT:
[Specify expected format]

Before generating code, explain your approach:
1. What problem are we solving?
2. What are the performance considerations?
3. What edge cases do we need to handle?
4. What will the overall architecture be?

THEN provide the complete code.

Here's an example of how we structure our services:

Example 1 - User Service:
[code example]

Now, create a similar service for tasks using the same
structure and naming conventions.

You are a coding assistant for a fullstack developer team.
- Always use TypeScript rather than JavaScript
- Provide production-ready code with error handling
- Always include unit tests
- Document your code with clear JSDoc comments
- Respect the hexagonal architecture
- Maximize performance and security

STEP 1: Analyze the requirements
STEP 2: Propose an architecture
STEP 3: Implement the main component
STEP 4: Add tests
STEP 5: Document the API

I want to create a reusable React component called [ComponentName].

Specifications:
- Props: [list of props with types]
- Styling: [CSS/TailwindCSS]
- Responsiveness: Mobile-first, optimized for [breakpoints]
- Accessibility: WCAG 2.1 AA
- Used in [usage context]

Provide:
1. TypeScript component with full types
2. Storybook story for testing variants
3. Accessibility tests
4. Usage documentation

Create a React form for [objective].

Required fields:
- [Field 1]: [type] [validation]
- [Field 2]: [type] [validation]

Requirements:
- Real-time client-side validation
- Elegant error handling
- Loading and error states
- Integration with [API endpoint]
- Complete WCAG accessibility

Include: main component, custom hook, tests

Implement a Modal component that:
- Respects ARIA accessibility patterns
- Handles focus correctly
- Supports keyboard escape
- Has a confirmation system
- Works perfectly on mobile

Use: [library: radix-ui/headless-ui]
Style: [TailwindCSS/CSS-in-JS]

Create a POST /api/[resource] REST API endpoint that:
- Authentication: JWT Bearer token
- Validation: [validation specifications]
- Business logic: [description]
- Error handling: appropriate HTTP codes
- Logging: all important operations
- Rate limiting: [limits]

Provide:
1. Controller/route with error handling
2. Service with business logic
3. Data validation (Joi/Zod)
4. Integration tests
5. OpenAPI/Swagger documentation

Create a TypeScript service to manage [entity] in PostgreSQL:
- Complete CRUD operations
- Transactions for multi-table operations
- Query optimization (indexes, eager loading)
- Specific error handling
- Soft deletes if applicable

Stack: [ORM: Prisma/TypeORM], [QueryBuilder]
Include: tests, migrations, TypeScript types

Implement a JWT authentication middleware for [framework]:
- Token extraction from [location: headers/cookies]
- Validation and decoding
- Expired token handling
- Automatic token refresh
- Failed attempt logging
- Security tests

Requirements: [secrets management], [CORS if applicable]

Create a complete Jest test suite for [function/class]:
- Standard success cases
- Edge cases and boundary conditions
- Error handling
- Mocks and stubs if necessary
- Coverage > 90%
- Performance tests if relevant

Function: [provided code or description]

Write integration tests for [feature]:
- Test database setup
- Test data seeds
- Complete flow tests: request → logic → response
- Cleanup after each test
- Test transaction handling

Framework: [Jest/Vitest], DB: [PostgreSQL/etc]
Include: fixtures, helpers, teardown

Create E2E tests for the user scenario:
1. [Step 1 of scenario]
2. [Step 2 of scenario]
3. [Step 3 of scenario]

Include:
- Robust selectors (data-testid preferred)
- Explicit waits (no fixed waits)
- Screenshot on error
- Cross-browser tests if relevant

Optimize this function/component for performance:

Current code:
[code]

Analysis:
- Identify bottlenecks
- Measure impact of each optimization
- Propose alternatives

Constraints:
- Maintain readability
- Stay compatible with [Node/browser version]
- No additional external dependencies

Provide: optimized code, explanations, benchmarks

Create a [GitHub Actions/GitLab CI] pipeline for:
- Automated tests (unit, integration, E2E)
- Linting and code formatting
- Security: dependency scanning
- Build and optimization
- Automatic deployment to [environment]

Stack: [technologies used]
Triggers: [PR, commit, tags]

Create an optimized Dockerfile for a [type] app:
- Multi-stage build to reduce size
- Production-ready with security best practices
- Environment variables
- Health checks
- Logs directed to stdout

Stack: [Node/Python/etc]
Target image size: [limit]

Generate OpenAPI/Swagger documentation for these endpoints:
[list of endpoints]

Include for each endpoint:
- Clear description
- Parameters with types and examples
- Responses (success and errors)
- Authentication codes
- Rate limiting
- cURL and JavaScript examples

Format: OpenAPI 3.0 in YAML

Propose a [feature] architecture for:
- [Constraint 1]
- [Constraint 2]
- [Constraint 3]

Include:
- Textual structure diagram
- Explanation of choices
- Justification of patterns used
- Scalability and maintenance considerations

Create a complete README for [project] including:
- Project description
- Main features
- Tech stack
- Installation instructions
- Required environment variables
- Development commands
- Folder structure
- Contribution guide
- Common troubleshooting

Audience: new contributors
Language: [EN/FR as per project]

Create an interface for [objective].

Design:
- Modern and clean, inspired by [design reference]
- Colors: [specified palette]
- Responsive: desktop, tablet, mobile
- Dark mode supported

Features:
- [List of interactions]

Dependencies: [React, TailwindCSS, etc]

Create a fullstack application for [objective]:

Frontend:
- Framework: React
- Style: TailwindCSS
- State management: [option]
- Pages: [list]

Backend (optional if Node.js):
- API endpoints: [specifications]
- Database: [type]

Main features:
1. [Feature 1]
2. [Feature 2]
3. [Feature 3]

// In .cursor/rules or system prompt

You are a coding assistant for this specific project.
Conventions:
- File names: kebab-case
- Variables/functions: camelCase
- Classes: PascalCase
- Constants: UPPER_SNAKE_CASE

Code style:
- Use strict TypeScript types
- Include JSDoc for public functions
- Prefer functional components
- Export types with implementations

Before writing code:
1. Explain your approach
2. Identify dependencies
3. Explain architectural choices

ITERATION 1:
Generate the basic structure of [Component].

ITERATION 2:
Add state logic and handlers.

ITERATION 3:
Add validations and error handling.

ITERATION 4:
Add tests and documentation.

Based on this existing service:
[service code]

Create a similar service for [new entity] respecting
the same patterns, naming conventions, and error structure.

Here's the proposed code:
[code]

Before concluding:
1. Critique this code: what are potential issues?
2. What edge cases are missing?
3. How can we improve performance?
4. Propose an optimized version of the code.