error-handling
Enforce proper error handling patterns. Use when writing async code, API calls, or user-facing features. Covers try-catch, error boundaries, graceful degradation, and user feedback.
global-error-handling
Implement robust error handling with user-friendly messages, specific exception types, fail-fast validation, centralized error boundaries, graceful degradation, and proper resource cleanup. Use this skill when writing try-catch blocks, raising exceptions, handling API errors, validating input, implementing error boundaries, managing external service failures, or ensuring resource cleanup. Apply when working with error handling code in any language, exception classes, error middleware, API error responses, retry logic, or any code that needs to handle failures gracefully while maintaining system stability and providing clear feedback to users.
global-tech-stack
Understand and apply project-specific technology choices including frameworks, languages, databases, testing tools, and third-party services to maintain consistency across the stack. Use this skill when making technology decisions, adding new dependencies, choosing libraries/frameworks, configuring build tools, setting up databases, implementing authentication, or integrating third-party services. Apply when working with framework-specific code, package managers, ORM configurations, testing setups, deployment configurations, or any task that requires knowledge of the project's chosen technologies to ensure architectural consistency and avoid introducing conflicting tools or patterns.
architecture-synthesis
Generate a reference architecture specification from analyzed frameworks. Use when (1) designing a new agent framework based on prior art, (2) defining core primitives (Message, State, Tool types), (3) specifying interface protocols, (4) creating execution loop pseudocode, or (5) producing architecture diagrams and implementation roadmaps.
architecture-documenter
Document system architecture and technical design decisions for effective team communication and ...
resilience-analysis
Assess error handling, isolation boundaries, and recovery mechanisms in agent frameworks. Use when (1) tracing error propagation paths, (2) evaluating sandboxing for code execution, (3) understanding retry and fallback mechanisms, (4) assessing production readiness, or (5) identifying failure modes and recovery patterns.
p2p-networking
Peer-to-peer networking patterns using commonware for building decentralized Guts network
team-collaboration
Working effectively with others in coding projects – including code reviews, clear communication, and contributing to shared or open-source codebases.
code-readability
Writing clean, understandable, and self-documenting code that is easy to review and maintain over time.
documentation
Communicating the intended behavior and context of code through clear documentation and comments, and sharing knowledge with the team.
code-refactoring
The practice of restructuring and simplifying code continuously – reducing complexity, improving design, and keeping codebases clean.
secure-coding
Incorporating security at every step of software development – writing code that defends against vulnerabilities and protects user data.
coding-principles
Language-agnostic coding principles for maintainability, readability, and quality. Use when implementing features, refactoring code, or reviewing code quality.
logging-patterns
Common logging patterns and practices. This skill is designed to be included in composite skills via the 'includes' feature.
overthrow-architecture
Overthrow mod architecture patterns, naming conventions, and project structure
error-handling-base
Foundation for error handling patterns. This is a base skill designed to be extended by language-specific error handling skills.
complete-rust-development
A comprehensive skill for Rust development that combines error handling, testing, and logging patterns. Demonstrates the 'includes' composition feature by merging content from multiple standalone skills.
rust-error-handling
Rust-specific error handling patterns, building on the base error handling skill. Demonstrates the 'extends' composition feature.
enforcescript-patterns
EnforceScript component patterns, networking, persistence, and memory management for Enfusion engine
testing-patterns
Common testing patterns and practices. This skill is designed to be included in composite skills via the 'includes' feature.
go-practices
Go conventions for hexagonal architecture, project structure, error handling, testing, and observability. Use when writing Go services.
