Find the perfect capability for your agent.
Unified enterprise programming language skill covering 25+ languages including Python 3.13, TypeScript 5.9, Go 1.23, Rust 1.91, Java 21, JavaScript ES2025, C++, C#, PHP, Swift, Kotlin, Scala, Elixir, Ruby, R, SQL, Shell, and more with patterns, best practices, and Context7 integration
Advanced FastAPI patterns including hierarchical dependency injection, background task management, and type-safe dependency annotation. Triggers: fastapi, dependency-injection, background-tasks, annotated-dependency, permission-chain.
Create detailed implementation strategies and architecture documentation
Bootstrap, maintain, and evolve context networks across their full lifecycle. Use when starting a new project, when existing documentation feels scattered, or when agent effectiveness degrades due to missing context.
Observability patterns including logging, metrics, tracing, and alerting. Auto-triggers when implementing monitoring, debugging production issues, or setting up alerts.
Provides expert observability analysis, logging review, and monitoring assessment. Use this skill when the user needs logging audit, error tracking evaluation, APM review, or monitoring strategy assessment. Triggers include requests for observability audit, logging patterns review, or when asked to evaluate system visibility and debugging capabilities. Produces detailed consultant-style reports with findings and prioritized recommendations — does NOT write implementation code.
Use this skill when implementing domain entities and their properties in .NET.
Orchestrate complete or partial feature implementation workflow with configurable phases. This skill should be used to run the full workflow (specification → research → plan → implement → test → fix) or specific phases, coordinating between all feature-implementation skills automatically.
Resiliency Engineering, Failure Domains, and Structured Logging
Refactor IC10 code for clarity and structure. Use when user wants to reorganize code, apply design patterns, improve naming, or make code more maintainable without changing functionality.
Implement robust error handling with user-friendly messages, specific exception types, centralized error handling, graceful degradation, and proper resource cleanup. Use this skill when implementing try-catch blocks, error boundaries, exception handling, or error recovery logic. When working with API error responses, validation errors, or external service failures. When adding error logging, retry strategies, or fallback mechanisms. This skill applies to all code files that handle errors, exceptions, or failure scenarios in any programming language including `.js`, `.ts`, `.py`, `.rb`, `.java`, `.go`, `.php`, and others.
Code review agent based on Sandi Metz's object-oriented design principles from "Practical Object-Oriented Design in Ruby" and "99 Bottles of OOP". Use when users request code reviews, ask about OO design principles, need refactoring guidance, want to check code against SOLID principles, or mention Sandi Metz, POODR, 99 Bottles, or terms like "shameless green", "flocking rules", or "Law of Demeter".
Structured approach to deprecating features, APIs, and systems with clear timelines and migration paths.
Senior principal engineer for Raamattu Nyt codebase. Use when: (1) Implementing features with architectural implications (Cinema Reader, search UX, audio) (2) Refactoring prototypes into production-grade components (3) Reviewing PRs for architecture, UX, and cinema constraints (4) Designing typed APIs that age well (5) Deciding what NOT to build yet (6) Challenging abstractions or spotting future maintenance issues Triggers: "code review", "architecture decision", "should this be", "is this portable", "design review", "principal review", "future-proof"
Apply object-oriented design principles (SOLID/GRASP) when writing or reviewing code in this TypeScript + Next.js codebase. Use when designing/refactoring services, libraries, domain models, and module boundaries; triggers on high coupling, low cohesion, duplicated business rules, and unclear responsibilities.
Automated content discovery workflow for scanning multiple data sources (ArXiv, GitHub, HuggingFace), applying AI-powered semantic filtering and deduplication, analyzing content quality, downloading images, and publishing to multiple channels (Hexo blog, Telegram, Discord). Use this skill when: - Executing /discover command with task configurations - Scanning academic papers from ArXiv (via MCP or WebSearch) - Finding GitHub repositories or HuggingFace models - Applying semantic AI filtering to avoid duplicate content - Generating high-quality Chinese summaries and insights - Publishing structured content with metadata tracking This skill handles the complete end-to-end discovery pipeline including data source detection, content filtering, quality validation, image extraction, and multi-channel publishing.
Guide for implementing DDD Aggregate Roots with rich domain models, validation, domain events, and exhaustive tests. Use when creating or modifying aggregates.
Orchestrator skill for realizing approved Architecture Decision Records (ADR). Representative use cases include (1) Decomposing approved ADRs into specific diagramming tasks (Issues) for visualization, (2) Managing the integration of distributed drafting results into a cohesive architectural map, and (3) Preparing the finalized architectural state as a prerequisite for detailed specification (spec-creation).
Error handling patterns for this project. Uses neverthrow for new code, custom Result type for legacy. Includes retry logic, parallel execution, and circuit breaker integration. Triggers on "error handling", "Result type", "neverthrow", "ok", "err", "retry".
Tier 0 decision principles - load always. Defines how we think and decide.
