domain▌

Guides initial domain choice for a single site: Brand vs Partial Match vs Exact Match domains, TLD selection (.ai, .com, .io), length, readability, history check, and defensive registration. A good domain affects SEO, brand perception, and UX. See domain-architecture when planning for multiple products; rebranding-strategy when changing domain.

Framework for tackling software complexity by modeling code around the business domain. Based on a fundamental truth: the greatest risk in software is not technical failure -- it is building a model that does not reflect how the business actually works.

Fintech domain constraints and design patterns for building precise, auditable financial systems in Rust. \n \n Enforces decimal precision (never f64) using rust_decimal, immutable transaction records with Arc, and double-entry accounting principles to prevent money loss or inconsistency \n Provides currency newtypes, transaction aggregates, and audit logging patterns aligned with regulatory compliance and dispute resolution requirements \n Maps domain rules (precision, audit trails, consistency

Design patterns and constraints for building reliable, power-efficient IoT applications in Rust. \n \n Covers six critical domains: network unreliability, power constraints, resource limits, security, reliability, and over-the-air updates with specific Rust implementation strategies \n Provides MQTT client patterns using rumqttc for pub/sub messaging with QoS levels, local buffering, and retry logic with exponential backoff \n Distinguishes between Linux gateway stacks (tokio + std) and MCU devi

Machine learning and AI applications in Rust with tensor operations, model inference, and GPU acceleration. \n \n Covers tensor libraries (ndarray), inference frameworks (tract for ONNX, candle, burn), and PyTorch bindings (tch-rs) for training and deployment workflows \n Emphasizes memory efficiency through zero-copy operations, GPU batching, and standard model formats (ONNX) for portability across Python and Rust \n Provides design patterns for model loading with lazy initialization, batched i

Design constraints and patterns for building stateless, observable cloud-native applications in Rust. \n \n Enforces stateless design, graceful shutdown with SIGTERM handling, and 12-factor configuration via environment variables to support Kubernetes orchestration and zero-downtime deployments \n Requires distributed tracing with tracing and OpenTelemetry, plus dedicated /health and /ready endpoints for liveness and readiness probes \n Recommends key crates: tonic for gRPC services, kube and ku

Rust CLI design constraints and patterns for argument parsing, configuration layering, and user feedback. \n \n Type-safe argument parsing with clap derive macros; supports subcommands, help text, and environment variable integration \n Configuration precedence rule: CLI args override environment variables, which override config files and defaults \n Proper error handling with stderr/stdout separation, non-zero exit codes, and Result-based error propagation \n Progress bars, colored output, and

Web service architecture with async handlers, type-safe extractors, and middleware composition. \n \n Enforces async-first design to prevent blocking request handlers; use spawn_blocking for CPU-intensive work \n Manages shared application state via Arc<T> and Arc<RwLock<T>> to ensure thread safety across concurrent requests \n Provides extractor pattern for request parsing and validation (e.g., State(db) , Json(payload) ) with unified error responses via IntoResponse \n Supports

Design error handling by categorizing who handles each error and how they recover. \n \n Distinguish between user-facing errors (actionable messages), internal errors (debug details), system errors (monitoring), and transient vs. permanent failures to determine recovery strategy \n Use typed error enums with thiserror and implement is_retryable() checks to enable appropriate handling patterns \n Apply recovery strategies: retry with exponential backoff for transient failures, fallback values for

Domain-driven design patterns for modeling entities, value objects, and aggregates in Rust. \n \n Distinguishes between Entities (unique identity required), Value Objects (interchangeable by value), and Aggregates (owned hierarchies), with clear Rust patterns for each \n Emphasizes invariant preservation through private fields, validated constructors, and type-state patterns \n Provides templates for common DDD structures: newtypes for value objects, structs with ID fields for entities, and modu