1. How an app adapts as its window changes shape and size
2. How it behaves in multitasking and multiwindow environments
3. How it stays usable across touch, keyboard, mouse/trackpad, and pen

The convergence isn’t accidental. It’s a response to the same hardware reality: foldables and tablets, laptops with touchscreens, desktop-class windowing on tablets, and “one app, many contexts” distribution (phone → tablet → desktop → large external display). The result is a shared design center of gravity: adaptive layouts + multiwindow + multi-input.

Adaptive layouts: the window is the unit, not the device

All three ecosystems have moved away from “design for devices” and toward “design for available space.”

Google’s Material 3 adaptive guidance is explicit: window size is dynamic and changes with user behavior—multi-window modes, resizing, and foldable postures—so layout should respond to window size classes rather than device labels. Material describes a set of window size classes (from compact through extra-large) and encourages layouts that reflow across these breakpoints. It also frames common UI structures in terms of 1–3 panes that can appear or collapse as space changes—an idea that maps cleanly to modern tablet and desktop UI.

Microsoft’s Windows app design guidance reaches a very similar place through different mechanics: responsive UI is commonly achieved with VisualStateManager and AdaptiveTrigger, so layouts rearrange automatically when a window hits a specified width/height threshold. Even Microsoft’s control guidance uses this approach for navigation patterns — switching, for example, between top navigation and a left/compact navigation model based on window width.

Apple’s Human Interface Guidelines speak the same “window-first” language: people can freely resize windows down to minimum sizes, and apps should account for that resizing behavior. Apple’s HIG also emphasizes that windows should adapt fluidly to different sizes to support multitasking and multiwindow workflows.

Similarity that matters: all three are teaching developers to treat UI as a responsive system driven by runtime constraints. Concretely, the design question is no longer “do we have a tablet layout?” but “what happens to our navigation, hierarchy, and content density when the window becomes medium, narrow, tall, split, or freeform?”

Multitasking: multiwindow is no longer optional behavior

The second convergence is that multitasking isn’t presented as a special mode; it’s treated as a default context that apps must survive.

Material’s layout guidance repeatedly anchors adaptation in scenarios like entering multi-window mode and resizing freeform windows, and it describes canonical patterns (like list-detail) that collapse from two panes to one when the window class shrinks. The framing is practical: layouts should keep working as the user changes the window, not only at app launch.

Apple’s platform guidance for multitasking similarly puts adaptation first: when supporting multitasking, your scenes should adapt to different window sizes, and Stage Manager/desktop-class features make resizable windows a core iPad experience rather than an edge case. Apple’s HIG sections on windows and multitasking reinforce that multiwindow workflows are expected and that window resizing is something the UI should handle gracefully.

On Windows, multitasking is essentially synonymous with windowing: users routinely resize, snap, and run multiple apps side by side. The Windows design hub explicitly frames guidance around consistent behavior across devices, input types, and form factors—meaning your app should still behave when it’s one window among many. The underlying adaptive UI model (states and triggers) exists precisely because multiwindow is normal, not exceptional.

Similarity that matters: across platforms, multitasking pushes the same engineering consequences: state restoration, layout performance during live resizing, and navigation that remains coherent when panes appear/disappear. The “design” problem is inseparable from lifecycle and state: a two-pane view that loses selection context when collapsing to one pane is a UX issue and a state-management issue at the same time.

Input methods: touch is table stakes; keyboard and pointer are first-class

The third convergence is input plurality. Touch-first assumptions are no longer safe, even on tablets.

On Windows, keyboard access and focusability are core accessibility and productivity concerns—Microsoft documents built-in support for access keys and keyboard interaction patterns that let users operate UI without a pointer.

Apple has spent years evolving iPad toward hybrid input. Official guidance and supporting material emphasize pointer/trackpad interaction and hardware keyboard workflows in iPad multitasking contexts (and, by extension, windowed environments). The HIG’s multiwindow push implicitly raises the importance of predictable focus, shortcuts, and pointer affordances, because windowed multitasking is strongly associated with keyboard/pointer usage.

Google’s adaptive layout framing is often paired with large-screen expectations that include keyboard, mouse/trackpad, and stylus across Android’s broader large-screen ecosystem—because the same layout needs to remain usable when interaction shifts from thumbs to cursor and keys. Material’s own multi-window framing underscores that layout must remain functional as the user changes context, which includes input context in real life.

Similarity that matters: the input problem is converging on the same checklist everywhere: reliable focus order, obvious hover/pressed states where relevant, keyboard accelerators/shortcuts, and controls that don’t depend on a single interaction model (e.g., swipe-only navigation with no keyboard alternative).

Why this convergence matters for app developers

This shared direction changes how teams should think about “platform support”:

• Adaptive layout becomes product work, not just UI polish. If your navigation model can’t collapse/expand cleanly (bottom bar side rail; single pane list-detail), you’ll feel it on iPad window resizing, Android multiwindow/foldables, and Windows snap layouts.
• State and navigation architecture are now design requirements. The better your app separates state from presentation and maintains meaningful selection/history across panes and window sizes, the more “native” it feels everywhere.
• Multi-input isn’t niche. The platforms are converging on the expectation that serious work happens with keyboards and pointers—even on devices that used to be touch-only.

The practical takeaway is simple: Apple, Google, and Microsoft aren’t asking developers to solve three different problems. They’re asking developers to solve the same problems—adaptive layout, multitasking resilience, and multi-input usability—through each platform’s idioms. If your app strategy treats those as a single design-and-architecture investment, you get leverage across ecosystems instead of re-litigating “tablet support” and “desktop support” as separate projects every year.

Some products deserved the excitement. Others were exercises in manufactured enthusiasm, where the disconnect between promise and delivery made you wonder if anyone actually used the product before declaring it revolutionary. Here are the most overhyped tech products of 2025 — and why the reality didn’t match the marketing.

Vision Pro Competitors That Weren’t Ready

After Apple’s Vision Pro launched in early 2024, 2025 saw a flood of competitors rushing to market with their own mixed reality headsets. Meta, Samsung, and others promised Vision Pro experiences at a fraction of the price.

The hype: All the spatial computing goodness of Vision Pro without the $3,500 price tag. Mixed reality for the masses, finally making the technology accessible.

The reality: These headsets were cheaper for a reason. Lower resolution displays that made text hard to read for extended periods. Hand tracking that worked inconsistently and frustrated users. Comfort issues that made wearing them for more than 30 minutes painful. App ecosystems that launched sparse and stayed sparse.

The Meta Quest 3S and similar devices were fine for gaming and entertainment, but the productivity promises fell flat. Using virtual monitors for work sounded great in demos but caused eye strain and headaches in real use. The “killer apps” never materialized—mostly ports of existing apps that worked better on regular screens.

Why it was overhyped: The industry desperately wanted mixed reality to be ready for mainstream adoption. Every manufacturer racing to compete with Apple created a narrative that spatial computing was the next big thing happening right now. Reality check: the technology still isn’t there for most people’s daily workflows, regardless of price point.

AI Companion Devices (Humane AI Pin, Rabbit R1, and Others)

2025 was supposed to be the year of AI companion devices—standalone gadgets that would replace your smartphone for many tasks through AI-powered voice and visual interaction. The Humane AI Pin and Rabbit R1 led the charge with massive hype.

The hype: A post-smartphone future where AI assistants handle everything through natural conversation. No more scrolling through apps—just ask and receive. The next computing paradigm, here today.

The reality: These devices launched to enthusiastic reviews from early adopters and crashed within weeks in real-world use. Response times were slow. Accuracy was inconsistent. Battery life was abysmal—often lasting just a few hours. The AI frequently misunderstood requests or provided incorrect information.

Critically, they couldn’t actually replace smartphones for most tasks. You still needed your phone for messages, navigation, payments, and countless other daily functions. The AI companions became extra devices to charge and carry, not replacements for anything.

The Humane AI Pin’s projector interface was novel but impractical—hard to see in sunlight, awkward to use in public. The Rabbit R1’s “large action model” promised to complete tasks across apps but struggled with anything beyond simple requests.

Why it was overhyped: Because major tech figures hyped these products as revolutionary, and the media amplified those claims without sufficient skepticism. The concept of AI companions is compelling, but 2025’s implementations were barely functional minimum viable products masquerading as finished consumer devices.

The “AI Phone” Wave

Multiple manufacturers declared 2025 the year of the “AI phone,” with Google’s Pixel 9 series, Samsung’s Galaxy S24, and others promising revolutionary AI features built into the hardware.

The hype: Phones that understand you, anticipate your needs, edit photos like professionals, summarize everything, and fundamentally change how you interact with your device.

The reality: Most AI features were gimmicks people used once and forgot about. AI wallpaper generation was fun for a day. Circle to Search was occasionally useful but not transformative. AI photo editing produced inconsistent results that often looked worse than the originals.

The truly useful AI features—better voice typing, smarter autocorrect, improved spam filtering—were incremental improvements, not revolutionary changes. Battery life suffered because AI processing is power-hungry, and many people disabled features to extend battery life.

The on-device AI that was supposed to protect privacy while enabling powerful features was limited by phone hardware constraints. Most impressive AI capabilities still required cloud processing, undermining the privacy pitch.

Why it was overhyped: Because manufacturers needed a new selling point after years of incremental camera and processor improvements. “AI” became the marketing angle, even when the actual AI features were minor additions to otherwise standard smartphone upgrades.

Foldable Phones Declaring “Mainstream Ready”

Samsung, Google, and others declared 2025 the year foldables would finally go mainstream. Prices dropped slightly, durability supposedly improved, and software was more optimized.

The hype: Foldables are ready for everyone now. The crease is barely visible, the durability concerns are solved, and the software experience is finally mature.

The reality: The crease was still visible and distracting. Durability improved but foldables remained more fragile than regular phones—screen protectors peeling, hinges collecting dust, displays scratching more easily. Many users reported screen failures within the first year.

App support remained inconsistent. Many apps didn’t properly utilize the larger unfolded screen or handled the fold transition awkwardly. The promise of a tablet experience in your pocket delivered an awkward in-between size that wasn’t optimal for either phone or tablet use cases.

Battery life suffered because you’re essentially powering two displays. The phones were significantly thicker and heavier than regular flagships, making them less comfortable for one-handed use or carrying in pockets.

Why it was overhyped: Market saturation of regular smartphones pushed manufacturers to create new categories. Foldables are that category, but declaring them “mainstream ready” was aspirational marketing, not reality. They’re better than early versions but still niche devices for enthusiasts willing to accept compromises.

ChatGPT Wrappers Disguised as Revolutionary Apps

2025 saw an explosion of apps that were essentially ChatGPT with a specialized interface, marketed as revolutionary AI solutions for specific use cases—AI lawyers, AI doctors, AI financial advisors, AI therapists.

The hype: Specialized AI that understands your specific domain deeply. Professional-grade advice and assistance at a fraction of traditional costs.

The reality: Most were just ChatGPT or similar models with custom prompts and nice UI. They provided generic advice that often included disclaimers to “consult a real professional.” The “specialized” knowledge was surface-level at best, dangerous at worst.

Legal AI apps gave outdated or incorrect legal information. Health AI apps provided generic wellness advice while specifically disclaiming they weren’t medical advice. Financial AI apps gave investment suggestions with massive disclaimers about not being financial advice.

Many charged $10-30 monthly subscriptions for functionality you could get from ChatGPT Plus for $20/month across all domains. The specialization was marketing, not capability.

Why it was overhyped: The democratization of AI through ChatGPT’s API made it trivial to build domain-specific wrappers. Founders and investors convinced themselves (and tried to convince users) that a nice interface and domain-specific prompting constituted a revolutionary product. Users quickly realized they were paying premiums for minimal additional value.

“Smart” Home Devices That Barely Worked

Matter was supposed to make smart home devices universally compatible in 2024. By 2025, manufacturers rushed Matter-compatible devices to market, promising seamless smart home integration across all platforms.

The hype: Finally, smart home devices that work together regardless of ecosystem. Buy any Matter device and it’ll work perfectly with Google Home, Apple HomeKit, Amazon Alexa, and everything else.

The reality: Matter support was incomplete and buggy. Devices lost connectivity frequently. Features that worked with one platform didn’t work with another. Updates broke compatibility that previously worked. Setup remained complicated and frustrating.

Many devices advertised as “Matter compatible” only supported a subset of features through Matter. Full functionality required manufacturer-specific apps and ecosystems, defeating the entire purpose.

The promised interoperability existed in theory but failed in practice. Users still ended up locked into specific ecosystems and dealing with multiple apps to control their smart home.

Why it was overhyped: Because the industry desperately needed Matter to succeed and collectively pretended it was ready when it wasn’t. Manufacturers rushed half-baked implementations to market to claim “Matter support” in marketing materials, regardless of actual functionality.

The Pattern Behind 2025’s Hype

Looking across the year’s most overhyped products, clear patterns emerged:

“AI-powered” justified everything. Adding AI to any product became the excuse for premium pricing and revolutionary claims, whether the AI actually improved the product or not.

Rush to market over readiness. Companies launched products before they were truly ready, banking on updates to fix problems later. This worked poorly when fundamental issues couldn’t be patched away.

Marketing to tech enthusiasts, not normal users. Products designed to impress in controlled demos and generate spec-sheet buzz, without considering daily real-world use by regular people.

Ecosystem lock-in disguised as features. “Seamless integration” often meant incompatibility with anything outside one company’s ecosystem, trapping users rather than serving them.

Overpromising privacy while undercutting it. Many products claimed to protect privacy through on-device AI while still requiring cloud processing for key features, undermining their own privacy pitch.

What Actually Delivered in 2025

Not everything was overhyped. Some products and technologies genuinely improved life without massive marketing campaigns:

USB-C becoming universal finally happened in 2025, making charging and data transfer simpler across all devices. This boring infrastructure improvement mattered more than most flashy launches.

Incremental phone improvements in cameras, battery life, and performance continued delivering real value without revolutionary claims.

WiFi 7 rollout started improving home network performance noticeably, especially in dense urban environments.

Boring software updates to existing platforms—better spam filtering, improved accessibility features, more efficient battery management—provided consistent value.

The pattern: genuinely useful innovation happened quietly through iteration and infrastructure improvements, while overhyped products got the attention through marketing spectacles.

The Lesson from 2025

The year taught us that the gap between marketing claims and product reality grows wider when technologies are still maturing. AI, mixed reality, and smart home ecosystems all need more development time, but competitive pressure pushes companies to launch prematurely and claim readiness that doesn’t exist.

For consumers, the lesson is clear: be skeptical of revolutionary claims, especially when they’re about “AI-powered” anything. Wait for real-world reviews from actual users, not just tech enthusiasts receiving free review units. The products worth buying solve specific problems you actually have, not theoretical problems marketing teams invented.

2025’s overhyped products weren’t scams—they were ambitious attempts to push technology forward that launched before they were ready. The gap between vision and execution was the problem, exacerbated by marketing that prioritized hype over honesty.

As we move into 2026, hopefully the industry learns to temper expectations and focus on delivering products that actually work well rather than marketing campaigns promising revolutionary experiences that can’t be delivered yet.

For years my workflow relied on three separate apps: Todoist for task management, Notion for notes and documentation and Grammarly for writing assistance. Each had its purpose, each had its subscription fee, and each demanded a slice of my attention throughout the day.

Then I spent a month trying to replace all three with a single AI tool. Not because I was chasing productivity trends, but because I was genuinely tired of context-switching between apps just to get basic work done. Here’s what actually happened when I consolidated my workflow.

What I Replaced

Todoist handled my tasks and projects. I’d been using it for five years, had built elaborate workflows, and trusted it completely. Annual subscription: $60.

Notion stored everything else—meeting notes, project documentation, knowledge base, personal wiki. It had become my second brain. Monthly subscription: $10.

Grammarly caught my writing mistakes and improved clarity. I wrote enough that the premium features felt justified. Annual subscription: $144.

Total annual cost: $324. Total mental overhead: switching between three apps dozens of times daily, keeping track of what information lived where, and maintaining different organizational systems in each.

The AI Tool Experiment

I chose Claude (with Projects feature) as my replacement, though ChatGPT Plus or Gemini, or other AI assistants could work similarly. The theory: AI tools can now handle task management through conversation, store and retrieve information contextually, and provide writing assistance all in one interface.

The promise was compelling: one tool, one subscription ($20/month for Claude Pro), and one place to work. No more switching, no more wondering which app had the information I needed.

What Worked Better Than Expected

Writing assistance became invisible. With Grammarly I wrote in one place, then checked another place for suggestions. With Claude I just write naturally and ask for improvements when needed. The friction disappeared entirely.

When I draft an email or document I can immediately ask “make this more concise” or “does this sound too direct?” without switching contexts. The AI understands what I just wrote and can refine it conversational. This feels dramatically more natural than Grammarly’s sidebar suggestions.

Information retrieval got smarter. Notion required me to remember my organizational structure and navigate to the right page. Claude’s Projects feature lets me dump information and retrieve it conversationally: “What did Sarah say about the budget in last week’s meeting?” It finds the relevant context without me needing to remember where I filed it.

This worked especially well for meeting notes and project documentation. Instead of building elaborate page hierarchies, I just store information and trust the AI to surface it when relevant.

What Didn’t Work as Well

Task management felt ephemeral. Todoist showed me my tasks persistently. They lived in a structured list that I could see and manipulate. With AI, tasks only exist in conversation. I found myself asking “what are my tasks today?” multiple times because I couldn’t just glance at a list.

The AI could track my tasks and remind me when I asked, but it couldn’t replace the quick visual scan of a dedicated task manager. I missed seeing my entire workload at a glance and dragging tasks to reorder priorities.

No mobile quick capture. Todoist’s mobile app let me add tasks in seconds while walking or during meetings. Claude’s mobile experience is conversation-based, which takes longer. For quick brain dumps, the friction was noticeably higher.

Collaboration completely broke. Todoist and Notion both support sharing and collaboration. AI tools are fundamentally single-user. When I needed to share a project plan or collaborate on documentation, I had nowhere to point colleagues except clunky copy-paste from conversations.

The Surprising Middle Ground

After a month, I didn’t fully switch to AI or return to my old setup. I found a hybrid that works better than either extreme:

Kept Todoist for task management. The visual interface and quick capture are irreplaceable for now. But I reduced my usage significantly—I plan my day conversationally with Claude, then transfer concrete next actions into Todoist as needed.

Replaced Notion almost entirely. The AI handles notes, documentation, and knowledge storage better through conversational retrieval. The few remaining Notion pages are things I need to share with others.

Completely replaced Grammarly. This was the cleanest win. AI writing assistance integrated into my actual workspace beats a separate tool checking my work.

New annual cost: $240 for Claude Pro + $60 for Todoist = $300 (saving $24/year, but that’s not why this matters).

What I Actually Learned

The real insight wasn’t about replacing apps – it was about where AI genuinely changes workflows versus where traditional tools still make sense.

AI excels at: Conversational interfaces for complex queries, contextual assistance that happens inline with work, connecting information across different domains, and providing specialized help on-demand.

Traditional apps still win at: Persistent visual interfaces you can scan quickly, fast mobile capture, structured organization that multiple people can share, and reliable reference systems that don’t require asking questions.

The future probably isn’t “AI replaces all apps.” It’s AI augmenting the apps that still make sense while replacing the ones where conversation is actually better than clicking through interfaces.

Would I Recommend This?

If you’re heavily invested in productivity tools and wondering if AI can simplify your stack: try it, but don’t expect a clean replacement.

Start with one category. Writing assistance is the easiest—AI genuinely outperforms dedicated grammar tools for most people. Note-taking and knowledge management work well if you primarily work solo. Task management is harder to replace unless you don’t mind losing visual task lists.

The biggest benefit wasn’t saving money or time. It was reducing cognitive overhead. One less place to check, one less system to maintain, one less interface to remember. That mental simplification is worth more than the subscription savings.

But this only works if you’re willing to adapt your workflow to how AI tools work. If you try to force AI to behave exactly like the apps you’re replacing, you’ll just create a worse version of what you had.

The Real Question

The experiment taught me that the question isn’t “can AI replace my apps?” It’s “where does conversational interaction actually improve my workflow, and where do I still need traditional interfaces?”

For me, that split is clear now: AI for anything involving writing, research, or contextual retrieval. Traditional apps for visual task management and anything involving collaboration.

Your split will probably differ based on how you work and what matters to you. But the exercise of trying to consolidate forces you to understand what you actually value in your tools versus what’s just comfortable habit.

Three months in, I’m using fewer apps than before, but not because AI replaced everything. I’m using fewer apps because AI made me realize what I actually needed and what I was keeping out of inertia.

Related article: I tried an AI app that writes messages for me

I’ve been tracking what actually consumes time in mobile development across multiple teams and projects. Some patterns emerge clearly. More importantly, I’ve seen teams successfully tackle these problems with surprisingly simple solutions. Here’s what’s really wasting your time, and what’s actually working to fix it.

The Build Time Death Spiral

Let’s start with the obvious one: build times. But the real problem isn’t just that builds are slow—it’s that they get progressively slower as your project grows, and most teams don’t notice until it’s painful.

You start with 20-second builds. Six months later, you’re at 45 seconds. A year in, you’re approaching two minutes. It happens gradually enough that you don’t realize how much time you’re collectively losing.

How devs are fixing it: The teams I’ve seen successfully tackle this problem don’t just optimize randomly — they measure first. They use build scan tools (Gradle Enterprise for Android, Xcode build analytics for iOS) to identify actual bottlenecks rather than guessing.

Common culprils they find: annotation processors running on every build, unnecessary clean builds in CI, modules with circular dependencies that prevent parallel compilation, and resource processing on unchanged files.

The fix usually involves modularizing the project more aggressively, moving to incremental annotation processing, and setting up proper dependency management so you only rebuild what actually changed. One team I know cut their build times from 3 minutes to 45 seconds just by properly modularizing their feature modules.

The key insight: Don’t wait until builds are unbearable. Set a threshold (say, 30 seconds for local builds) and treat exceeding it as a P1 bug. Time spent optimizing builds pays itself back within weeks.

Waiting for QA Feedback Loops

Here’s a time-waster that’s invisible in time-tracking tools: the gap between when you think a feature is done and when you get feedback that it’s not.

You implement a feature, mark it ready for testing, move on to something else. Two days later, QA finds an issue. Now you need to context-switch back, remember what you were thinking, fix the issue, and repeat the cycle. The context switching overhead alone kills productivity.

How devs are fixing it: Smart teams are shrinking this feedback loop dramatically. Some approaches that work:

Developers test their own work more thoroughly before marking it ready. This sounds obvious, but it means actually installing the build on physical devices, testing unhappy paths, and checking edge cases—not just verifying the happy path works on the emulator.

Teams are setting up automated testing for common issues: missing error states, broken deep links, accessibility problems, layout issues on different screen sizes. Catching these before QA saves entire cycles.

Some teams do “desk checks” — a quick 5-minute walkthrough with QA before marking something done. It catches obvious issues immediately while the context is still loaded in your head.

The key insight: Every feedback loop iteration costs 1-2 hours of productive time in context switching. Investing 15 extra minutes upfront to catch issues early pays back immediately.

Debugging Device-Specific Issues

“Works on my device” is the mobile developer’s version of “works on my machine,” and it’s just as problematic. Issues that only appear on specific Android devices, certain iOS versions, or particular screen sizes consume enormous amounts of time.

The worst part? You often can’t reproduce the issue on your development device, so you’re debugging blind or constantly switching between devices.

How devs are fixing it: The most effective approach I’ve seen is maintaining a small device lab that covers the actual devices your users have. Not 50 devices—just 5-6 that represent your real user base.

Check your analytics. Find the top 3-4 Android devices and iOS versions your users actually use. Test on those specifically during development, not just at the end. One team reduced device-specific bugs in production by 60% just by testing on 4 specific mid-range Android devices during development instead of only on flagship phones.

For issues you can’t reproduce locally, teams are getting better at remote debugging. Firebase Crashlytics with proper logging, App Center for distribution with built-in crash reporting, and better error tracking in production means you can often identify and fix issues without reproducing them locally.

The key insight: Your iPhone 16 Pro and Pixel 9 don’t represent your users. Test on what they actually use, and test early.

Unclear Requirements and Scope Creep

Here’s the biggest time-waster that has nothing to do with code: building the wrong thing, or constantly rebuilding things as requirements change.

You implement a feature based on a design mockup and some brief notes. Partway through, you discover the mockup doesn’t cover error states. You make your best guess. Later, you learn your guess was wrong and need to redo it. Then someone realizes the feature needs to work offline, which wasn’t mentioned anywhere.

How devs are fixing it: The best teams I know have a simple rule: no implementation without a spec. Not a 20-page document—a one-page doc that answers: What are we building? Why? What are the success criteria? What are the edge cases? What’s explicitly out of scope?

The spec takes 30 minutes to write. It saves hours of rework. More importantly, writing it usually surfaces questions and assumptions that would have caused problems later.

Some teams do a quick “pre-implementation review” where the developer reads the spec, looks at designs, and comes back with questions before writing any code. This 15-minute conversation often prevents days of wasted work.

The key insight: Every hour spent clarifying requirements saves 5-10 hours of implementation and rework. The fastest code to write is code you don’t have to rewrite.

Fragmented Communication and Context Hunting

How much time do you spend hunting for information? Checking Slack, searching JIRA, looking for that design file, finding the API documentation, locating the decision that was made in some meeting you weren’t in.

This invisible overhead adds up fast. A few minutes here, a few minutes there—but it happens dozens of times per day and completely fragments your focus.

How devs are fixing it: The solution isn’t a better tool – it’s better information architecture. Teams that solve this problem have clear conventions:

All technical decisions go in one place (many teams use ADRs—Architecture Decision Records—in their repo). All design files are linked in the relevant tickets. API documentation is kept in the repo, not in external docs that get out of date. Each feature has a clear owner who’s the go-to person for questions.

Some teams maintain a simple wiki with “Start here” pages for common questions: How do I set up the project? Where are the API docs? How do I test payment flows? Where are our coding standards?

The key insight: If everyone on the team asks the same question twice, document the answer once in a findable place. The ROI is immediate.

Flaky Tests and CI Pipeline Issues

You push code. CI fails. You check the logs — it’s a test that randomly fails sometimes. You restart the build. It passes. You just wasted 20 minutes and eroded trust in your test suite.

Flaky tests are insidious because they train developers to ignore test failures. Once that happens, your entire test suite loses value.

How devs are fixing it: Zero tolerance for flakiness. When a test flakes even once, it gets fixed or disabled immediately. Never restart a flaky test hoping it passes—fix it.

Common causes of flakiness in mobile tests: timing issues (waiting for animations or network calls), order dependencies between tests, shared state that doesn’t get cleaned up, and tests that depend on external services.

Teams that solve this usually invest in better test infrastructure: proper test fixtures, deterministic clocks and schedulers, mock network responses, and isolated test data. They also run tests multiple times locally before pushing to catch intermittent failures early.

For CI pipeline issues, the fix is monitoring and alerts. Set up notifications when builds are taking longer than normal, when certain steps fail repeatedly, or when cache hit rates drop. Treat CI health as a team priority, not an afterthought.

The key insight: A flaky test is worse than no test. It wastes time and destroys confidence. Fix it immediately or remove it.

Manual Deployment and Release Processes

I still see teams where releasing an app involves a checklist of 15 manual steps, takes two hours, and requires someone senior because they’re the only one who knows all the gotchas.

This is pure waste. Every release takes hours, creates anxiety, and creates single points of failure on your team.

How devs are fixing it: Full automation of the release process. Not partial automation—full automation. A single command or button that does everything: version bumping, changelog generation, building release artifacts, running the full test suite, uploading to app stores, creating git tags, notifying stakeholders.

Tools like Fastlane make this achievable in a few days of setup work. Yes, there’s an upfront investment. But once it’s done, releases go from a half-day ordeal to a 5-minute task anyone can do.

Some teams go further and automate the entire deployment pipeline: merge to main triggers tests, successful tests trigger a beta deployment, manual approval triggers production release. Releases become routine instead of events.

The key insight: If your release process takes more than 15 minutes of human time, you’re wasting hours every release cycle. Automate it completely.

The Time Tax Compounds

The insidious thing about these time-wasters is how they compound. Slow builds make you context-switch more. Poor communication leads to building the wrong thing. Unclear requirements cause rework. Flaky tests waste time on every push. Manual deployments create bottlenecks.

A team experiencing all these problems simultaneously isn’t 50% less productive — they’re 70% or 80% less productive. Fixing them doesn’t just save time; it restores momentum and makes development actually enjoyable again.

The good news? You don’t need to fix everything at once. Pick the biggest pain point—the one that makes your team groan the loudest—and fix that first. Build momentum. Then tackle the next one.

Because the real win isn’t just saving time. It’s creating an environment where developers spend their energy solving interesting problems instead of fighting their tools and processes. That’s when great apps get built.

Not the AI camera that generates perfect portraits. Not the on-device LLM that can write emails. Not the intelligent battery management that uses machine learning to optimize charging patterns. Just battery life – the unglamorous, fundamental capability to keep working throughout the day without hunting for outlets.

This gap between what manufacturers emphasize and what users actually value reveals something important about mobile technology in 2026. We’re in an era where the flashy innovations get the headlines, but the basic reliability determines whether people actually enjoy using their devices.

The AI Feature Everyone Ignores

Open your phone’s settings and check your AI feature usage. For most people, the numbers are revealing: those cutting-edge AI capabilities that justified the phone’s price tag are barely used, if at all.

The AI photo enhancement that was demonstrated so impressively at launch? Used occasionally, mostly forgotten. The smart reply suggestions? Ignored more often than selected. The AI-powered app predictions? Marginally better than just opening your app drawer manually.

Meanwhile, battery percentage is checked compulsively throughout the day. Battery anxiety—that gnawing concern about whether your phone will last until you get home—affects user behavior more than any AI feature ever will.

People change how they use their phones to preserve battery. They lower brightness, disable features, avoid using apps they want to use, all to extend battery life. Nobody changes their behavior to preserve AI features. If anything, they disable AI capabilities to improve battery life.

What Actually Drains Your Battery in 2026

Here’s the irony: many of the AI features manufacturers promote are actively making the battery problem worse.

On-device AI processing requires significant computational power. Running large language models locally, performing real-time image processing, executing continuous environmental awareness—all of this consumes energy at rates that traditional phone tasks don’t approach.

That “intelligent” photo mode that processes every shot with neural networks? It’s costing you hours of battery life over the course of a day. Background AI processing is particularly problematic. Features that constantly monitor context, predict your needs, or prepare intelligent suggestions drain battery even when you’re not actively using the phone. The AI that’s supposedly making your phone smarter is quietly making it die faster.

Developers building mobile apps face this reality constantly. Every AI feature they add comes with a battery cost. Most are choosing to make those features optional, off by default, or severely limited because the battery drain destroys the user experience.

The Features Users Actually Want

When researchers ask people what would make them happier with their phones, AI features rarely make the top ten. What does appear consistently:

Longer battery life. Not smarter battery management through AI—just more capacity and better efficiency so the phone lasts longer between charges.

Faster charging. When the battery does run low, users want it back to usable levels quickly. This is a hardware and physics problem, not an AI opportunity.

Better performance consistency. Users want apps to launch quickly, scrolling to be smooth, and the phone to stay responsive throughout the day. AI features often work against this, consuming resources that could make basic operations faster.

Reliable connectivity. Good cellular signal, stable WiFi, Bluetooth that just works. These are infrastructure and radio problems that AI can’t solve.

Display quality that doesn’t destroy battery. Bright, readable screens that don’t consume 40% of the battery budget.

Notice what’s missing from this list: AI capabilities. It’s not that users hate AI features—many are genuinely useful. It’s that they’re not more important than the fundamentals, and they often make the fundamentals worse.

The Developer Perspective

Talk to mobile app developers about what constraints shape their work in 2026, and battery considerations dominate the conversation.

Every background task is evaluated through the lens of battery impact. Every network request is optimized to reduce radio usage. Every UI animation is tuned to minimize rendering cost. Developers obsess over battery efficiency because they know users will delete apps that drain battery, regardless of how clever the AI features are.

Meanwhile, implementing AI features is often a reluctant exercise in meeting stakeholder expectations. “Marketing wants an AI feature” is a common requirement. “Users complained about battery drain” is a common bug report. Guess which one developers take more seriously?

The tools and frameworks developers use reflect this priority. Battery profiling is built into every IDE. Performance monitoring emphasizes energy impact. Platform updates focus on efficiency improvements. AI capabilities are added to SDKs, but the emphasis is always on making them efficient enough to be usable, not on making them more powerful.

When AI Actually Helps (Rarely)

To be fair, some AI applications genuinely improve the mobile experience without destroying battery life. The key differentiator: they solve problems users actually have rather than problems manufacturers think are interesting.

Computational photography that happens when you take a photo, not continuously in the background, can produce noticeably better images without significant battery cost. Users appreciate this because better photos is a clear, understandable benefit.

Spam filtering using AI to block robocalls and filter messages provides obvious value and runs efficiently because it only activates when needed.

Accessibility features powered by AI—like live captions or voice control—provide enormous value to users who need them, and those users are willing to accept battery tradeoffs for functionality that makes their device usable.

Predictive text and autocorrect has been AI-powered for years, runs efficiently, and genuinely helps most users type faster and more accurately.

The pattern: AI features that activate on-demand, solve real problems, and don’t run continuously in the background can justify their battery cost. AI features that run constantly, solve theoretical problems, or exist primarily for marketing purposes can’t.

The Physics Problem AI Can’t Solve

Here’s the fundamental issue: battery technology improves slowly. Despite decades of research and massive investment, battery energy density increases by only a few percent per year. We’re constrained by physics and chemistry in ways that software innovation can’t overcome.

Meanwhile, AI feature complexity grows exponentially. Each generation of AI models is larger, more capable, and more computationally expensive than the last. The gap between what AI features want to do and what batteries can support is widening, not closing.

Manufacturers try to paper over this gap with “intelligent battery management”—AI that optimizes charging patterns, predicts usage, and allocates power. These features help marginally, but they’re fundamentally using AI to manage problems that other AI features create. It’s optimization at the margins, not solutions to the core issue.

What would actually solve the battery problem? Bigger batteries (heavier phones, which users don’t want), more efficient processors (which we’re getting, but not fast enough to keep up with AI demands), or fewer power-hungry features running constantly (which defeats the purpose of adding AI capabilities in the first place).

The Trust Factor

Battery life has another dimension that AI features lack: trust and reliability. Users need to trust that their phone will last through their day. This trust is built through consistent performance, not occasional impressive capabilities.

A phone that usually lasts all day but sometimes dies unexpectedly because an AI feature decided to process something in the background creates anxiety and erodes trust. Users start treating their phone as unreliable, which changes the entire relationship with the device.

Conversely, a phone that reliably lasts from morning to night builds confidence. Users don’t think about battery, which means they can think about everything else they want to do with their phone. This reliability is more valuable than any individual AI feature.

Developers understand this deeply. An app that occasionally drains battery, even if it provides amazing AI capabilities when it does, will get uninstalled. An app that consistently preserves battery, even if it lacks cutting-edge features, will be kept and used regularly.

What 2025 Actually Teaches Us

The persistent importance of battery life over AI features in 2025 reveals a broader truth about technology adoption: fundamentals matter more than innovations.

Users will tolerate missing AI features. They won’t tolerate phones that die before the day ends. They’ll disable AI capabilities to extend battery life without hesitation. They’ll choose older phones with better battery life over newer phones with more AI features.

This doesn’t mean AI features have no value—some genuinely improve user experience. But it does mean they’re secondary considerations. They’re nice-to-haves that become liabilities when they interfere with core functionality.

For mobile developers, this creates a clear priority order: make sure your app runs efficiently, preserves battery, and performs reliably. Then, if battery budget allows and user value is clear, consider AI features. Never the reverse.

For phone manufacturers, the message should be equally clear: users will remember the phone that lasted all day far longer than they’ll remember the AI demo that impressed them in the store. Battery life is the feature that determines daily satisfaction. AI is the feature that makes for good marketing slides.

The Unglamorous Truth

Battery life isn’t exciting. It doesn’t demo well. It’s hard to show in commercials. It doesn’t give tech reviewers much to discuss beyond “it lasts X hours in our test.”

But it’s what users actually care about. It’s what determines whether people enjoy using their phones or spend the day anxiously monitoring battery percentage. It’s what shapes developer decisions and app architectures. It’s what influences purchase decisions more than any AI capability.

In 2025, amid all the AI hype and impressive technological demonstrations, battery life remains the most important feature most phones don’t talk about enough. Because while AI features might be the future, battery life is what gets users through today.

And today, repeated day after day, is what actually matters.

The biggest productivity gains in mobile development don’t come from learning the hottest new framework or adopting the latest architecture pattern. They come from tiny workflow adjustments that eliminate friction from tasks you do fifty times a day.

I’m talking about the small stuff: switching between files, running builds, checking designs, testing on devices. Individually, each action takes seconds. Cumulatively, they define whether you’re in flow state or constantly interrupted by tooling overhead.

After years of building mobile apps and obsessively tracking what actually slows me down, I’ve identified workflow micro-optimizations that genuinely add up. These aren’t dramatic overhauls — they’re small changes that compound into hours saved every week. Here’s what actually works.

Master Your IDE’s Navigation (Not Just Search)

Everyone knows Command+Shift+O (or Ctrl+Shift+N) to search for files. But most developers stop there and miss the navigation features that eliminate the search step entirely.

Learn “Go to Last Edit Location” (Command+Shift+Delete on Mac). When you’re bouncing between files—implementing a feature in your ViewModel, updating the UI in your Fragment, adding a network call in your repository—this single shortcut takes you exactly where you were working, with your cursor at the right line. No searching, no scrolling.

Similarly, “Recent Files” (Command+E) with the search filter lets you type a few characters and jump to any recently-opened file instantly. Unlike file search, it’s scoped to your current context, which means fewer keystrokes and faster results.

Set Up Proper Build Variants for Daily Development

How many times a day do you build and run your app? If you’re like most developers, dozens. And if each build includes every feature, library, and build configuration you’ll eventually ship, you’re wasting enormous amounts of time.

Create a “dev” build variant that strips out everything non-essential: analytics, crash reporting, complex animations, heavy background tasks, third-party SDKs you’re not actively working on. Enable R8 only in release builds. Disable unnecessary build steps.

On a mid-sized app, this can cut build times from 45 seconds to 20 seconds. That’s 25 seconds saved per build. If you build 40 times a day (conservative for active development), you’ve just saved 16 minutes daily. That’s over an hour per week, and you get the bonus of staying in flow state rather than context-switching during every build.

Go further: set up a minimal build variant with a single feature for when you’re doing focused work. Building the entire app to test one screen is usually overkill.

Use Template Files for Repetitive Patterns

Every project has patterns you recreate constantly: a new Fragment with the standard setup, a ViewModel with dependency injection configured, a RecyclerView adapter, a network repository class, a SwiftUI view with your team’s standard structure.

Create file templates for these. In Android Studio: Settings → Editor → File and Code Templates. In Xcode: create file snippets or use custom templates.

Now instead of copying an existing file, renaming things, and deleting irrelevant bits (error-prone and surprisingly time-consuming), you generate the structure you need with the correct naming from the start.

This saves 2-3 minutes every time you need to create these files. If you’re actively developing new features and creating 3-4 of these files daily, that’s another 10-12 minutes saved per day, or roughly an hour per week.

Automate Device Testing Setup

How much time do you spend installing builds on test devices, clearing app data between test runs, navigating to the specific screen you’re testing, and setting up test states?

Write scripts. A simple shell script or Gradle task can: uninstall the current build, install the new one, grant necessary permissions, and launch directly to the screen you’re testing. Add flags to your app that let you skip onboarding, bypass login with test credentials, or jump to specific states.

For iOS, create schemes that configure these options. For Android, use custom debug-only intents or deep links.

The setup time for this is maybe an hour. The daily savings when you’re testing a feature 20+ times? Easily 15-20 minutes, often more. That’s over an hour weekly, and it eliminates the tedious manual steps that break your concentration.

Keep a Running Debug Log (Not In Your Head)

Here’s a workflow change that’s psychological as much as technical: maintain a simple text file where you note what you’re working on, weird behaviors you’ve noticed, and things to investigate later.

When you spot something odd but don’t have time to dig into it right now, you log it. When you make a temporary workaround, you note it. When you change something that might affect other features, you write it down.

This takes 30 seconds when you do it, but saves 10-15 minutes later when you’re trying to remember “what was that weird thing I noticed yesterday?” or when a bug report comes in and you realize you’d already spotted the issue but forgot about it.

It also helps during daily standups or when handing off work—you have a record of what you actually did rather than trying to reconstruct it from memory.

Set Up Automatic Resource Organization

Every app accumulates drawables, string resources, layouts, and assets. When these aren’t organized, you waste time hunting for the right file or accidentally duplicating resources that already exist.

Create a simple naming convention and folder structure, then enforce it automatically with lint rules or git hooks. For example: ic_feature_action_size.xml for icons, organized by feature in subdirectories if your project supports it.

Add a custom lint check that flags resources not following your naming convention. Set up a git pre-commit hook that warns about unused resources or duplicates.

This prevents the “where did I put that icon?” problem and the “we have three versions of the same drawable with different names” problem. Small savings each time, but over a week of active development, this easily saves 30-60 minutes of resource hunting and cleanup.

Use Keyboard Shortcuts for Build Actions

Most developers click the “Run” button or use a single shortcut to build and run. But you’re not always running on a device—sometimes you just need to compile, or sync Gradle, or clean the build.

Learn these distinct shortcuts:

• Build module (usually faster than building everything)
• Run without building (when you know the code hasn’t changed)
• Clean build (only when actually needed)
• Sync Gradle (faster than full build when you only changed dependencies)

Using the right action for the moment saves 5-30 seconds per build cycle. If you’re building conservatively 30 times a day and using the right action saves 10 seconds average, that’s 5 minutes daily, or 25 minutes weekly.

Batch Similar Work Together

Context switching is expensive. Your brain needs time to load the mental model for each type of work: UI implementation requires different thinking than business logic than network integration than testing.

Instead of jumping between different types of work throughout the day, batch similar tasks together. Spend a focused hour on UI implementation, then switch to an hour of business logic, then an hour of testing.

This isn’t a workflow tool change, but it’s a workflow pattern change. The time savings come from reduced context switching overhead. Most developers find they complete tasks 20-30% faster when batching similar work, which translates to 1-2 hours saved weekly.

Create Quick Access to Common Commands

How often do you run the same complex commands? Starting your backend locally, running specific test suites, cleaning build caches, deploying to test environments, generating code from protobuf or GraphQL schemas?

Create shortcuts for these. Use IDE tasks, shell aliases, or custom Gradle tasks. Put frequently-used commands in a README or a scripts folder with memorable names.

Instead of remembering (or searching Slack for) the exact command with all its flags, you type run-backend or test-auth or clean-all. Each command execution saves maybe 20-30 seconds. Run 10 of these per day and you’ve saved 3-4 minutes daily, or about 20 minutes weekly.

The Compounding Effect

None of these changes are dramatic. None will double your productivity tomorrow. But they compound.

Let’s be conservative and say these optimizations collectively save 30 minutes per day. That’s 2.5 hours per week, or roughly 120 hours per year. That’s three full work weeks.

But the real benefit isn’t just time—it’s maintaining flow state. When you eliminate the small friction points that constantly interrupt your thinking, you stay in the zone longer. You solve problems faster. You make fewer mistakes.

The best workflow optimizations are the ones you stop noticing because they’ve become natural. They’re not tools you use, they’re patterns you’ve internalized that let you focus on what actually matters: building great apps.

Start with one or two changes this week. Stick with them until they’re habitual. Then add another. Within a month, you’ll wonder how you ever worked any other way.

PS: Once again:

Worth buying

• Smart lights
  Easy setup, reliable, and instantly useful. Scheduling and voice control actually make sense here.-

• Smart thermostats
  One of the few devices that can save money. Automatic adjustments and remote control are genuinely helpful.

• Smart plugs
  Cheap, flexible, and underrated. They turn regular devices into smart ones with almost no effort.

• Video doorbells
  Great for package alerts and quick security checks, especially if you’re often away.

Often not worth it

• Smart refrigerators
  Expensive, overcomplicated, and rarely used beyond basic cooling.
• Too many voice assistants
  One or two is enough. More just adds noise and privacy concerns.
• Complex security systems
  High setup effort, subscriptions, and false alerts make them frustrating.

Before you buy

Ask yourself:

• Will I use this every week?
• Does it save time or effort?
• Does it require a subscription?
• Will it still work without internet?

If not, skip it.

Final take

Good smart home tech disappears into the background. If a device feels like work, it’s not worth it. Start simple and focus on reliability over novelty.

Here’s a clear breakdown.

What AI can actually do well

Write and rewrite text
AI is excellent at drafts, summaries, follow-ups, and rewriting messages. It’s faster than starting from scratch and works best as a first pass.

Edit photos and videos
Removing objects, fixing lighting, and generating short clips are now fast and reliable for everyday use.

Help developers move faster
Tools like Android Studio Gemini assist with code suggestions, explanations, and debugging directly inside the development environment. It doesn’t replace developers, but it speeds up routine work and reduces friction.

Filter and organize information
From email sorting to notification prioritization, AI helps reduce noise and surface what matters.

Work offline (sometimes)
With more on-device AI, features like transcription and image processing can run without an internet connection.

What AI still struggles with

True understanding and judgment
AI can sound confident while being subtly wrong, especially in complex or unfamiliar situations.

Emotional nuance
Humor, sarcasm, conflict, and sensitive conversations still require human judgment.

Complex decision-making
AI can assist, but it shouldn’t be trusted to make important decisions on its own.

What’s overhyped

“Fully autonomous” assistants
AI still needs guidance. It doesn’t manage your life without supervision.

AI replacing creative or technical roles
AI tools help writers and developers, but they don’t replace original thinking, taste, or experience.

One app that does everything
Most all-in-one AI tools are average at many things rather than great at one.

What this means for everyday users

The most useful AI features in 2026 aren’t flashy. They’re quiet, integrated, and practical — saving time, reducing friction, and working in the background.

If an AI feature needs constant correction, it’s probably not ready.

Bottom line

AI in 2026 is genuinely useful, but it’s not magic. Used as an assistant — whether for writing, editing or coding – it improves everyday tasks. The key is knowing where it helps and where the hype still outweighs reality.

For mobile developers in 2026, “every screen” isn’t a nice-to-have feature or an enterprise requirement—it’s the baseline expectation. Users don’t think in terms of device categories anymore. They expect apps to work well wherever they happen to open them, whether that’s a foldable unfolding mid-task, a phone casting to an external display, or a tablet running three apps simultaneously in Stage Manager.

This shift changes everything about how we build apps. “Mobile-first” thinking assumed a primary form factor with occasional adaptations. Modern app development assumes constant variability. Your app isn’t just running on different devices—it’s running in different postures, with different input methods, in different multitasking configurations, often changing dynamically within a single session.

The challenge isn’t supporting more devices. It’s building systems that adapt gracefully to contexts you can’t fully predict. Here’s how to approach building apps that work everywhere without losing your mind—or your users.

1. The Reality of Modern Screens (It’s Not About Size Anymore)

Understanding modern screen diversity starts with unlearning what we thought we knew about device categories.

Screen Ranges Replace Fixed Devices

There’s no such thing as “the tablet size” or “the phone size” anymore. iPads range from 8.3 inches to 12.9 inches. Android phones span from compact 6-inch devices to 6.8-inch flagships that approach small tablet territory. Foldables transition between phone and tablet sizes mid-use.

More importantly, window sizes are often independent of physical screen size. Your app on a 12.9-inch iPad might occupy a 4-inch-wide column in Stage Manager. Your app on a 6.5-inch phone might be letterboxed when casting to a TV. The device tells you almost nothing about the actual space you have to work with.

Modern frameworks recognize this with breakpoint systems based on actual available width, not device detection. Compact, medium, and expanded aren’t “phone, tablet, desktop”—they’re descriptions of how much space you actually have to present information.

Resizable Windows and Posture Changes

On Android, users can freely resize app windows in multi-window mode, dragging them to any width they want. On iPadOS, Stage Manager lets users adjust app sizes dynamically. Windows laptops running Android apps offer similar flexibility.

This means your layout can change at any moment, not just at app launch. Users expect this to work smoothly, not to trigger full-screen refreshes or lose their place in the app. Your UI needs to reflow gracefully, maintaining context across size transitions.

Foldables add another dimension: posture changes. A Galaxy Z Fold transitions from phone to tablet configuration as it unfolds, changing aspect ratio, screen size, and available space simultaneously. Your app needs to handle this transition while the user is actively using it.

External Displays and Unexpected Contexts

Phones mirror to TVs. Tablets connect to external monitors. Samsung DeX turns a phone into a desktop environment. Users increasingly expect apps to work in contexts you might never have tested.

The key insight: you’re not designing for specific hardware configurations. You’re designing for variability itself. The question isn’t “what does our app look like on an iPad Pro?”—it’s “how does our app adapt when available space changes, regardless of the underlying hardware?”

If you’re still thinking in terms of device detection and fixed breakpoints, you’re already behind. Modern apps need to be inherently adaptive, responding to actual available space and input methods rather than trying to recognize specific devices.

 Read more: Building once, running everywhere: what multi-device really means in 2026

2. Designing Experiences That Feel Right Everywhere

Adaptive layouts are pointless if the resulting experience feels awkward. The goal isn’t just to make your app “work” on different screens—it’s to make it feel natural and appropriate for each context.

Designing for Ranges, Not Devices

Effective multi-screen design starts with understanding that you’re creating a system, not a collection of device-specific layouts.

Think in terms of three core ranges:

• Compact: Limited width, vertical scrolling dominant, one thing at a time
• Medium: Enough space for related content, selective side-by-side layouts
• Expanded: Room for spatial organization, persistent navigation, multiple content areas

These aren’t device categories—they’re descriptions of how much information you can present comfortably. A compact layout might appear on a phone in portrait, a tablet in narrow split-screen, or an app in a Stage Manager column.

Using Space Intentionally

The biggest mistake in multi-screen design is stretching phone layouts to fill larger screens or cramming tablet layouts into smaller spaces. Both approaches fail because they don’t respect the purpose of the space.

On compact screens, embrace vertical flow. Users expect to scroll. Trying to fit everything “above the fold” creates cramped, cluttered interfaces. Focus on one primary task at a time.

On expanded screens, use horizontal space for meaningful relationships. Show list and detail together when both are relevant. Provide persistent navigation instead of hiding it behind menus. Let users see related information simultaneously.

The key is intentionality: every use of space should serve a purpose. Empty space is better than stretched interfaces, and dense layouts are better than artificial expansion.

Content Density and Readability

What’s readable on a 6-inch phone held 12 inches from your face is uncomfortably large on a 13-inch tablet held 24 inches away. What’s comfortably dense on a tablet is cramped and tappable on a phone.

Adapt your content density to match viewing distance and input precision. Larger screens typically mean more distance, which means you can increase information density without sacrificing readability. Smaller screens need more whitespace and larger touch targets because precision is harder.

This isn’t just about font sizes—it’s about how much information appears simultaneously, how tightly grouped interactive elements are, and how much effort users need to exert to parse what they’re seeing.

 Read more: Designing apps that actually feel good on phones, tablets, and foldables

3. Navigation That Adapts Without Confusing Users

Navigation is where most multi-screen apps fall apart. It’s easy to make navigation “work” at different sizes. It’s hard to make it feel coherent across those sizes.

Navigation as a System, Not a Component

The mistake most developers make is treating navigation as a component you swap out at different breakpoints. Bottom nav for phones, side drawer for tablets, top tabs for certain contexts. This creates fragmentation—users learn your navigation once on their phone, then encounter a completely different system on their tablet.

Better approach: think of navigation as a system that moves and reorganizes, but maintains consistency in structure and behavior. The same top-level sections should exist regardless of screen size. The same hierarchy should be apparent. Only the presentation changes.

When Bottom Nav Breaks

Bottom navigation works beautifully on phones in portrait. It’s ergonomic, always visible, and provides direct access to top-level sections. But it fails on larger screens and landscape orientations.

On tablets, bottom navigation wastes vertical space and creates an awkward visual balance. The navigation is distant from the content it controls. Users’ hands aren’t naturally positioned at the bottom of a 12-inch screen.

In landscape, bottom navigation consumes critical horizontal space and often feels cramped.

The solution isn’t to replace bottom nav entirely—it’s to transition it. On medium and expanded screens, bottom nav can become a side rail (still persistent, but better positioned) or integrate into a top navigation system. The key is maintaining the same destinations and structure, just repositioned.

When Side Nav Helps

Side navigation—whether as a rail or a drawer—makes sense when you have horizontal space and vertical content. It keeps navigation visible while leaving content area unobstructed. It scales well when you have many destinations or hierarchical structure.

But side nav fails when it’s just bottom nav rotated 90 degrees. Don’t take five icons and stack them vertically if they worked horizontally—that’s not adaptation, that’s just rotation.

Avoiding Redundant Controls

One of the worst multi-screen experiences is navigation that multiplies. You see this when apps keep bottom nav AND add a side drawer AND include top navigation, all providing overlapping access to the same destinations.

Redundant navigation doesn’t help users—it creates decision fatigue and makes the interface feel cluttered. If your app has three ways to get to settings, you haven’t made settings more accessible; you’ve just added visual noise.

Navigation should move and reorganize across screen sizes, not multiply. The number of top-level destinations shouldn’t change based on screen size. The entry points should be clear and singular, just positioned differently.

 Read more: What breaks first when your app goes multi-device (and how to avoid it)

4. Multi-Window and Multitasking: Where Theory Meets Reality

Building for “every screen” isn’t just about supporting different screen sizes—it’s about handling the reality that your app is rarely the only thing users are looking at.

Split-Screen Usage Patterns

On Android and iPadOS, users regularly run apps side-by-side. Your app might occupy half the screen, a third, or a resizable portion that changes as users adjust the split.

The critical insight: split-screen isn’t an edge case for power users. It’s how normal people multitask. They’re watching a video while texting, comparing prices while shopping, taking notes while reading, following a recipe while checking messages.

Your app needs to work well when it’s not the primary focus. It needs to handle narrow widths gracefully. It needs to maintain state when users switch focus to the other app. It needs to respond to dynamic resizing as users adjust the split ratio.

Live Resizing and State Preservation

Users don’t resize your app once and leave it. They adjust splits during active use. They rotate devices mid-task. They fold and unfold foldables while viewing content.

Every resize is an interruption. If your app reloads content, resets scroll position, or loses form input during these transitions, you’ve broken the user’s flow.

The technical challenge: preserving meaningful state through layout changes without breaking performance. The UX challenge: making these transitions feel smooth and predictable, not jarring.

Minimize, Restore, and Overlap

On desktop environments (DeX, Windows subsystems, Chrome OS running Android apps), your app can be minimized, restored, overlapped by other windows, and partially obscured.

Users expect desktop-like window behavior in these contexts. Your app should handle being background, return quickly when foregrounded, and work sensibly when only partially visible.

The mistake developers make is assuming mobile apps always run full-screen. Modern reality: your app shares space constantly. Design for interruption and background state as normal conditions, not edge cases.

External Displays

Phone mirroring to TVs, tablet external monitor support, and desktop docking modes mean your app might render on screens you’ve never considered.

The challenge isn’t just size—it’s input methods and viewing distance. A UI designed for touch at 12 inches might appear on a 50-inch TV viewed from 10 feet away. Controls that work with fingers might be awkward with a remote or mouse.

You can’t test every scenario, but you can design resilient systems that adapt to available space and degrade gracefully in unexpected contexts.

 Read more: Multi-window, multi-screen, multi-problem: lessons from real-world apps

5. Input Changes Everything (Touch, Keyboard, Mouse, Stylus)

Screen size gets all the attention, but input method defines how users actually interact with your app. The same interface can feel completely different depending on whether someone’s using touch, a keyboard, a mouse, or a stylus.

Touch vs Precision Input

Touch interfaces need larger targets, more spacing, and forgiving hit areas. Mouse interfaces can handle smaller controls, denser layouts, and hover interactions. Keyboard interfaces need visible focus states and logical tab order.

The problem: modern devices support multiple input methods simultaneously, and users switch between them fluidly. A tablet user might primarily use touch, occasionally grab a keyboard for text entry, and use an Apple Pencil for annotations.

Your app can’t assume a single input method. It needs to work well with all of them, adapting interaction patterns to match what the user is actually doing.

Keyboard Navigation Expectations

When someone attaches a keyboard to their tablet or phone, they expect keyboard shortcuts to work. Tab should move focus logically through interactive elements. Arrow keys should navigate lists. Standard shortcuts (Cmd+S, Cmd+F) should do expected things.

Most mobile apps fail here completely. They’re designed for touch and treat keyboard input as an afterthought. This creates frustration for users who want to work efficiently with external keyboards.

The fix isn’t complicated: proper focus management, visible focus indicators, logical tab order, and handling standard keyboard shortcuts. But it requires thinking beyond touch-first design.

Hover States and Progressive Disclosure

On devices with mice or trackpads, hover states provide valuable progressive disclosure. You can show additional context, reveal actions, or provide tooltips without cluttering the default view.

But hover doesn’t exist on touch devices. Any critical functionality hidden behind hover is inaccessible to touch users.

The solution: use hover for enhancement, never for essential functionality. Show additional context on hover for precision input users, but ensure touch users can access the same information through taps or long-presses.

Gesture Fallbacks

Gestures like swipe-to-delete or pinch-to-zoom are intuitive on touch but don’t map to keyboard or mouse input. Every gesture needs a fallback—an explicit button or menu option that achieves the same result.

This isn’t just accessibility—it’s usability. Some touch users never discover gestures. Users with external input devices can’t perform them. Gestures should be shortcuts for efficiency, not the only way to accomplish tasks.

The key principle: input method should never determine whether users can accomplish a task, only how efficiently they can do it.

6. State, Performance, and Trust

Multi-screen apps have a hidden requirement that breaks user trust when violated: state preservation. If resizing your app causes content to reload, forms to clear, or scroll position to reset, users will avoid resizing—or worse, avoid your app entirely.

Preserving State Across Resizes

When your app transitions from compact to expanded layout, users expect their context to remain intact. If they were reading an article, they should stay at the same position. If they were filling out a form, their input should persist. If they had a modal open, it should remain open.

This sounds obvious, but it’s technically challenging. Layout changes often trigger lifecycle events that reset state. Components remount. ViewModels recreate. State gets lost.

The fix requires deliberate architecture: separating presentation state (which can change) from content state (which must persist). Using proper state management that survives configuration changes. Testing explicitly for state preservation during resizes.

Avoiding Layout-Triggered Re-renders

Performance problems in multi-screen apps often stem from unnecessary re-renders during layout changes. When available space changes, components recalculate layout, which triggers measurements, which causes re-renders, which can create cascading updates throughout your component tree.

For simple layouts, this happens fast enough to not matter. For complex UIs—especially those with lists, grids, or data visualizations—this can cause visible lag or frame drops during resizes.

The solution: memoization, proper dependency management, and avoiding layout calculations that trigger business logic. Separate layout concerns from data concerns. Let layout change without forcing data to reload.

Performance Consistency Across Sizes

An app that performs smoothly on a phone but stutters on a tablet feels broken, even if it’s technically functional. Users expect consistent performance regardless of screen size.

The challenge: larger screens often mean more content visible, more complex layouts, and more pixels to render. Naive scaling can destroy performance.

Test performance at every breakpoint. Profile frame rates during resizes. Ensure your app isn’t just functional at large sizes but actually pleasant to use. Smooth performance builds trust; janky performance destroys it.

Why Losing State Destroys Trust

Every time users resize your app and lose their place, they learn not to resize your app. They keep it small on tablets even though larger layouts would be better. They avoid multi-window mode. They work around your app instead of with it.

State preservation isn’t a technical detail—it’s a trust signal. It tells users whether your app respects their context and workflow. Get it wrong, and everything else you’ve built becomes less valuable.

 Read more: What breaks first when your app goes multi-device (and how to avoid it)

7. Feature Scaling: Why Parity Is the Wrong Goal

One of the most common mistakes in multi-screen development is assuming every feature should work identically everywhere. Feature parity sounds like fairness, but it often results in compromised experiences across all screen sizes.

Why “Everything Everywhere” Fails

Trying to provide every feature at every screen size forces compromises that make nothing work well. Complex features get cramped on small screens. Simple features feel lost on large screens. Navigation becomes cluttered trying to expose everything everywhere.

The better approach: selective capability based on context. Some features genuinely work better on larger screens. Some features make sense only with certain input methods. Some features are optimized for specific usage contexts.

This doesn’t mean arbitrary restrictions—it means honest assessment of where features actually provide value.

When Features Should Scale Up

Data-rich features benefit enormously from larger screens. Analytics dashboards, comparison tools, detailed forms, multi-panel workflows—these improve dramatically when they can use more space intelligently.

On compact screens, these features might work, but they require scrolling, tabbing between views, or hiding information. On expanded screens, you can show related information simultaneously, reduce navigation overhead, and provide richer visualization.

Scale these features up by using additional space for meaningful relationships, not just making everything bigger. Show list and detail together. Display comparison views side-by-side. Provide richer data visualizations that would be cramped on smaller screens.

When Features Should Disappear

Some features don’t scale down well and shouldn’t try. Complex editing tools designed for precision input don’t work well on small touch screens. Features that require seeing large amounts of information simultaneously can’t be forced into compact layouts without compromising their usefulness.

It’s okay for certain features to be unavailable on compact screens if the alternative is a frustrating, barely-functional experience. Be honest with users: “This feature works best on tablets” is better than pretending a terrible experience is acceptable.

Respecting User Context

The decision about which features to show where shouldn’t be arbitrary—it should reflect actual user needs in different contexts.

People using phones are often on the go, focused on quick tasks, working with one hand. Features that require sustained attention, complex input, or detailed analysis are poor fits for this context.

People using tablets or desktop environments are often settled in, have more time, can use external input devices. This context supports different feature sets.

Match feature availability to context, and users will understand. Force features into inappropriate contexts, and users will be frustrated.

 Read more: Apple, Google, and Samsung are all betting on on-device AI (as an example of selective capability rollout)

8. Where AI Helps — And Where It Doesn’t

AI tools have changed how we build multi-screen apps, but not always in the ways the hype suggests. Understanding where AI genuinely accelerates development versus where it creates new problems is critical for modern mobile developers.

AI in IDEs for Layout and Refactoring

AI excels at generating responsive layout code. Describe a layout structure—”two-column grid that collapses to single column on compact screens”—and modern AI tools can generate working SwiftUI or Compose code that implements it correctly.

This acceleration is real. What used to take 20 minutes of writing constraints and testing breakpoints now takes 2 minutes of reviewing and refining AI-generated code. For boilerplate layout work, AI genuinely saves time.

AI also helps with refactoring existing layouts to be responsive. It can identify hard-coded sizes, suggest adaptive alternatives, and help migrate View-based layouts to Compose or SwiftUI patterns.

Faster Iteration, Not Better Decisions

Where AI doesn’t help: making the actual design decisions about how your app should adapt. AI can generate a responsive layout, but it can’t tell you whether showing list and detail together on tablets is the right choice for your app. It can’t determine which navigation pattern fits your content structure. It can’t balance feature availability across screen sizes.

These decisions require understanding your users, your content, and your product goals. AI provides implementation speed, not design insight.

The risk is using AI’s implementation suggestions as design validation. “AI suggested this layout, so it must be right” is a trap. AI generates plausible patterns, not optimal solutions for your specific context.

Avoiding AI-Driven Design Shortcuts

The biggest mistake I see: developers using AI to bypass learning responsive design principles. AI can generate adaptive layouts, but if you don’t understand why the generated code works, you can’t evaluate whether it’s the right approach or debug when it fails.

Use AI to accelerate implementation of designs you understand. Don’t use it to avoid understanding responsive design fundamentals. The developers who get the most value from AI tools are those who already know how to build responsive UIs manually—they use AI for speed, not as a replacement for knowledge.

 Read more: AI in IDEs: what actually helps developers (and what gets in the way)

9. Testing for Real Usage, Not Ideal Demos

The gap between “our app works on tablets” and “our app actually works well when people use tablets” is enormous. That gap is where most multi-screen apps fail.

Resizing Mid-Task

Don’t just test your app at different sizes—test resizing during active use. Fill out a form, then resize. Scroll through a list, then switch orientations. Play a video, then enter split-screen mode.

Real users don’t launch your app at optimal size and leave it there. They resize dynamically, often while in the middle of tasks. Your app needs to handle these transitions gracefully without losing state, breaking layouts, or interrupting workflows.

Multi-Window Testing

Test your app actually running alongside other apps, not just in multi-window mode in isolation. See how it behaves when the other app is playing audio. When notifications appear from the other app. When users switch focus back and forth rapidly.

The real-world scenario isn’t your app in a carefully controlled split-screen demo—it’s your app competing for attention with messages, videos, documents, and everything else users do simultaneously.

Keyboard-Only Flows

Attach a keyboard and try using your app without touching the screen. Can you navigate with tab? Do focus states make it clear where you are? Do standard shortcuts work? Can you accomplish core tasks efficiently?

If keyboard navigation feels like an afterthought, it is—and users with keyboards will notice immediately. This isn’t just accessibility; it’s basic usability for the growing number of users who attach keyboards to tablets and expect desktop-like efficiency.

Long-Session Fatigue

Test your app during extended sessions at different sizes. What feels fine for 5 minutes might become uncomfortable after 30. Information density that seems efficient initially might feel overwhelming during sustained use.

Long-session testing reveals issues that quick demos miss: font sizes that strain eyes over time, navigation patterns that become tedious with repetition, layouts that waste space in ways that accumulate frustration.

The key principle: if it feels awkward to you during testing, it will feel worse to users in real contexts. Don’t rationalize away discomfort—it’s signal that something needs improvement.

10. A Practical Mental Model for Every-Screen Apps

After years of building apps for multiple screens, I’ve settled on a mental model that helps make good decisions quickly. Think of every-screen apps as having five key principles:

One Foundation

Your app’s core functionality, data model, and business logic should be identical regardless of screen size. The foundation doesn’t change—only the presentation layer adapts.

This principle keeps you from creating divergent codebases where tablet and phone versions drift apart, accumulating different bugs and requiring separate maintenance.

Many Contexts

Users encounter your app in wildly different contexts: rushed and mobile, settled and focused, multitasking and distracted, on large displays with precision input, on small screens with one hand.

Design for context diversity, not device diversity. The question isn’t “how does this work on an iPad” but “how does this work when someone has space, time, and a keyboard?”

Intentional Adaptation

Every adaptation should serve a purpose. Don’t change layouts just because you can—change them because the different context enables a better experience.

Ask: “Why is this different at this size?” If the answer is “because it’s a tablet” rather than “because we can show related information together,” you’re adapting arbitrarily, not intentionally.

Calm Transitions

State should persist. Layouts should reflow smoothly. Users shouldn’t notice the technical complexity of what’s happening during resizes or orientation changes.

The best multi-screen experiences feel effortless because the transitions are calm and predictable. The worst feel fragile because every change triggers visible problems.

Selective Capability

Not everything needs to work everywhere. Features can scale based on available space and input methods, as long as the logic is defensible and communicated clearly.

Don’t apologize for selective capability—embrace it as honest design. An excellent small-screen experience with a subset of features beats a cramped everything-everywhere compromise.

This mental model provides a framework for making countless micro-decisions during development. When you’re unsure whether to show something differently at different sizes, run it through these principles. Usually the right answer becomes clear.

11. Conclusion: Building for Change, Not Devices

The screens we’re building for today won’t be the screens we’re building for in three years. New form factors will emerge. Window management will evolve. Users will develop new multitasking patterns. The specific devices and contexts will change.

What won’t change: the need for apps that adapt gracefully to variability.

The mistake most developers make is optimizing for current devices—adding specific support for today’s foldables, today’s tablet sizes, today’s desktop environments. This approach is always behind, always reactive, always accumulating device-specific code that becomes technical debt.

The better approach: build systems that are inherently adaptive. Design for ranges, not specific sizes. Handle input methods generically, not device by device. Preserve state through transitions regardless of what triggers them. Think in terms of available space and user context, not hardware models.

Apps built this way don’t just work on current devices—they work on devices that don’t exist yet. They handle unexpected contexts gracefully because they’re designed for variability itself, not specific variants.

This mindset shift—from device targeting to adaptive systems—is the fundamental change required for modern app development. It’s harder initially because it requires thinking more abstractly about interface design. But it’s sustainable in ways that device-specific optimizations never are.

Building for Every Screen Is About Respect

Ultimately, building for every screen isn’t a technical challenge—it’s a commitment to respecting how people actually use technology.

Respecting that users don’t think about device categories—they just open your app wherever they happen to be and expect it to work.

Respecting that context changes constantly—users fold devices, resize windows, rotate screens, and your app should adapt calmly without losing their place.

Respecting that input methods vary—some people use touch, some use keyboards, some switch between both, and all deserve thoughtful interactions.

Respecting that not everyone uses your app the way you designed it—they multitask, they resize, they use accessibility features, and your app should support their workflows, not fight them.

When you approach multi-screen development this way—as respect for user agency and context diversity rather than a checklist of device support—the technical decisions become clearer. You’re not asking “should we support this device?” but “how do we respect this usage pattern?”

Building apps for every screen isn’t about supporting everything. It’s about respecting context, embracing variability, and creating systems that adapt gracefully to however users choose to engage with your app.

The screens will keep changing. The assumptions will keep breaking. The apps that win will be the ones that adapt calmly and respect their users’ contexts—whatever those contexts turn out to be.

This wasn’t an experiment in replacing human developers or seeing if AI could build an entire app. It was about finding the boundaries: what kinds of coding work benefit from AI assistance, and what kinds still demand human expertise and judgment?

The results surprised me. AI excelled in areas I expected it to struggle, and failed in ways I didn’t anticipate. Here’s what I learned from letting AI write part of my code.

Where It Worked: Data Transformation Logic

The single biggest success was using AI for data transformation code—the unglamorous work of converting API responses into domain models, formatting data for display, and mapping between different representations.

I’d paste an API response structure and describe what I needed, and the AI would generate parsing logic, null handling, type conversions, and edge case handling. For a recent project involving a complex nested JSON structure, AI wrote about 80% of the transformation layer, and it was mostly correct.

Why this worked: these tasks are mechanical and pattern-based. Given clear input and output types, there’s usually one obvious correct approach. AI has seen thousands of similar transformations in training data.

What I still had to do: verify the edge case handling was actually correct, not just plausible. AI might add null checks, but it doesn’t know which fields should never be null in your domain. I caught several cases where AI was too defensive (checking for nulls that couldn’t exist) or not defensive enough (missing validation for optional fields that business logic treats as required).

Where It Worked: UI Layout Boilerplate

Building UI layouts in Jetpack Compose and SwiftUI involves a lot of structural repetition. Container views, modifiers, spacing, accessibility labels—it’s tedious but straightforward work.

AI excels here. I’d describe a layout (“two-column grid of cards, each with an image, title, subtitle, and action button”) and get working code that was 90% of what I needed. The structure was right, the components were appropriate, and basic styling was sensible.

For a settings screen with a dozen different row types, AI generated all the layout code in minutes. I just refined the styling and wired up the actual actions.

Why this worked: UI layouts are highly constrained by framework conventions. There are only so many ways to build a card layout or a form screen, and AI has seen them all.

What I still had to do: the generated layouts often lacked attention to detail. Spacing wasn’t quite right, accessibility support was basic, and responsive behavior for different screen sizes was missing. The structure was there, but making it actually good required human polish.

Where It Partially Worked: Network Layer Implementation

AI did reasonably well at generating network request code following established patterns. Given an API endpoint specification and an example of existing network code in my project, it could create new endpoints with proper error handling, request/response models, and retry logic.

But “reasonably well” meant I still spent significant time reviewing and correcting. About 60% of the generated code made it to production as-written.

Why this partially worked: network code follows predictable patterns, but the details matter enormously. Error handling, timeout values, retry strategies, authentication token handling—all of these require context-specific decisions.

What I still had to do: verify authentication was handled correctly, adjust timeout values based on endpoint characteristics, ensure error messages were user-facing appropriate, add proper logging for debugging, and validate that the retry logic wouldn’t cause issues in edge cases.

AI would sometimes generate technically correct code that didn’t fit the app’s error handling philosophy or made assumptions about network reliability that weren’t appropriate for mobile.

Where It Worked Surprisingly Well: Test Case Generation

I was skeptical about AI-generated tests, but this turned out to be one of the more valuable use cases. Given a function or component, AI could generate a comprehensive set of test cases covering happy paths, edge cases, and error conditions.

For a complex validation function, AI generated 15 test cases that I wouldn’t have thought to write manually. It caught edge cases like empty strings, extremely long inputs, special characters, and boundary values.

Why this worked: AI is good at thinking through permutations and combinations. Test case generation is partly about imagining what could go wrong, and AI has seen countless bug reports and test suites.

What I still had to do: verify the assertions actually tested meaningful behavior, not just that code executed without errors. AI would sometimes generate tests that passed but didn’t actually validate correctness. I also had to add tests for business-logic-specific scenarios that AI couldn’t infer from just looking at the code.

Where It Failed: State Management Logic

This was the biggest failure point. Anything involving complex state transitions, lifecycle management, or coordinating multiple pieces of state—AI consistently produced code that looked plausible but had subtle bugs.

I tried having AI implement a feature with multiple interdependent states (loading, loaded, error, refreshing) and user interactions that affected those states. The generated code compiled and mostly worked, but had race conditions, missing state transitions, and edge cases where the UI could get stuck.

Why this failed: state management requires understanding temporal relationships and all possible sequences of events. AI generates code that handles the cases it “thinks about” but misses the interactions between states and the edge cases where multiple things happen simultaneously.

What I learned: never accept AI-generated state management code without thorough review and testing. Even code that appears correct often has subtle timing bugs or missing transitions that only appear in specific scenarios.

Where It Failed: Performance Optimization

AI can suggest optimizations, but it doesn’t actually understand performance in context. I asked it to optimize a RecyclerView implementation that was causing frame drops, and it suggested several changes that sounded reasonable but didn’t address the actual problem.

It recommended view recycling patterns that were already implemented, suggested caching that wouldn’t help, and missed the real issue (complex measurement calculations in onBind).

Why this failed: performance optimization requires profiling, understanding what’s actually slow, and knowing the platform-specific characteristics of the runtime. AI generates generic optimization advice, not targeted solutions to real performance problems.

What I learned: use AI to generate optimization ideas to investigate, but don’t trust its solutions without measuring. Performance is empirical, not theoretical.

Where It Failed Spectacularly: Architecture Decisions

I tried asking AI to help design the architecture for a new feature involving offline-first data synchronization. The suggestions sounded sophisticated but were actually problematic.

AI suggested patterns that would work in a backend service but created issues in a mobile context—unnecessary complexity, battery drain from background work, and patterns that conflicted with Android’s lifecycle constraints.

Why this failed: architecture decisions require understanding tradeoffs specific to your app, platform, and constraints. AI has knowledge of patterns but no judgment about when to use them.

What I learned: AI can explain existing patterns and suggest approaches, but architectural decisions require human judgment about priorities, constraints, and long-term maintainability. Don’t outsource these decisions to AI.

Where It Failed Subtly: Memory Management

AI generated code that worked correctly but had memory leaks—capturing strong references in closures, not properly cleaning up observers, creating retain cycles.

The code functioned perfectly in testing but would gradually consume more memory over time. These are exactly the kinds of bugs that are hard to catch in review and even harder to debug in production.

Why this failed: memory management requires understanding ownership and lifecycles. AI knows the syntax but doesn’t reason about object graphs and reference cycles.

What I learned: any AI-generated code that involves closures, callbacks, or observers needs careful review for memory management. Run it through memory profilers, not just functional tests.

The Pattern That Emerged

After six months, a clear pattern emerged: AI excels at generating code where correctness is locally verifiable and fails when correctness depends on broader context.

AI works well for:

• Transforming data with clear input/output contracts
• Generating structural code following established patterns
• Creating test cases for isolated functions
• Implementing well-defined, self-contained logic

AI struggles with:

• Code where correctness depends on timing or sequence
• Decisions requiring platform-specific knowledge
• Optimization requiring empirical measurement
• Architecture requiring tradeoff analysis
• Anything involving memory management or resource lifecycles

The New Development Rhythm

My workflow evolved to leverage AI’s strengths while protecting against its weaknesses:

For mechanical tasks (data models, boilerplate, standard layouts), I let AI generate first drafts and spend my time reviewing and refining rather than typing.

For complex logic (state management, business rules, performance-critical paths), I write it myself but use AI as a rubber duck—explaining my approach and asking for potential issues.

For testing, I let AI generate initial test cases, then add my own tests for business-specific scenarios and integration cases.

For architecture and design decisions, I make them myself but sometimes ask AI to critique my approach or suggest alternatives I might not have considered.

The Honest Assessment

Did AI make me more productive? Yes, but not as much as the hype would suggest. I’d estimate a 15-20% productivity gain, concentrated in specific types of work.

The time I saved on boilerplate and mechanical coding, I partially spent on more careful review and debugging of subtle issues in AI-generated code. I’m faster at producing code, but not proportionally faster at producing correct, production-ready code.

The bigger benefit wasn’t speed—it was being able to focus my cognitive energy on the interesting problems. When AI handles the boring parts competently, I have more mental bandwidth for the complex parts that actually matter.

What This Means for Mobile Development

AI is genuinely useful for mobile development, but it’s not a replacement for expertise—it’s an amplifier. It makes experienced developers more productive at certain tasks, but it won’t make inexperienced developers suddenly capable of building production apps.

The developers who benefit most are those who can quickly distinguish between “this AI-generated code is good” and “this looks good but is subtly wrong.” That distinction requires the exact expertise AI is supposedly replacing.

We’re not headed toward a world where AI writes apps and humans just review. We’re headed toward a world where humans focus more on architecture, optimization, and complex logic, while AI handles more of the mechanical translation of intent into code.

For mobile developers, that’s actually good news. The work that’s being automated is the work most of us would rather not do anyway. The work that remains is the interesting part—solving hard problems, making smart tradeoffs, and building apps that genuinely work well.

Just don’t trust AI to make those decisions for you. It can’t.