Skill UI

This comprehensive guide covers structured concurrency patterns in Go, focusing on goroutines, channels, mutexes, and various sync primitives. It provides principles for writing, reviewing, and auditing concurrent code to ensure leak-freedom, correct ownership management, and robust error handling, covering topics like context propagation and race condition avoidance.

A comprehensive guide for advanced Go developers, detailing the internals, optimal usage, and performance pitfalls of core data structures like slices, maps, and arrays. It covers capacity growth mechanics, preallocation strategies using `make` and `slices` package functions, and best practices for choosing between various standard library containers (e.g., `strings.Builder` vs `bytes.Buffer`). Essential for writing highly efficient, memory-safe Go code.

A comprehensive guide for writing robust, idiomatic, and production-ready error handling in Go. This skill covers best practices for error creation, wrapping (using %w), inspection (errors.Is/As), combining errors (errors.Join), and structured logging with slog. It promotes reliable code by enforcing principles like the single handling rule and contextual logging, crucial for building scalable applications.

This skill provides comprehensive observability tooling for Go services, covering the five essential signals: structured logging (slog), Prometheus metrics, OpenTelemetry tracing, continuous profiling, and RUM. Use it for proactive production monitoring, correlating logs with traces, setting up SLOs, and ensuring all new features are fully instrumented for robust diagnosis.

Improves Go error handling by treating errors as structured data. This utility adds critical context—such as domain, user IDs, stack traces, and machine-readable error codes—to standard Go errors. This capability is vital for enhancing observability, enabling APM tools (like Sentry or Datadog) and on-call engineers to diagnose complex issues quickly without relying on manual log correlation.

A comprehensive collection of composable handlers and middlewares for Go's standard slog package. This skill enables developers to build robust, multi-stage logging pipelines by implementing critical steps like log sampling (throughput control), attribute formatting (PII stripping), advanced routing, and sinking logs to various professional backends (e.g., Sentry, Loki, Datadog). Ideal for production-grade services requiring high observability.

Provides a minimal skill definition that only includes the required fields, showing how to structure SKILL.md for quick testing or deployment of basic examples.

This skill provides comprehensive functionality for reading, creating, editing, and downloading content from Lark Feishu Docs (Docx/Wiki). Whether accessing via URL or token, it supports structured content manipulation using both XML and Markdown formats (v2 API). Use it for fetching document details, updating specific blocks, and managing embedded media and resources like whiteboards and images. Note that it requires prerequisite knowledge for advanced operations.

A powerful tool for managing whiteboard content embedded in Lark cloud documents. It allows users to query the board, exporting content as a preview image, retrieving raw node structures, or updating the board using various formats (Mermaid, PlantUML). Ideal for generating, viewing, or modifying complex diagrams like architecture diagrams and flowcharts.

Example skill that walks through the Anthropic SKILL.md structure, showcasing when to load it, how to author steps, and how to reference bundled resources for skill creation.

This guide details how to systematically decompose large specifications or features into small, manageable, and verifiable tasks. It outlines best practices for vertical slicing, mapping component dependencies, and defining clear acceptance criteria. Use this process to ensure complex development work is broken down into reliably executable steps, suitable for agents or teams.

This CLI alias implements the PUA Loop protocol, designed for running structured, iterative verification cycles. It helps developers set up and manage complex coding tasks that require explicit verification commands and defined stop conditions. It serves as a powerful wrapper for AI coding assistants like Codex/Claude, ensuring robust and traceable development workflows.