Complex backend systems need strong architectural foundations. This skill provides expert guidance on hexagonal architecture, domain-driven design, SOLID principles, and code quality to help you build maintainable and scalable applications.

Working with GitHub issues and PRs without full context leads to misunderstandings and missed information. This skill teaches AI to proactively use GitHub CLI commands to retrieve PR descriptions, review comments, CI status, issue discussions, and repository information.

Writing tests after code leads to untested behavior and design problems. This skill provides a strict TDD workflow that drives better code design through the Red-Green-Refactor cycle.

Code becomes difficult to maintain when classes have multiple responsibilities and tight coupling. This skill provides clear explanations and examples of SOLID principles so you can design software that is easier to extend, test, and modify.

Code is read far more often than it is written. This skill helps you write code that humans can understand. It provides proven principles for naming, functions, comments, and error handling that improve code readability and maintainability.

APIs often suffer from inconsistent naming, poor URL structure, and incorrect HTTP method usage. This skill provides clear guidelines for designing APIs that are intuitive, scalable, and easy to maintain.

The Scoop news platform has a cluttered frontend with excessive vertical space and inconsistent design patterns. This skill provides a structured workflow to compress layouts, improve density, add snap-scroll navigation, and enforce a clean no-emoji policy across the entire frontend.

Setting up new projects takes too long. Genesis scaffolds React, Python, Go, and Taro projects with production-ready templates in under a minute. Templates include modern tech stacks, best practices, and full documentation.

TypeScript applications often lack proper input validation, leading to runtime errors and security vulnerabilities. This skill provides comprehensive Zod validation patterns to validate API requests, form data, and user inputs with type-safe schemas.

Writing TypeScript without strict mode leads to runtime errors and maintainability issues. This skill provides comprehensive patterns for explicit typing, type guards, and error handling so AI assistants generate production-ready TypeScript code from the first line.

TypeScript projects often suffer from implicit any types and loose error handling. This skill provides clear rules and examples for writing type-safe, production-ready TypeScript code that prevents runtime errors.

Writing tests after code leads to gaps in test coverage and fragile tests. This skill guides the TDD cycle with clear phases: Red (write failing tests), Green (minimal implementation), and Refactor (improve code while tests stay green).

Managing server state and client state in React applications creates complexity that slows development and hurts user experience. This skill provides proven patterns for separating server state from client state using TanStack Query for data fetching and Zustand for UI state.

Finding code by exact text match misses related concepts and requires reading many files. This skill uses Serena MCP semantic search to find code by meaning, reducing token usage by 93 percent while finding more relevant results across your codebase.

Applications need efficient caching and abuse prevention but lack clear patterns for implementation. This skill provides production-ready Upstash Redis patterns for caching, rate limiting, session storage, and pub/sub messaging.

Writing React 19 components requires understanding Server vs Client patterns, new hooks, and Suspense boundaries. This skill provides comprehensive guides and a validation tool to ensure correct React 19 usage with TypeScript.

Inconsistent coding standards create technical debt, security vulnerabilities, and maintenance challenges. This skill enforces TDD workflow, TypeScript strict mode, Next.js App Router patterns, and ShadCN UI components for every new feature in Quetrex.

Software projects need systematic quality checkpoints to prevent bugs and security issues from reaching production. This skill provides a complete framework with automated validation scripts that run TypeScript, security, testing, and pattern checks at each development stage.

Next.js 15 introduces new patterns that are easy to get wrong. This skill provides comprehensive guidance on App Router, Server Components, Server Actions, and caching strategies so agents build correctly the first time.

Teams struggle with inconsistent branches and commits. This skill enforces naming conventions, worktree isolation, and conventional commits for clean history.