Skill UI

A comprehensive guide to structuring robust Flutter applications using industry-standard layered architecture (UI, Domain, Data). It details patterns like MVVM, Repository pattern, and Use Cases, ensuring clean separation of concerns, manageable state flow (unidirectional data flow), and testability. Ideal for scaffolding new, large-scale projects or refactoring legacy codebases.

Guides using ChangeNotifier with provider for Flutter state management, covering model creation, providing to the widget tree, consuming via Consumer and Provider.of, optimization practices, and testing notifications.

Diagnoses and explains fixes for Flutter runtime and layout errors such as RenderFlex overflow, unbounded constraints, scroll-controller conflicts, and inappropriate setState calls during build, helping developers resolve issues quickly.

Enforces full, unabridged code and document generation by overriding LLM truncation safeguards, forbidding placeholder patterns, and managing token-limit splits so every requested deliverable is returned complete.

Guides multi-round investigation of any GitHub repository, combining API queries, discovery searches, and deep dives to produce structured markdown reports with summaries, timelines, metrics tables, and Mermaid diagrams for executive-ready briefs.

This skill provides a comprehensive framework for measuring Go application performance. It guides users through writing robust benchmarks using `testing.B`, running tests with various flags (`-benchmem`, `-cpuprofile`), interpreting complex profiling data (pprof), statistically comparing results using tools like `benchstat`, and setting up CI regression detection. It is essential for deep performance analysis and making statistically sound optimization decisions.

A comprehensive guide for writing, reviewing, and auditing concurrent Go code. It covers core principles of structured concurrency, including proper resource management for goroutines, safe use of channels, mutexes, and advanced synchronization primitives like errgroup and singleflight. Essential for avoiding common issues like goroutine leaks, race conditions, and context propagation failures.

Provides comprehensive guidelines on using Go's `context.Context` for managing request lifecycles. Learn how to correctly propagate cancellation signals, enforce deadlines, handle timeouts, and safely pass request-scoped values across API boundaries (HTTP handlers, services, databases). Essential reading for writing resilient and robust concurrent Go applications.

Comprehensive guide to Go's built-in and standard library data structures, including slices, maps, and arrays. Deep dives into memory allocation, capacity growth mechanics, and best practices for optimization. Learn when to use `strings.Builder`, preallocation techniques, `container/heap`, and managing pointers safely with `unsafe.Pointer` and `weak.Pointer`. Ideal for optimizing performance-critical Go code.

This comprehensive guide covers Dependency Injection (DI) patterns specifically for Golang. It explains why DI is crucial for building testable, loosely coupled, and maintainable services. The skill compares manual constructor injection for small projects with advanced DI libraries (like google/wire, uber-go/dig) for complex architectures, focusing on best practices such as interface-based design and managing service lifecycles.

A comprehensive guide to implementing robust, idiomatic error handling in Go. It covers best practices for error creation, context wrapping using `%w`, type-safe inspection with `errors.Is`/`errors.As`, adhering to the single handling rule, and utilizing structured logging with `slog`. Essential for building scalable, debuggable, and production-ready Go applications.

A comprehensive guide for building robust, production-ready microservices using gRPC in Golang. This skill covers advanced patterns including structured error handling with specific status codes, implementing cross-cutting concerns via interceptors (logging, auth), managing connections, ensuring graceful shutdowns, and defining optimal Protobuf schemas for distributed systems.