Skill UI

This guide outlines the architecture and implementation steps for building a robust, production-ready design system. It covers core elements like design tokens, reusable components, and layout patterns. Ideal for teams needing to maintain design consistency, ensure accessibility, and synchronize design (Figma) with implementation (Storybook).

This guide details the Hexagonal Architecture (Ports and Adapters) pattern, a robust method for decoupling core business logic from external infrastructure concerns. It teaches how to structure applications to make the domain model independent of databases, UI frameworks, or message queues. Implementing this pattern drastically improves testability, maintainability, and the ability to swap out external services without rewriting business rules.

A comprehensive guide to idiomatic and robust Dart/Flutter patterns. Covers essential topics including null safety, immutable state management (Freezed), advanced state solutions (BLoC, Riverpod, Provider), reactive routing with GoRouter, secure networking using Dio, and implementing Clean Architecture principles. Ideal for setting up new, scalable Flutter projects.

This guide outlines how to build new API connectors or providers that strictly adhere to the existing integration architecture and patterns of a target repository. It is designed for adding integrations while maintaining architectural consistency (e.g., layout, configuration schema, authentication model, and testing style), preventing the creation of novel, unsupported patterns.

A comprehensive guide to structuring Flutter applications using a feature-first, layered architecture. It defines clear separation of concerns across UI, Logic (Domain), and Data layers, ensuring maintainability and testability. This approach guides developers on organizing code by feature modules, making it ideal for building complex, scalable, and long-lived applications while remaining agnostic to specific state management solutions.

Generates professional documentation for software projects, covering READMEs, API references, architecture guides, inline comments, and changelogs, adapting style and scope to the codebase and user request.

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 building production-ready user interfaces with thoughtful component architecture, consistent spacing, typography, color, and accessibility standards while avoiding generic AI aesthetics and over-configured patterns.

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 for structuring, organizing, and initializing Go projects. It covers architectural decisions (Clean, Hexagonal, DDD), best practices for directory layouts (CLI, Service, Library, Monorepo), mandatory naming conventions, and adhering to 12-Factor App principles. Use this when starting a new Go service, refactoring large codebases, or setting up a complex monorepo.

A type-safe dependency injection toolkit for Go, enabling robust and maintainable application architecture. It manages service containers, handling service lifecycles (Lazy, Eager, Transient), scoped services, and dependency resolution. Ideal for refactoring manual constructor injection into a structured DI system in Go projects.

A comprehensive Go implementation of ReactiveX for building declarative, type-safe pipelines for asynchronous data streams. It manages complex event sources, handling automatic backpressure, error propagation, and context integration. Ideal for real-time data processing, WebSockets, and event-driven architectures where manual goroutine and channel wiring is complex.