dovhomilja-cz

Design and implement RESTful API endpoints following REST principles with clear resource-based URLs and appropriate HTTP methods. Use this skill when creating API routes, defining API endpoints, implementing HTTP request handlers, working on route files (routes.ts, route.ts, api/*, controllers/*, handlers/*), building REST APIs, designing API versioning strategies, setting up query parameters for filtering and pagination, implementing rate limiting, or returning appropriate HTTP status codes. Apply this skill when structuring backend API architecture, creating new API endpoints, refactoring existing endpoints, or reviewing API design for consistency and best practices.

Create and manage database migrations following best practices for schema changes and data migrations. Use this skill when creating database migration files, modifying database schemas, adding or removing tables and columns, working with migration files (prisma/migrations/*, db/migrate/*, migrations/*), implementing reversible migrations with rollback methods, managing database indexes, handling zero-downtime deployments, separating schema changes from data migrations, or ensuring backwards compatibility during schema updates. Apply this skill when setting up new database tables, altering existing database structures, creating migration scripts, or reviewing migration safety and rollback strategies.

Define and structure database models with proper naming conventions, data integrity constraints, and relationship definitions. Use this skill when creating or modifying database model files, defining table schemas, setting up model relationships (one-to-many, many-to-many, one-to-one), working with ORM model files (schema.prisma, models/*, app/models/*, entities/*), implementing data validation at the model level, adding timestamps and audit fields, defining foreign keys and indexes, choosing appropriate data types, configuring cascade behaviors, or balancing database normalization with query performance. Apply this skill when designing database schemas, creating new models, refactoring existing model structures, or reviewing data integrity and relationship configurations.

Write optimized and secure database queries using parameterized queries, eager loading, and proper indexing strategies. Use this skill when writing database queries, constructing SQL statements, using ORM query methods, implementing data fetching logic, preventing SQL injection attacks, optimizing query performance, avoiding N+1 query problems, selecting specific columns instead of all data, implementing transactions for related operations, setting query timeouts, caching expensive queries, or working with WHERE clauses, JOINs, and ORDER BY statements. Apply this skill when fetching data from databases, optimizing slow queries, refactoring data access code, or reviewing query security and performance.

Build accessible user interfaces using semantic HTML, ARIA attributes, keyboard navigation, and proper color contrast. Use this skill when creating or modifying UI components, implementing forms and interactive elements, working with navigation menus, building modals and dialogs, adding images and media content, writing JSX/HTML markup, ensuring keyboard accessibility, testing with screen readers, managing focus states, implementing proper heading hierarchies, providing alternative text for images, maintaining color contrast ratios, using ARIA labels and roles, or ensuring all interactive elements are keyboard-navigable. Apply this skill when building frontend components, reviewing UI accessibility, refactoring markup for better semantics, or implementing WCAG compliance requirements.

Design and build reusable, composable UI components following single responsibility principle with clear interfaces and proper state management. Use this skill when creating React components, Vue components, or other framework components, defining component props and interfaces, managing component state, building reusable UI elements, working with component files (*.tsx, *.jsx, *.vue, *.svelte, components/*, ui/*), implementing component composition patterns, encapsulating component logic, documenting component APIs, keeping state local or lifting it up when needed, designing component hierarchies, or refactoring monolithic components into smaller pieces. Apply this skill when building new components, refactoring existing component structures, reviewing component design patterns, or ensuring components are maintainable and reusable.

Write and maintain CSS following project conventions using consistent methodologies like Tailwind CSS, BEM, CSS modules, or utility classes, while creating distinctive, aesthetically excellent designs. Use this skill when writing CSS styles, applying Tailwind utility classes, creating custom CSS, working with styling files (*.css, *.scss, *.module.css, globals.css, tailwind.config.*), maintaining design systems and design tokens, defining CSS variables for colors and spacing, implementing typography styles with unique font choices, creating atmospheric backgrounds and depth, adding animations and micro-interactions, avoiding framework style overrides, avoiding generic "AI slop" aesthetics (purple gradients, Inter/Roboto everywhere, cookie-cutter designs), optimizing CSS for production with purging and tree-shaking, or ensuring consistent styling patterns across the application. Apply this skill when styling components, refactoring CSS code, setting up design systems, choosing fonts and colors, creating animat

Build responsive layouts that adapt seamlessly across devices using mobile-first design, fluid layouts, and standard breakpoints. Use this skill when implementing responsive designs, creating mobile-first layouts, defining breakpoint styles, working with responsive components and pages, using relative units (rem, em) instead of fixed pixels, implementing media queries, ensuring touch-friendly tap targets, optimizing images and assets for different screen sizes, maintaining readable typography across breakpoints, prioritizing content for smaller screens, testing UI across mobile, tablet, and desktop devices, or building fluid container layouts. Apply this skill when building responsive UI components, optimizing layouts for different screen sizes, or reviewing mobile and tablet user experiences.

Write clean, consistent code following established naming conventions, formatting rules, and the DRY principle across all files. Use this skill when writing any code in any file, naming variables and functions, structuring code logic, formatting code with consistent indentation, choosing descriptive names that reveal intent, keeping functions small and focused, removing dead code and unused imports, extracting common logic into reusable functions, maintaining consistent code style across the codebase, configuring linters and formatters, or refactoring code for better readability. Apply this skill universally across all coding tasks to ensure code quality, maintainability, and consistency with project standards. This skill should be active for all file types including TypeScript, JavaScript, Python, Ruby, Java, Go, and other programming languages.

Write self-documenting code with minimal, helpful comments that explain large sections of logic without cluttering the codebase. Use this skill when writing code comments, documenting complex logic, reviewing whether comments are needed, writing function documentation, explaining non-obvious code sections, ensuring code clarity through naming and structure, avoiding temporary or change-related comments, keeping comments evergreen and future-relevant, or deciding between adding comments versus refactoring for clarity. Apply this skill when writing or reviewing any code file to ensure comments add value without creating noise, and that code is primarily self-explanatory through clear naming and structure.

Follow project-wide development conventions for file organization, version control, documentation, and dependency management. Use this skill when organizing project directories and files, writing README documentation, creating commit messages, working with git branches, managing pull requests, configuring environment variables, handling secrets and API keys, managing project dependencies, setting up feature flags, maintaining changelogs, defining testing requirements, establishing code review processes, or structuring the overall project architecture. Apply this skill when setting up new projects, refactoring project structure, working with version control, managing configuration files, or ensuring the project follows consistent organizational patterns and best practices.

Implement robust error handling with user-friendly messages, specific exception types, centralized error boundaries, and graceful degradation strategies. Use this skill when writing try-catch blocks, handling exceptions and errors, creating error messages for users, implementing error boundaries in React or other frameworks, validating input and checking preconditions, handling API errors and external service failures, implementing retry strategies with exponential backoff, cleaning up resources in finally blocks, designing graceful degradation for non-critical failures, or preventing technical details and security information from being exposed to users. Apply this skill when handling errors in any code file, implementing error recovery mechanisms, or reviewing error handling approaches for robustness and security.

Reference and maintain documentation of the project's technical stack including frameworks, languages, databases, testing tools, and third-party services. Use this skill when choosing technologies for implementation, adding new dependencies or libraries, setting up project infrastructure, configuring build tools and package managers, integrating third-party services (authentication, email, monitoring), selecting appropriate frameworks for features, ensuring consistency with existing technology choices, documenting technology decisions, reviewing technology compatibility, or onboarding team members to the tech stack. Apply this skill when making technology decisions, adding new tools or services, documenting the stack, or ensuring new code aligns with the project's established technical architecture.

Implement comprehensive input validation on both client and server sides with clear error messages, type checking, and sanitization to prevent security vulnerabilities. Use this skill when validating user input, implementing form validation, checking data types and formats, sanitizing input to prevent injection attacks (SQL, XSS, command injection), validating business rules, providing field-specific error messages, implementing server-side validation for all entry points (API endpoints, web forms, background jobs), using client-side validation for immediate user feedback, applying allowlists over blocklists, validating ranges and required fields, or ensuring consistent validation across the application. Apply this skill when handling any user input, building forms, creating API endpoints, or reviewing code for security and data integrity.

Write minimal, strategic tests focused on core user flows and critical paths during feature development, deferring comprehensive edge case testing. Use this skill when writing unit tests, integration tests, or end-to-end tests, creating test files (*.test.ts, *.spec.js, __tests__/*), testing critical user workflows, focusing on behavior rather than implementation details, using descriptive test names, mocking external dependencies (databases, APIs, file systems), ensuring tests run quickly, testing business-critical functionality, or determining which tests to write during development versus dedicated testing phases. Apply this skill when completing features at logical milestones, writing tests for primary user flows, or balancing feature development speed with adequate test coverage.