अपने एजेंट के लिए सही क्षमता खोजें।
This skill should be used when the user asks to "detect asyncpg usage", "find asyncpg patterns", "scan for asyncpg imports", or "identify asyncpg database code in FastAPI projects". It automatically scans Python files to identify asyncpg imports, connection patterns, and query execution methods that need conversion to SQLAlchemy.
SQLModel - Pydantic + SQLAlchemy combined. This skill should be used when building FastAPI apps with database, creating ORM models, data validation with database persistence, or any Python project needing both validation and ORM. Triggers on "create database model", "add SQLModel", "database with FastAPI", "ORM model", or any SQLModel-related development.
SQLModel ORM skill for Python database operations combining SQLAlchemy power with Pydantic validation. Use when: (1) Defining database models with type hints, (2) Setting up async database connections, (3) Creating model relationships (one-to-many, many-to-many, one-to-one), (4) Implementing repository pattern, (5) Setting up Alembic migrations, (6) Writing complex queries with joins and aggregations, (7) Creating database seeders, (8) Validating data with Pydantic validators in models.
SQLAlchemy ORM and Alembic migration patterns
Apply DDD tactical patterns (Entities, Value Objects, Aggregates, Domain Services, Repositories) and strategic design (Ubiquitous Language, Bounded Contexts). Use when modeling complex business logic.
Complete guide for creating, publishing, and consuming events in the DeLoNET home network's 33GOD agentic developer pipeline. Built on RabbitMQ with strict type safety via Pydantic, async Python (aio-pika), FastAPI, and Redis-backed correlation tracking. Features modular event architecture with domain-based organization and auto-discovery registry. This skill is REQUIRED for any work involving the home network event bus.
Follow TDD practices with Red-Green-Refactor cycle. Write tests before implementation, use AAA pattern, and ensure high-quality test coverage. Use when implementing features or fixing bugs.
Asynchronous programming patterns for Python, JavaScript/TypeScript, and other languages. Auto-triggers when implementing concurrent code, handling promises, or optimizing I/O operations.
OpenFGA authorization modeling best practices and guidelines. This skill should be used when authoring, reviewing, or refactoring OpenFGA authorization models. Triggers on tasks involving OpenFGA models, relationship definitions, permission structures, .fga files, .fga.yaml test files, or OpenFGA SDK usage in JavaScript, TypeScript, Go, Python, Java, or .NET.
This skill should be used when the user asks about "design patterns", "SOLID principles", "factory pattern", "strategy pattern", "observer pattern", "composition vs inheritance", "Pythonic design", "singleton alternatives", "anti-patterns", "dependency injection", or needs guidance on applying Gang of Four patterns idiomatically in Python.
Universal error handling, exception management, and logging best practices for all development agents across JavaScript/TypeScript, Python, Rust, Go, and Java. Use when implementing error handling, exception management, logging, error recovery, or debugging production issues.
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.
Software design patterns for Python and C++ development. Use when implementing creational patterns (Factory, Builder, Singleton), structural patterns (Adapter, Decorator, Facade), or behavioral patterns (Strategy, Observer, Command). Covers Gang of Four patterns with language-specific implementations, when to use each pattern, and common anti-patterns to avoid.
pytest patterns and best practices
Use when refactoring code or designing flexible systems. Covers creational, structural, and behavioral patterns with Python examples.
Python development principles and decision-making. Framework selection, async patterns, type hints, project structure. Teaches thinking, not copying.
Modern Python coding standards, best practices, testing patterns, and implementation guidelines
Systematic identification of race conditions, concurrency bugs, and thread-safety issues across codebases. Use when asked to find race conditions, audit concurrent code, debug non-deterministic behavior, review thread safety, find data races, or analyze async/parallel code. Supports TypeScript, JavaScript, Python, Go, Rust, C++, Java, and Kotlin.
Domain-Driven Design system for software development. Use when designing new systems with DDD principles, refactoring existing codebases toward DDD, generating code scaffolding (entities, aggregates, repositories, domain events), facilitating Event Storming sessions, creating bounded context maps, or performing code reviews with a DDD lens. Covers both strategic design (bounded contexts, subdomains, context maps, ubiquitous language) and tactical design (entities, value objects, aggregates, domain services, repositories). Supports all major architecture patterns (Hexagonal/Ports & Adapters, CQRS, Event Sourcing, Clean Architecture) with language-agnostic guidance and concrete examples in Python and TypeScript.
Python Protocol-based storage abstraction pattern enabling dependency injection and testable file operations. Use this skill when implementing storage backends, adding file operations to services, or writing tests that need to avoid filesystem side effects. The pattern uses Python's typing.Protocol for structural subtyping, allowing any class with matching methods to satisfy the interface without explicit inheritance.
