Your cart is empty
Add prompt packs to continue
Master the mobile development ecosystem with this definitive collection of prompts designed for software engineers and architects. This comprehensive guide covers everything from deep logic in Flutter and React Native to the technical implementation of cloud services, ensuring high-performance applications and industrial scalability. Optimize your workflow with precise monetization strategies, native interface design, and in-store optimization. Each section has been curated to solve specific technical problems, allowing you to reduce development times and raise the final quality of your digital products in the global market.
100 resources included
Acts as a Senior Software Architect specialized in mobile development with [MAIN_TECHNOLOGY] and expert in reactive state management patterns using MobX. Your goal is to design a comprehensive and scalable system for reactive error management that integrates seamlessly into an [APP_TYPE] architecture. The system should avoid the use of scattered try-catch blocks and centralize the logic for capturing, classifying and responding to network failures, validation and unexpected system errors, ensuring that the user interface reacts automatically and consistently. Design a global 'ErrorStore' structure that uses observables to track the current state of errors. This store must include properties for the located message, a unique error code, the severity level (warning, error, fatal), and a visibility boolean. Implement action methods for 'setError', 'clearError' and a MobX 'flow' that manages automatic retry logic based on [RETRY_STRATEGY]. It is essential that the system differentiates between transient errors (such as connection loss) and permanent errors (such as business logic failures or permissions denied). Develop an integration strategy with domain stores. Explains how to catch exceptions in methods decorated with '@action' or 'runInAction' and how to delegate those failures to the central 'ErrorStore'. Includes an example of how to handle error log persistence using [LOGGING_FORMAT] to facilitate post-mortem debugging. The prompt should generate clean example code, following SOLID principles, and show how an 'Observer' UI component should subscribe to these changes to display modals or snackbars reactively without manual intervention on each screen. Finally, analyze how this approach impacts application performance and end-user experience. Please propose a solution to automatically clean errors after [PERSISTENCE_DURATION] or after successful user navigation. Ensure that the solution supports unit testing best practices, allowing simulating error states in the store to verify the behavior of the interface in isolation.
Acts as a Senior Software Engineer specialized in mobile platforms (iOS/Android) and expert in Observability and advanced Debugging. Your mission is to perform a deep technical autopsy of a critical bug reported in Firebase Crashlytics and Sentry. The goal is to break down the raw information to find the 'Root Cause' that is not evident to the naked eye, considering race conditions, memory management and inconsistent UI states in the mobile application [App Name]. Thoroughly analyze the following data dump that I will provide below: [Raw Logs and Stack Trace]. You must logically reverse engineer the execution flow based on the 'Breadcrumbs' and custom event logs provided in the report. Identifies whether the error is a direct result of an unexpected response from an external API, a failure in the local data persistence layer, or a memory access violation in native C++/Kotlin/Swift code. Specifically consider environment metadata such as [Operating System Version] and hardware model to rule out fragmentation issues. Decomposes the Stack Trace by prioritizing the thread where the exception occurred (usually the Main Thread or specific Background threads). Locate the exact class and method in the repository [Module Path or Code Package] where the fatal exception is raised. Evaluate edge cases that could have caused the control variables to be null or out of range. Propose an optimized code solution that not only patches the current bug, but improves the overall resiliency of the system through the use of defensive programming, granular exception handling, or retry patterns. Provides a diagnosis of the technical impact based on the frequency of events and the criticality of the affected functionality in the specific version [Build/Release Version]. Generate a list of detailed and logical steps so that the QA team can attempt to reproduce the bug in a controlled environment, mentioning if special conditions such as low connectivity or low available memory are required. It concludes with a proactive monitoring recommendation, suggesting which additional custom tags or 'Custom Keys' we should implement to better capture the state of the application in future similar incidents.
He acts as a Senior UI Design Engineer and Design Systems Specialist with extensive experience in developing native interfaces for iOS and Android. Your goal is to create a comprehensive responsive and dynamically scalable typography framework for the [Application Name] mobile application. This system must strictly comply with WCAG 2.1 accessibility guidelines and align with Apple's Human Interface Guidelines (HIG) standards for Dynamic Type and Google's Material Design 3 for font scaling. Defines a typographic token architecture based on a modular scale of [Modular Ratio, e.g. 1.125 Major Second or 1.250 Major Third] using a base size of [Base Size in px/pt]. Generates a complete matrix that classifies the styles into semantic categories: Display, Headline, Title, Body and Label. For each style, you must specify the font size (in pt/sp), font-weight, line-height, and letter-spacing. It is crucial that the system supports fluid scaling, so you must propose mathematical formulas that adjust these values according to the width of the viewport on mobile devices and tablets. Develop technical implementation logic for two environments: first, for iOS using SwiftUI, integrating 'UIFontMetrics' and custom text styles that respect the user's accessibility settings without compromising the layout. Second, for Android using Jetpack Compose, defining a 'Typography.kt' structure that uses 'sp' units and correctly handles the LineHeightStyle to avoid visual clipping. Make sure to include clamping logic so that the typography does not scale indefinitely on large format devices, always maintaining visual hierarchy. Finally, it provides an implementation guide for developers that includes code examples on how to apply these tokens to complex components, such as fact cards or forms. Include a validation section explaining how to test readability under extreme conditions, such as the use of extra-large fonts by visually impaired users, ensuring that the text container fits correctly without overflows or overlaps.