Skill Creator
maksimtereshin
15 published skills · 0 GitHub stars across the catalog. View on GitHub ↗
testing-test-writing
Write minimal, focused tests following KISS and YAGNI principles - test only core user flows during development, defer edge case testing, test behavior not implementation, use clear test names, mock external dependencies, and ensure fast test execution. Use this skill when creating test files, writing unit tests, integration tests, or component tests. Use when working with test frameworks (Jest, Vitest, pytest, RSpec, JUnit, Mocha), when deciding what to test and when, when writing test cases for critical paths and primary workflows, when mocking external services or databases, or when ensuring tests run quickly for developer productivity. Apply when creating test files (.test.ts, .spec.ts, test_*.py, *_test.go) or when implementing behavior-driven test cases.
global-conventions
Follow project-wide development conventions including consistent project structure, clear documentation, version control best practices, environment configuration, dependency management, code review processes, and modular architecture following Open/Closed Principle. Use this skill when organizing project files and directories, writing README files, creating commit messages, managing dependencies, setting up environment variables, implementing feature flags, or designing modular system boundaries. Use when working with configuration files (.env, package.json, requirements.txt, Cargo.toml), documentation files (README.md, CONTRIBUTING.md), version control operations, or architectural decisions about how to structure and organize code across the entire project.
frontend-components
Design and build reusable, composable UI components following Single Responsibility Principle with clear prop interfaces, minimal state, and proper encapsulation. Use this skill when creating or modifying React components, Vue components, Angular components, Svelte components, or Web Components. Use when working with component files (.tsx, .jsx, .vue, .svelte, .component.ts) in component directories. Use when designing component APIs with props and prop types, implementing component composition patterns, managing local component state, or creating reusable design system components. Use when refactoring large components into smaller focused ones, defining component documentation and usage examples, or building component libraries.
global-error-handling
Implement robust error handling with user-friendly messages, specific exception types (ISP), centralized error boundaries (SRP), fail-fast validation (KISS), graceful degradation, retry strategies, and proper resource cleanup. Use this skill when adding try-catch blocks, throwing or catching exceptions, creating error classes, implementing error boundaries or middleware, displaying error messages to users, or handling async errors and promise rejections. Use when working with error handling in any language (.ts, .js, .py, .java, .go) across backend services, API endpoints, frontend components, or data processing pipelines. Use when implementing exponential backoff for external service calls or ensuring resources are cleaned up in finally blocks.
global-commenting
Write self-documenting code with clear structure and naming, using minimal but helpful comments only when necessary to explain complex logic. Use this skill across all code files when deciding whether to add comments or how to structure code for clarity. Use when refactoring code to be more self-explanatory, when removing outdated or temporary comments, when writing evergreen informational comments that remain relevant over time, or when choosing between adding a comment versus improving variable/function names. Apply when working with any programming language (.ts, .js, .py, .java, .go, .tsx, .jsx, .vue) to maintain clean, understandable code without over-commenting.
frontend-responsive
Implement mobile-first responsive layouts using fluid containers, media queries, standard breakpoints, relative units (rem/em), and touch-friendly design patterns. Use this skill when creating layouts that adapt across mobile, tablet, and desktop screens. Use when writing media queries or breakpoint-specific styles, implementing fluid grid systems, designing touch targets for mobile devices, or optimizing images and assets for different screen sizes. Use when working with responsive CSS frameworks (Tailwind responsive utilities, Bootstrap grid, CSS Grid, Flexbox), when testing layouts across multiple viewports, or when ensuring readable typography and content priority on smaller screens. Use when implementing mobile navigation patterns or adaptive UI components.
global-coding-style
Follow core coding style principles including SOLID, DRY, KISS, and YAGNI when writing code. Apply consistent naming conventions, meaningful variable names, small focused functions, automated formatting, and proper code organization. Use this skill across all programming languages and file types when writing or refactoring code. Use when creating functions, classes, modules, or components to ensure Single Responsibility Principle, when avoiding code duplication (DRY), when choosing simple over clever implementations (KISS), or when resisting premature optimization and speculative features (YAGNI). Use when establishing naming conventions, removing dead code, or maintaining consistent indentation and formatting. Apply these principles universally across backend (.ts, .js, .py, .java, .go), frontend (.tsx, .jsx, .vue), and configuration files.
global-tech-stack
Reference and maintain project technology stack documentation including frameworks, languages, databases, testing tools, deployment infrastructure, and third-party services. Use this skill when needing to understand what technologies and frameworks are used in the project, when making architectural decisions about adding new dependencies, when documenting the tech stack for team members, or when ensuring consistency across technology choices. Use when working with configuration files (package.json, requirements.txt, Gemfile, Cargo.toml), when setting up new services or integrations, when choosing between multiple library options, or when onboarding new developers who need to understand the project's technical foundation. Reference this when making decisions about ORM choices, testing frameworks, CSS frameworks, frontend libraries, or deployment platforms.
backend-api
Design and implement RESTful API endpoints following REST principles with proper HTTP methods, status codes, and resource-based URL patterns. Use this skill when creating or modifying API route handlers, controllers, or endpoint definitions in backend frameworks (Express, NestJS, FastAPI, Django REST Framework, etc.). Use when working with API versioning strategies, implementing rate limiting, designing nested resource endpoints, or defining query parameter filtering and pagination. Use when writing files like routes.ts, controllers.ts, api.py, views.py, or any backend files that define HTTP endpoints and handle API requests/responses.
backend-queries
Write optimized and secure database queries using parameterized queries, eager loading, strategic indexing, and proper transaction management. Use this skill when writing database queries, repository methods, or data fetching logic that interacts with SQL or NoSQL databases. Use when implementing query builders, ORM query methods, raw SQL queries, or database service functions. Use when working with files containing database access code (repositories.ts, services.ts, queries.py, dao.java), when optimizing N+1 query problems, implementing query caching strategies, or writing queries with JOINs and WHERE clauses. Use when preventing SQL injection vulnerabilities, setting up query timeouts, or wrapping related operations in database transactions.
backend-models
Define and structure database models and entities with proper naming conventions, timestamps, data integrity constraints, relationships, and validation layers. Use this skill when creating or modifying ORM model definitions, database entity classes, schema definitions, or data access layer objects. Use when working with TypeORM entities, Sequelize models, SQLAlchemy models, Mongoose schemas, Django models, Prisma schema files, or any framework-specific model files (models.ts, entities.py, schema.prisma, models.py). Use when defining table structures, foreign key relationships, database constraints (NOT NULL, UNIQUE), indexes, or multi-layer validation rules. Use when implementing repository patterns or designing data models that balance normalization with query performance.
backend-migrations
Create and manage database migrations with reversible up/down methods, zero-downtime deployment strategies, and proper schema versioning. Use this skill when creating database migration files, altering table schemas, adding or modifying database indexes, or implementing data migrations. Use when working with migration tools like TypeORM migrations, Sequelize migrations, Alembic (Python), Rails migrations, Flyway, or Liquibase. Use when writing migration files (e.g., YYYYMMDDHHMMSS_migration_name.ts, 001_create_table.sql, versions/*.py) or when modifying database schema in a version-controlled manner. Use when handling backwards compatibility for high-availability deployments or when separating schema changes from data migrations.
global-validation
Implement comprehensive input validation with server-side validation (security), client-side validation (UX), fail-early patterns (KISS), specific error messages, allowlists over blocklists, and reusable validators (DRY). Use this skill when validating user input in forms, API endpoints, or data processing functions. Use when implementing validation rules for data types, formats, ranges, required fields, or business rules (SRP). Use when creating validator functions, validation schemas (Zod, Joi, Yup), form validation logic, or input sanitization to prevent injection attacks (SQL, XSS). Use when working with backend validators, frontend form libraries (React Hook Form, Formik), or consistent validation across web forms, API endpoints, and background jobs. Apply validation at multiple layers for defense in depth.
frontend-accessibility
Build accessible user interfaces using semantic HTML, proper ARIA attributes, keyboard navigation support, sufficient color contrast, and screen reader compatibility. Use this skill when creating or modifying UI components, forms, navigation elements, modals, or any interactive frontend elements. Use when working with React components, Vue components, Angular templates, or vanilla HTML/JSX files (.tsx, .jsx, .vue, .html). Use when implementing keyboard navigation, focus management, form labels and inputs, image alt text, heading hierarchies, or ARIA roles and properties. Use when ensuring WCAG compliance, testing with screen readers, or creating accessible dynamic content and single-page applications. Use when adding color contrast requirements or visible focus indicators to interactive elements.
frontend-css
Write and structure CSS using consistent methodology (Tailwind, BEM, CSS Modules, styled-components), maintain design system tokens, minimize custom CSS, and optimize performance. Use this skill when writing or modifying stylesheets, CSS files, or styled components. Use when working with .css, .scss, .sass, .module.css files, Tailwind utility classes, CSS-in-JS libraries (styled-components, emotion, JSS), or component styling. Use when establishing design tokens for colors, spacing, and typography, when avoiding framework style overrides, when implementing CSS purging or tree-shaking for production, or when maintaining consistent styling methodology across the project. Use when working with global styles, component-scoped styles, or utility class systems.