kaakati/rails-enterprise-dev
Overview
This skill provides expert guidance for applying Atomic Design to iOS and tvOS projects using SwiftUI. It helps you decide when a component hierarchy adds value versus when it is overkill, how to draw atom vs molecule boundaries, and how to manage design tokens and component reuse across apps and teams.
How this skill works
It codifies decision trees and concrete rules: when to adopt a full Atomic hierarchy based on system size, how to decide extraction scope (one-off, local, design system), and explicit token naming and usage patterns for colors, spacing, and typography. The skill highlights anti-patterns (magic numbers, components that know app state, skipped composition levels) and offers composable patterns and token structures you can apply directly in SwiftUI.
When to use it
- Structuring a new design system or evolving an existing one
- Deciding whether to extract a view into an atom, molecule, or organism
- Defining or auditing design tokens for colors, spacing, typography, radii, and shadows
- Working across multiple teams or features where component reuse and consistency matter
- Cleaning up components that have too many parameters or hidden app dependencies
Best practices
- Match hierarchy to scale: skip formal Atomic structure for very small systems, adopt full hierarchy for large systems (30+ components, multiple teams)
- Atoms should be presentational and receive state via parameters — never depend on environment or fetch data
- Use tokens for every themeable value (Spacing.xs..xl, Color.semantic/brand, Font tokens, Radius enums) and avoid magic numbers
- Extract components based on reuse: inline for single-use, local for 2–3 uses, design-system level for 4+ or cross-feature reuse
- Prefer focused variants over a single component with many parameters; split responsibilities to keep APIs simple
Example use cases
- Deciding whether a complex search bar becomes a molecule or remains an atom
- Converting repeated inline cards into a Card molecule with content/footer slots
- Choosing token names for semantic colors (interactive, surface, error) to support theming and dark mode
- Auditing a component library to remove magic numbers and centralize radii and spacing tokens
- Designing button variants (PrimaryButton, IconButton, LoadingButton) instead of a single over-parameterized button
FAQ
If your system is very small (fewer than ~10 components) or you have only a few screens, the overhead of formal hierarchy often outweighs benefits; prefer a simple components folder and revisit as the system grows.
How many parameters are too many for a component?
If a component needs more than ~5–6 parameters to configure common variants, split it into focused variants (e.g., PrimaryButton, SecondaryButton, IconButton) to keep APIs easy to use and reason about.
30 skills
This skill provides expert Atomic Design decisions for iOS SwiftUI, helping you choose boundaries and token strategies to optimize component reuse.
This skill provides expert MVVM architecture guidance for iOS/tvOS, guiding ViewModel patterns, service boundaries, DI, and testing strategies.
This skill helps you implement robust service objects in Rails to organize business logic, manage transactions, and return clear results.
This skill guides when to use Alamofire over URLSession, designs interceptor chains, and selects retry and pinning strategies for robust networking.
This skill applies Dart and Flutter conventions, naming, structure, and async/await best practices to improve code clarity and maintainability.
This skill helps you make informed performance decisions for iOS/tvOS by profiling, selecting tools, and balancing optimization with user impact.
This skill helps you master Ruby OOP patterns and Rails practices, highlighting classes, modules, and SOLID principles for robust apps.
This skill helps you implement robust core layer patterns for error handling, validation, and configuration in Flutter projects.
This skill helps you implement comprehensive testing patterns including unit, widget, integration, and golden tests with mocking strategies.
This skill guides you through Turbo and Hotwire patterns to implement partial updates, real-time features, and Stimulus controllers in Rails apps.
This skill enables building consistent admin dashboards by applying TailAdmin UI patterns and Tailwind classes with verified usage from the official source.
This skill provides expert SwiftGen decisions for iOS projects, guiding template choice, organization, and build-phase configuration to maximize type-safety
This skill helps you prevent Rails runtime errors before coding by enforcing explicit exposure, proper grouping, and safe component access.
This skill guides expert decision making for error handling, designing error hierarchies, recovery strategies, and user-facing presentation.
This skill provides expert push notification decisions for permission timing, delivery strategies, and architecture choices to optimize user engagement.
This skill helps you optimize Rails ActiveRecord queries, manage associations, and use PostgreSQL patterns to prevent N+1 and improve performance.
This skill provides expert dependency injection guidance for iOS/tvOS, optimizing testability and flexibility through patterns, protocols, and environment
This skill guides you to design production-ready Rails REST APIs with serialization, authentication, versioning, and testing patterns.
This skill offers expert XCTest decision guidance for test type selection, mock design, and async testing strategies to improve reliability.
This skill orchestrates a complete refactoring workflow with tracking, validation, and cross-layer impact checks to ensure no old references remain.
This skill provides expert quality gate decisions for iOS/tvOS projects, calibrating coverage, linting, and CI patterns to balance quality and velocity.
This skill enables LSP-powered context extraction and type-safe code generation with cclsp, Sorbet, and Solargraph for safer Rails development.
This skill enables multi-language Flutter apps with GetX translations, offering setup, locale management, RTL support, and formatting patterns.
This skill guides you through implementing and optimizing Sidekiq background jobs in Rails, ensuring idempotent tasks, proper retries, and efficient scheduling.
This skill enforces codebase inspection before Rails tasks, citing observed file paths to guide architecture, patterns, and file additions.
This skill guides you to choose between Combine and async/await, design robust operator chains, and prevent memory leaks in reactive streams.
This skill guides you in selecting SwiftUI navigation architectures, managing navigation state, and implementing robust deep links for scalable iOS apps.
This skill provides production-ready Rails safety checklists to prevent nil errors, N+1 queries, and security issues during implementation.
This skill provides expert Clean Architecture decisions for iOS, guiding layer boundaries, data vs domain placement, and pragmatic trade-offs.
This skill helps you implement polished UX patterns for Rails apps with responsive layouts, dark mode, loading states, and smooth interactions.
