Kaakati
@Kaakati
Public Skills
accessibility-patterns
by Kaakati
"Expert accessibility decisions for iOS/tvOS: when to combine vs separate elements, label vs hint selection, Dynamic Type layout strategies, and WCAG AA compliance trade-offs. Use when implementing VoiceOver support, handling Dynamic Type, or ensuring accessibility compliance. Trigger keywords: accessibility, VoiceOver, Dynamic Type, WCAG, a11y, accessibilityLabel, accessibilityElement, accessibilityTraits, isAccessibilityElement, reduceMotion, contrast, focus"
alamofire-patterns
by Kaakati
"Expert Alamofire decisions for iOS/tvOS: when Alamofire adds value vs URLSession suffices, interceptor chain design trade-offs, retry strategy selection, and certificate pinning considerations. Use when designing network layer, implementing auth token refresh, or choosing between networking approaches. Trigger keywords: Alamofire, URLSession, interceptor, RequestAdapter, RequestRetrier, certificate pinning, Session, network layer, token refresh, retry"
atomic-design-ios
by Kaakati
"Expert Atomic Design decisions for iOS/tvOS: when component hierarchy adds value vs overkill, atom vs molecule boundary judgment, design token management trade-offs, and component reusability patterns. Use when structuring design systems, deciding component granularity, or organizing component libraries. Trigger keywords: Atomic Design, atoms, molecules, organisms, templates, component library, design system, design tokens, reusability, composition"
combine-reactive
by Kaakati
"Expert Combine decisions for iOS/tvOS: when Combine vs async/await, Subject selection trade-offs, operator chain design, and memory management patterns. Use when implementing reactive streams, choosing between concurrency models, or debugging Combine memory leaks. Trigger keywords: Combine, Publisher, Subscriber, Subject, PassthroughSubject, CurrentValueSubject, async/await, AnyCancellable, sink, operators, reactive"
code-quality-gates
by Kaakati
"Expert quality gate decisions for iOS/tvOS: which gates matter for your project size, threshold calibration that catches bugs without blocking velocity, SwiftLint rule selection, and CI integration patterns. Use when setting up linting, configuring CI pipelines, or calibrating coverage thresholds. Trigger keywords: SwiftLint, SwiftFormat, coverage, CI, quality gate, lint, static analysis, pre-commit, threshold, warning"
concurrency-patterns
by Kaakati
"Expert Swift concurrency decisions: async let vs TaskGroup selection, actor isolation boundaries, @MainActor placement strategies, Sendable conformance judgment calls, and structured vs unstructured task trade-offs. Use when designing concurrent code, debugging data races, or choosing between concurrency patterns. Trigger keywords: async, await, actor, Task, TaskGroup, @MainActor, Sendable, concurrency, data race, isolation, structured concurrency, continuation"
coordinator-pattern
by Kaakati
"Expert Coordinator pattern decisions for iOS/tvOS: when coordinators add value vs overkill, parent-child coordinator hierarchy design, SwiftUI vs UIKit coordinator differences, and flow completion handling. Use when designing navigation architecture, implementing multi-step flows, or decoupling views from navigation. Trigger keywords: Coordinator, navigation, flow, parent coordinator, child coordinator, deep link, routing, navigation hierarchy, flow completion"
dependency-injection
by Kaakati
"Expert DI decisions for iOS/tvOS: when DI containers add value vs overkill, choosing between injection patterns, protocol design for testability, and SwiftUI-specific injection strategies. Use when designing service layers, setting up testing infrastructure, or deciding how to wire dependencies. Trigger keywords: dependency injection, DI, constructor injection, protocol, mock, testability, container, factory, @EnvironmentObject, service locator"
app-lifecycle
by Kaakati
"Expert lifecycle decisions for iOS/tvOS: when SwiftUI lifecycle vs SceneDelegate, background task strategies, state restoration trade-offs, and launch optimization. Use when managing app state transitions, handling background work, or debugging lifecycle issues. Trigger keywords: lifecycle, scenePhase, SceneDelegate, AppDelegate, background task, state restoration, launch time, didFinishLaunching, applicationWillTerminate, sceneDidBecomeActive"
error-handling-patterns
by Kaakati
"Expert error handling decisions for iOS/tvOS: when to use throws vs Result, error type design trade-offs, recovery strategy selection, and user-facing error presentation patterns. Use when designing error hierarchies, implementing retry logic, or deciding how to surface errors to users. Trigger keywords: Error, throws, Result, LocalizedError, retry, recovery, error presentation, do-catch, try, error handling, failure"
localization-ios
by Kaakati
"Expert localization decisions for iOS/tvOS: when runtime language switching is needed vs system handling, pluralization rule complexity by language, RTL layout strategies, and string key architecture. Use when internationalizing apps, handling RTL languages, or debugging localization issues. Trigger keywords: localization, i18n, l10n, NSLocalizedString, Localizable.strings, stringsdict, plurals, RTL, Arabic, Hebrew, SwiftGen, language switching"
model-patterns
by Kaakati
"Expert model design decisions for iOS/tvOS: when DTO separation adds value vs overkill, validation strategy selection, immutability trade-offs, and custom Codable decoder design. Use when designing data models, implementing API contracts, or debugging decoding failures. Trigger keywords: Codable, DTO, domain model, CodingKeys, custom decoder, validation, immutable, struct, mapping, JSON decoding"
mvvm-architecture
by Kaakati
"Expert MVVM decisions for iOS/tvOS: choosing between ViewModel patterns (state enum vs published properties vs Combine), service layer boundaries, dependency injection strategies, and testing approaches. Use when designing ViewModel architecture, debugging data flow issues, or deciding where business logic belongs. Trigger keywords: MVVM, ViewModel, ObservableObject, @StateObject, service layer, dependency injection, unit test, mock, architecture"
navigation-patterns
by Kaakati
"Expert navigation decisions for iOS/tvOS: when NavigationStack vs Coordinator patterns, NavigationPath state management trade-offs, deep link architecture choices, and tab+navigation coordination strategies. Use when designing app navigation, implementing deep links, or debugging navigation state issues. Trigger keywords: NavigationStack, NavigationPath, deep link, routing, tab bar, navigation, programmatic navigation, universal link, URL scheme, navigation state"
performance-optimization
by Kaakati
"Expert performance decisions for iOS/tvOS: when to optimize vs premature optimization, profiling tool selection, SwiftUI view identity trade-offs, and memory management strategies. Use when debugging performance issues, optimizing slow screens, or reducing memory usage. Trigger keywords: performance, Instruments, Time Profiler, Allocations, memory leak, view identity, lazy loading, @StateObject, retain cycle, image caching, faulting, batch operations"
core-data-patterns
by Kaakati
"Expert Core Data decisions for iOS/tvOS: when Core Data vs alternatives, context architecture for multi-threading, migration strategy selection, and performance optimization trade-offs. Use when choosing persistence layer, debugging save failures, or optimizing fetch performance. Trigger keywords: Core Data, NSManagedObject, NSPersistentContainer, NSFetchRequest, FetchRequest, migration, lightweight migration, background context, merge policy, faulting"
api-integration
by Kaakati
"Expert API integration decisions for iOS/tvOS: REST vs GraphQL trade-offs, API versioning strategies, caching layer design, and offline-first architecture choices. Use when designing network architecture, implementing offline support, or choosing between API patterns. Trigger keywords: REST, GraphQL, API versioning, caching, offline-first, URLSession, background fetch, ETag, pagination, rate limiting"
clean-architecture-ios
by Kaakati
"Expert Clean Architecture decisions for iOS/tvOS: when Clean Architecture adds value vs overkill, layer boundary judgment calls, dependency rule violations to catch, and practical trade-offs between purity and pragmatism. Use when designing app architecture, debugging layer violations, or deciding what belongs where. Trigger keywords: Clean Architecture, layer, domain, data, presentation, use case, repository, dependency rule, entity, DTO, mapper"
Accessibility Patterns
by Kaakati
WCAG 2.2 Level AA compliance patterns for Flutter applications including Semantics widgets, screen reader support, keyboard navigation, and color contrast requirements
Advanced GetX Patterns
by Kaakati
Advanced GetX features including Workers, GetxService, SmartManagement, GetConnect, GetSocket, bindings composition, and testing patterns
Performance Optimization
by Kaakati
Performance optimization patterns for Flutter applications including widget optimization, memory management, profiling, and 60 FPS best practices
Core Layer Patterns
by Kaakati
Base classes, error handling, utilities, configuration, and dependency injection patterns for Flutter Clean Architecture
Navigation Patterns
by Kaakati
GetX navigation patterns including routing, parameters, guards, deep linking, and custom transitions for Flutter applications
Internationalization Patterns
by Kaakati
Internationalization (i18n) and localization (l10n) patterns using GetX Translations for multi-language Flutter applications
Code Quality Gates
by Kaakati
"Quality gate patterns including dart analysis, test coverage, build validation, and compliance checks"
Repository Patterns
by Kaakati
"Repository interface and implementation patterns with offline-first strategies"
Testing Patterns
by Kaakati
"Unit, widget, integration, and golden test patterns with mocking strategies"
GetStorage Patterns
by Kaakati
"Local storage with GetStorage for preferences, caching, and offline-first patterns"
Model Patterns
by Kaakati
"Entity and model patterns with JSON serialization, immutability, and equality"
HTTP Integration Patterns
by Kaakati
"HTTP client configuration, API providers, error handling, and request/response patterns"
Clean Architecture Patterns
by Kaakati
"Domain, Data, and Presentation layer separation with dependency inversion and use case patterns"
GetX State Management Patterns
by Kaakati
"GetX controllers, reactive state, dependency injection, bindings, navigation, and best practices"
Error Handling Patterns
by Kaakati
"Exception classes, failure classes, Either type, and error handling strategies"
Flutter Conventions & Best Practices
by Kaakati
"Dart 3.x and Flutter 3.x conventions, naming patterns, code organization, null safety, and async/await best practices"
API Development Patterns
by Kaakati
Comprehensive guide to building production-ready REST APIs in Rails with serialization, authentication, versioning, rate limiting, and testing
Rails Conventions & Patterns
by Kaakati
"Comprehensive Ruby on Rails conventions, design patterns, and idiomatic code standards. Use this skill when writing any Rails code including controllers, models, services, or when making architectural decisions about code organization, naming conventions, and Rails best practices."
RSpec Testing Patterns
by Kaakati
"Complete guide to testing Ruby on Rails applications with RSpec. Use this skill when writing unit tests, integration tests, system tests, or when setting up test infrastructure including factories, shared examples, and mocking strategies."
ActiveRecord Query Patterns
by Kaakati
"Complete guide to ActiveRecord query optimization, associations, scopes, and PostgreSQL-specific patterns. Use this skill when writing database queries, designing model associations, creating migrations, optimizing query performance, or debugging N+1 queries and grouping errors."
Sidekiq & Async Patterns
by Kaakati
"Complete guide to background job processing with Sidekiq in Ruby on Rails. Use this skill when: (1) Creating background jobs, (2) Configuring queues and workers, (3) Implementing retry logic and error handling, (4) Designing idempotent jobs, (5) Setting up scheduled/recurring jobs, (6) Optimizing job performance."
Ruby OOP Patterns
by Kaakati
Comprehensive guide to Object-Oriented Programming in Ruby and Rails covering classes, modules, design patterns, SOLID principles, and modern Ruby 3.x features
Service Object Patterns
by Kaakati
"Complete guide to implementing Service Objects in Ruby on Rails applications. Use this skill when creating business logic services, organizing service namespaces, handling service results, and designing service interfaces for complex operations."
Turbo & Hotwire Patterns
by Kaakati
"Complete guide to Hotwire implementation including Turbo Drive, Turbo Frames, Turbo Streams, and Stimulus controllers in Rails applications. Use this skill when implementing real-time updates, partial page rendering, or JavaScript behaviors in Rails views."
requirements-writing
by Kaakati
Write clear, testable requirements using User Stories and Gherkin scenarios for Manifest Logistics SaaS. Capture functional and non-functional requirements with proper acceptance criteria. Use when defining new features or documenting system behavior.
Rails Localization (i18n) - English & Arabic
by Kaakati
"Comprehensive internationalization skill for Ruby on Rails applications with proper English and Arabic translations, RTL support, pluralization rules, date/time formatting, and culturally appropriate content adaptation."
Codebase Inspection Protocol
by Kaakati
"Mandatory inspection procedures for understanding Rails codebase structure before writing any code. Use this skill FIRST before any code generation task to discover existing patterns, conventions, dependencies, and file organization in the target Rails project."
TailAdmin UI Patterns
by Kaakati
"TailAdmin dashboard UI framework patterns and Tailwind CSS classes. ALWAYS use this skill when: (1) Building any dashboard or admin panel interface, (2) Creating data tables, cards, charts, or metrics displays, (3) Implementing forms, buttons, alerts, or modals, (4) Building navigation (sidebar, header, breadcrumbs), (5) Any UI work that should follow TailAdmin design. This skill REQUIRES fetching from the official GitHub repository to ensure accurate class usage - NEVER invent classes."
Rails Error Prevention
by Kaakati
"Comprehensive checklist and prevention strategies for common Ruby on Rails errors. Use this skill BEFORE writing any Rails code to prevent ViewComponent template errors, ActiveRecord query mistakes, method exposure issues, N+1 queries, and other common Rails pitfalls."
ViewComponents Specialist
by Kaakati
"Specialist in ViewComponent implementation, component architecture, slots, previews, and method exposure patterns. Invoke this agent when creating or modifying ViewComponents, implementing component slots, setting up previews, debugging component rendering issues, or ensuring proper method delegation from services."
Rails Context Verification
by Kaakati
Systematic verification of codebase context before code generation to prevent assumption bugs
Skill Discovery Patterns
by Kaakati
How the Rails Enterprise Dev plugin discovers and uses project skills dynamically