← all publishers

overtimepog

@overtimepog source repo

Report this profile Claim this profile

• 13 skills
• 0 followers
• 1 week ago last updated

1. ▌
   Backend Models · overtimepog

   Define database models, schemas, and ORM mappings with proper relationships, constraints, and data integrity rules. Use this skill when creating or modifying ORM model classes, database schema definitions, model relationships, validators, or working with files like models.py, schema.prisma, entity classes, or Sequelize/TypeORM/ActiveRecord model definitions. Apply this skill when defining primary keys, foreign keys, indexes, unique constraints, timestamps, or when implementing model validation logic, serializers, and data type mappings. This skill ensures models follow naming conventions, include appropriate database constraints, define clear relationships with cascade behaviors, balance normalization with performance needs, and maintain data integrity at both the model and database levels.
   0 installs
2. ▌
   Backend Queries · overtimepog

   Write efficient, secure database queries using ORMs or raw SQL, preventing N+1 problems, SQL injection, and performance issues. Use this skill when writing database queries, implementing data access layers, creating repository patterns, or optimizing query performance in service files, query builders, or data access objects. Apply this skill when using parameterized queries, implementing eager loading to avoid N+1 queries, selecting only needed columns, adding WHERE/JOIN/ORDER BY clauses, or working with query optimization, indexes, and database performance tuning. This skill ensures queries use proper SQL injection prevention, implement transactions for data consistency, cache expensive queries appropriately, and follow best practices for query timeouts, connection pooling, and database resource management.
   0 installs
3. ▌
   Global Commenting · overtimepog

   Write self-documenting code with minimal, evergreen comments that explain WHY rather than WHAT, avoiding temporary change notes or obvious descriptions. Use this skill when adding comments to any code file to ensure comments provide value by explaining complex logic, business rules, or non-obvious decisions rather than describing what the code does. Apply this skill when writing code that needs clarification, when documenting complex algorithms or business logic, or when removing outdated or redundant comments that describe obvious operations. This skill prioritizes writing clear, expressive code through meaningful naming and structure that minimizes the need for comments, ensures any comments added are helpful and explain intent or reasoning, and avoids leaving comments about recent changes, temporary fixes, or information that belongs in commit messages or documentation.
   0 installs
4. ▌
   Global Tech Stack · overtimepog

   Reference and maintain the project's technology stack including frameworks, languages, databases, testing tools, and third-party services to ensure consistency across the codebase. Use this skill when making technology decisions, adding new dependencies, choosing appropriate tools or libraries, configuring build systems, setting up testing frameworks, or documenting the tech stack. Apply this skill when selecting which framework, library, or tool to use for a given task, when ensuring code follows the conventions of the chosen stack (React patterns, Python idioms, Rails conventions), when integrating third-party services, or when documenting technology choices in README or architecture documentation. This skill ensures all team members use consistent technologies, new additions align with existing stack decisions, technology choices are documented with rationale, and the project maintains coherent patterns rather than mixing conflicting approaches or frameworks.
   0 installs
5. ▌
   Backend Migrations · overtimepog

   Create and manage database migrations for schema changes, ensuring zero-downtime deployments and data integrity. Use this skill when creating migration files, modifying database schemas, adding or altering tables/columns/indexes, or working with migration tools like Alembic, Flyway, Liquibase, or framework-specific migration systems (Django migrations, Rails migrations, Prisma migrations). Apply this skill when implementing reversible migrations with up/down methods, handling data migrations separately from schema changes, creating indexes on large tables, or planning backwards-compatible schema changes for high-availability systems. This skill ensures migrations are version-controlled, focused, safe to rollback, and compatible with CI/CD pipelines and zero-downtime deployment strategies.
   0 installs
6. ▌
   Global Conventions · overtimepog

   Follow project-wide development conventions including project structure, documentation standards, version control practices, environment configuration, and dependency management. Use this skill when organizing files and directories, writing README documentation, creating commit messages, managing environment variables, updating dependencies, or establishing code review processes. Apply this skill when ensuring consistent project structure (src/, components/, utils/, tests/), maintaining up-to-date documentation, using clear commit messages and feature branches, properly configuring environment variables without committing secrets, keeping dependencies minimal and documented, and implementing feature flags for incomplete work. This skill ensures the entire team follows predictable patterns for project organization, maintains comprehensive documentation for setup and architecture, practices good version control hygiene, manages configuration securely, and establishes clear workflows for testing and code review.
   0 installs
7. ▌
   Frontend Components · overtimepog

   Design and build reusable, maintainable UI components following modern architecture patterns for React, Vue, or other frameworks. Use this skill when creating component files (.jsx, .tsx, .vue), implementing component logic, managing component state, defining props interfaces, or organizing component hierarchies in directories like components/, views/, or pages/. Apply this skill when building functional components with hooks (React), composition API components (Vue), single-file components, implementing component composition patterns, managing local vs. lifted state, or creating custom hooks for shared logic. This skill ensures components follow single responsibility principle, are properly encapsulated, have clear prop interfaces with TypeScript types, support reusability across contexts, and follow modern patterns like atomic design, container/presentational separation, and compound components.
   0 installs
8. ▌
   Frontend Responsive · overtimepog

   Create responsive, mobile-first user interfaces that adapt seamlessly across all device sizes using modern CSS techniques and responsive design patterns. Use this skill when implementing layouts, breakpoints, fluid typography, responsive images, or any UI that needs to work across mobile, tablet, and desktop viewports. Apply this skill when using CSS media queries, container queries, responsive utility classes (Tailwind's sm:, md:, lg:), flexible grid/flexbox layouts, relative units (rem, em, vw, vh), or when optimizing touch interactions for mobile devices. This skill ensures mobile-first development approach, consistent breakpoint usage, proper viewport configuration, touch-friendly target sizes (44x44px minimum), readable typography across all screen sizes, and optimized performance on mobile networks with responsive images and lazy loading.
   0 installs
9. ▌
   Global Coding Style · overtimepog

   Maintain consistent coding style, formatting, and naming conventions across the entire codebase following DRY and YAGNI principles. Use this skill when writing or refactoring any code in any language or framework to ensure consistent indentation, naming patterns, function size, and code organization. Apply this skill when naming variables, functions, classes, or files, when formatting code with proper spacing and line breaks, when removing dead code or unused imports, when extracting duplicated logic into reusable functions, or when ensuring small focused functions that do one thing well. This skill ensures the entire codebase maintains uniform style through automated formatting tools (Prettier, Black, ESLint), follows established naming conventions (camelCase, PascalCase, snake_case), avoids code duplication, removes commented-out code, and prioritizes readability and maintainability over cleverness.
   0 installs
10. ▌
    Testing Test Writing · overtimepog

    Write strategic, focused tests for critical user flows and core functionality using modern testing frameworks, focusing on behavior over implementation. Use this skill when creating test files, writing unit tests, integration tests, or end-to-end tests in test directories (tests/, __tests__, spec/, *.test.js, *.spec.py). Apply this skill when testing core user workflows and business-critical features, implementing test-driven development (TDD) with red-green-refactor cycles, mocking external dependencies for isolated unit tests, using clear descriptive test names that explain expected behavior, following arrange-act-assert patterns, and ensuring tests run fast and independently. This skill prioritizes testing what matters most (primary user flows) while deferring edge cases and non-critical paths until later, emphasizes behavior testing over implementation details to reduce brittleness, and uses modern frameworks like Jest, Playwright, Cypress, pytest, RSpec, or Testing Library for reliable, maintainable test
    0 installs
11. ▌
    Global Error Handling · overtimepog

    Implement robust error handling with user-friendly messages, fail-fast validation, specific exception types, and proper resource cleanup across the application. Use this skill when writing try-catch blocks, throwing or catching exceptions, implementing error boundaries, handling API errors, or managing error states in any part of the codebase. Apply this skill when validating inputs early (fail fast), providing clear actionable error messages to users without exposing security details, using specific exception types rather than generic errors, implementing centralized error handling at appropriate boundaries, designing for graceful degradation, implementing retry logic with exponential backoff, or ensuring resources are cleaned up in finally blocks. This skill ensures errors are caught and handled appropriately, user experience remains positive even when errors occur, security is maintained by not leaking sensitive information, and systems continue operating or degrade gracefully when non-critical services fa
    0 installs
12. ▌
    Frontend Accessibility · overtimepog

    Build accessible user interfaces following WCAG 2.2 standards with proper semantic HTML, ARIA attributes, keyboard navigation, and screen reader support. Use this skill when creating or modifying UI components, forms, interactive elements, navigation menus, modals, or any frontend code that users interact with. Apply this skill when implementing keyboard navigation, focus management, color contrast requirements, alternative text for images, form labels, ARIA roles and landmarks, or when ensuring components work with assistive technologies like screen readers. This skill is essential when working with React, Vue, or other framework components, HTML templates, JSX files, or any UI implementation to ensure inclusive design that serves users with visual, auditory, motor, or cognitive disabilities and meets legal compliance standards (ADA, WCAG 2.2 Level AA).
    0 installs
13. ▌
    XLSX · overtimepog bundle

    Spreadsheet toolkit (.xlsx/.csv). Create/edit with formulas/formatting, analyze data, visualization, recalculate formulas, for spreadsheet processing and analysis.
    0 installs