Yanko Belov

This skill helps you apply the single-responsibility principle by guiding you to split classes and modules, reducing change coupling and maintenance.

This skill helps you apply the Dependency Inversion Principle in TypeScript by promoting interface-based design and injecting dependencies instead of

This skill helps you design focused interfaces by applying the Interface Segregation Principle, avoiding throw and no-op methods and promoting cohesive,

This skill helps you resist feature bloat by enforcing YAGNI principles, guiding minimal viable implementations until requirements actually demand change.

This skill helps you apply the Liskov Substitution Principle by avoiding broken inheritance and favoring interfaces and composition for reliable subclassing.

This skill helps you apply the Open/Closed Principle by guiding you to add new behavior via extensions rather than modifying existing code.

This skill helps you identify and extract duplicate logic to enforce a single source of truth across codebases, reducing bugs and maintenance.

This skill helps you replace overengineered solutions with simple, clear code that works and ships faster.

This skill enforces encapsulation in TypeScript by guiding you to hide internal state and expose behavior through validated methods.

This skill tracks every code-craft application to build a practice record and support analytics across sessions.

This skill helps you write safer TypeScript code by avoiding deep property access and encouraging explicit data access patterns.

This skill helps you place error handling at architectural boundaries, enabling graceful degradation and preventing cascading failures.

This skill enforces immutable patterns by returning new objects for updates, preventing bugs and improving React state predictability.

This skill helps you prevent N+1 queries by enforcing eager loading and providing patterns to fetch related data in a single query.

This skill helps you enforce test isolation by guiding you to create independent tests, avoid shared state, and run reliably.

This skill helps you design RESTful endpoints by enforcing correct HTTP methods, avoiding verbs in URLs, and promoting semantic, cache-friendly APIs.

This skill helps you replace inheritance with composition by guiding you to assemble behaviors via interfaces and injectables for flexible class design.

This skill helps you implement lazy loading to load data on demand, improving initial load times and perceived performance.

This skill helps you identify and remediate race conditions by applying atomic, transactional, and locking patterns across code paths.

This skill helps you implement safe, structured API error responses that avoid leaks and improve client understanding.

This skill enforces clear arrange-act-assert test structure by guiding you to separate phases for readability and maintainability.

This skill helps you design precise exception hierarchies in TypeScript, enabling targeted catch blocks and safer error handling across layers.

This skill promotes fail-fast error handling in TypeScript by throwing at the source and surfacing clear errors to boundaries.

This skill helps you implement idempotency for critical mutations using idempotency keys to prevent duplicates and ensure safe retries.

This skill guides you to never hardcode secrets, enforcing environment variables and startup validation to prevent leaks and secure credentials.

This skill helps prevent deadlocks by enforcing consistent lock ordering and timeouts across services, ensuring operations complete reliably.

This skill helps you implement caching with robust invalidation strategies to boost performance while ensuring data freshness.

This skill helps you design and evolve APIs safely by enforcing versioning, deprecation, and non-breaking changes across clients.