<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Hrusikesh Swain on Medium]]></title>
        <description><![CDATA[Stories by Hrusikesh Swain on Medium]]></description>
        <link>https://medium.com/@hrusikesh251.nalanda?source=rss-1012a21dc6fa------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*_u9tOjC9cURbLGfRXoR-2g.png</url>
            <title>Stories by Hrusikesh Swain on Medium</title>
            <link>https://medium.com/@hrusikesh251.nalanda?source=rss-1012a21dc6fa------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 21:03:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@hrusikesh251.nalanda/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your iOS App Works on iPhone. But Is It Ready for a Foldable?]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/your-ios-app-works-on-iphone-but-is-it-ready-for-a-foldable-67ed39ae9992?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/67ed39ae9992</guid>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 22:04:47 GMT</pubDate>
            <atom:updated>2026-11-04T22:04:47.425Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What foldable devices reveal about technical debt, responsive UI, SwiftUI, React Native, and modern mobile application architecture.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/980/1*EZRfPXBYfgp7Ne3iTAcMQg.jpeg" /></figure><p>For years, mobile apps have been designed around one simple assumption: <strong>one screen, one size, one layout.</strong></p><p>Foldable devices are changing that.</p><p>Now, apps need to adapt to different screen sizes, layouts, and device positions without compromising the user experience.</p><p>But here’s the real challenge:</p><p><strong>It’s not about building for a new device. It’s about making existing apps ready for what’s next.</strong></p><p>Fixed dimensions, rigid layouts, and outdated design assumptions can quickly become obstacles when screen sizes change.</p><p>Let’s explore how developers can overcome these challenges using SwiftUI, UIKit, and React Native — and build mobile apps that are ready for the next generation of devices.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6SjZCZF_dKeqTEftrY09WA.jpeg" /></figure><h3>1. A New Form Factor Changes More Than Screen Size</h3><p>Traditional smartphones give developers a relatively predictable layout.</p><p>Foldable devices introduce multiple configurations:</p><ul><li>Closed mode: A compact display for everyday interactions.</li><li>Open mode: A larger display with more room for content.</li><li>Half-folded mode: A different interaction experience influenced by the device’s physical position.</li><li>Orientation changes: Different available dimensions and content arrangements.</li></ul><p>This means developers can no longer think only in terms of portrait and landscape.</p><p>They need to consider:</p><ul><li>Available screen space.</li><li>Dynamic layout changes.</li><li>Safe areas and hardware-obstructed regions.</li><li>Multiple content regions.</li><li>Navigation placement.</li><li>State preservation during transitions.</li></ul><p>An application that looks perfect on a traditional iPhone may suddenly feel cramped, stretched, or poorly positioned on a foldable device.</p><p>The objective isn’t to create a separate application for every device configuration.</p><p><strong>It’s to build one application that adapts intelligently.</strong></p><h3>2. The Real Problem: Technical Debt Hidden in Existing Layouts</h3><p>One of the biggest challenges in preparing an existing app for foldable devices isn’t integrating new APIs — it’s fixing the layout assumptions built into the application over time.</p><p>Hardcoded dimensions, rigid layouts, and custom UI components can make even simple adaptations difficult.</p><p>Let’s look at some common examples.</p><h3>Problem 1: Hardcoded dimensions</h3><pre>let cardWidth: CGFloat = 320</pre><p>This might have worked perfectly when the application was designed around a specific iPhone width.</p><p>But what happens when the available width changes?</p><p>Fixed dimensions can cause:</p><ul><li>Clipped content.</li><li>Unused screen space.</li><li>Overlapping components.</li><li>Inconsistent layouts.</li></ul><h3>Problem 2: Depending on screen bounds</h3><pre>let screenHeight = UIScreen.main.bounds.height</pre><p>Global screen dimensions aren’t always representative of the available application window.</p><p>This becomes particularly problematic when the application runs in a resizable window or supports multiple display configurations.</p><p>Instead, layouts should respond to their actual container dimensions.</p><h3>Problem 3: Assuming portrait orientation</h3><p>Some applications contain screens designed exclusively for portrait mode.</p><p>When the available dimensions change, these screens may display overlapping text, misplaced controls, or broken navigation.</p><h3>Problem 4: Custom navigation and modal components</h3><p>Custom-built tab bars, overlays, and navigation components may not automatically adapt to new system conventions.</p><p>Sometimes the best solution isn’t another custom implementation.</p><p>It’s using the native components already provided by the operating system.</p><h3>Before vs. After: The impact of adaptive layouts</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pLUt88UnmYPZLjBKHJ6vmw.png" /></figure><p>The difference is more than visual.</p><h3>Before: Fixed Layout</h3><ul><li>Fixed component widths</li><li>Unused display space</li><li>Manually positioned modals</li><li>Fixed navigation placement</li><li>Assumed screen dimensions</li></ul><h3>After: Adaptive Layout</h3><ul><li>Flexible dimensions</li><li>Better space utilization</li><li>Adaptive system presentations</li><li>Context-aware navigation</li><li>Container-based sizing</li><li>The important lesson is that new hardware doesn’t necessarily create technical debt.</li></ul><p><strong>It exposes the technical debt that was already there.</strong></p><h3>3. Building Adaptive Layouts with SwiftUI</h3><p>SwiftUI provides several tools for creating interfaces that respond to available space.</p><p>Instead of checking individual device models, developers can use layout containers and available dimensions to decide how content should be presented.</p><p>Consider a simple list-and-detail interface.</p><p>On a compact screen, displaying both sections side by side might not be practical.</p><p>On a wider screen, a two-column layout provides a better experience.</p><p>Here’s a simplified example using ViewThatFits:</p><pre>struct AdaptiveDashboard: View {<br>    var body: some View {<br>        ViewThatFits(in: .horizontal) {<br>           HStack(spacing: 16) {<br>                NavigationPanel()<br>                    .frame(maxWidth: 220)<br>                 DashboardContent()<br>                    .frame(maxWidth: .infinity)<br>            }<br>            VStack(spacing: 16) {<br>                NavigationPanel()<br>                DashboardContent()<br>            }<br>        }<br>        .padding()<br>    }<br>}</pre><p>Here, SwiftUI evaluates the available horizontal space and selects a layout that fits.</p><p>The same approach can be extended to dashboards, document viewers, messaging interfaces, and other complex screens.</p><p>For more precise control, developers can use GeometryReader or size classes to respond to the available container dimensions.</p><p>The key principle:</p><p><strong>Design layouts around available space, not around a particular iPhone model.</strong></p><p>Note: This is a general adaptive-layout example, not a complete implementation of fold geometry or hinge-aware positioning. Those capabilities require additional platform-specific integration.</p><h3>4. What About React Native Applications?</h3><p>This is particularly interesting for cross-platform developers.</p><p>React Native already provides flexible layout capabilities through Flexbox, but responsive UI and native device integration are two different things.</p><p>A React Native application can resize its components correctly and still miss platform-specific functionality.</p><p>Let’s look at a simple example.</p><h3>Avoid fixed dimensions</h3><p>A common implementation might look like this:</p><pre>const styles = StyleSheet.create({<br>  container: {<br>    width: 320,<br>    height: 600,<br>    padding: 16,<br>  },<br>});</pre><p>This creates unnecessary assumptions about available screen dimensions.</p><p>A more flexible implementation uses useWindowDimensions:</p><pre>import React from &#39;react&#39;;<br>import {<br>  View,<br>  Text,<br>  useWindowDimensions,<br>} from &#39;react-native&#39;;<br>export default function Dashboard() {<br> const { width } = useWindowDimensions();<br> const isExpanded = width &gt;= 700;<br>    return (<br>    &lt;View<br>      style={{<br>        flex: 1,<br>        flexDirection: isExpanded ? &#39;row&#39; : &#39;column&#39;,<br>        padding: 16,<br>      }}<br>    &gt;<br>      &lt;View<br>        style={{<br>          flex: isExpanded ? 1 : undefined,<br>        }}<br>      &gt;<br>        &lt;Text&gt;Navigation&lt;/Text&gt;<br>      &lt;/View&gt;<br>      &lt;View<br>        style={{<br>          flex: isExpanded ? 2 : undefined,<br>        }}<br>      &gt;<br>        &lt;Text&gt;Dashboard Content&lt;/Text&gt;<br>      &lt;/View&gt;<br>    &lt;/View&gt;<br>  );<br>}</pre><p>useWindowDimensions automatically updates when the available window dimensions change.</p><p>This allows React Native components to respond to layout changes without manually tracking orientation events.</p><p>The breakpoint is illustrative, real applications should validate their layouts against actual content requirements.</p><h3>Where React Native needs additional attention</h3><p>Responsive layouts solve only part of the problem.</p><p>Some native iOS capabilities may require additional integration:</p><ul><li>Fold and hinge geometry.</li><li>Reserved display regions.</li><li>Native toolbar and navigation behavior.</li><li>Device-specific presentation APIs.</li><li>Advanced camera and display interactions.</li></ul><p>These capabilities may require native Swift or Objective-C integration through a React Native native module.</p><p><strong>A responsive React Native application isn’t automatically a fully integrated native iOS application.</strong></p><h3>5. How to Assess Native iOS Compatibility in an Existing React Native App</h3><p>Before implementing foldable-specific features, it’s worth auditing the existing React Native application.</p><p>I would divide the assessment into five areas.</p><h3>1. React Native and iOS build compatibility</h3><p>Check:</p><ul><li>React Native version.</li><li>iOS deployment target.</li><li>Xcode and SDK compatibility.</li><li>New architecture compatibility, where applicable.</li><li>Third-party native dependency compatibility.</li></ul><p>A JavaScript dependency working correctly doesn’t guarantee that its underlying iOS implementation supports the latest platform capabilities.</p><h3>2. Layout and responsive behavior</h3><p>Search the codebase for:</p><ul><li>Fixed width and height values.</li><li>Dimensions.get(&#39;screen&#39;) used for layout calculations.</li><li>Orientation-specific conditions.</li><li>Absolute positioning.</li><li>Custom navigation components.</li></ul><p>Prefer useWindowDimensions, flexible Flexbox layouts, and container-based sizing.</p><h3>3. Native iOS lifecycle</h3><p>Review the application’s native iOS entry points and lifecycle integration.</p><p>Check:</p><ul><li>AppDelegate implementation.</li><li>Scene lifecycle requirements for the target SDK.</li><li>Window and root-view configuration.</li><li>Native module initialization.</li><li>Background and foreground transitions.</li></ul><p>Don’t assume that upgrading React Native automatically migrates every custom native integration.</p><h3>4. Native API availability</h3><p>Identify which features are available through React Native itself and which require native integration.</p><h3>Capability Assessment</h3><p>Responsive Layouts</p><p>- React Native Flexbox</p><p>Dynamic Dimensions</p><p>- useWindowDimensions</p><p>Safe Areas</p><p>- Safe-area integration</p><p>Native Toolbars</p><p>- Native integration may be required</p><p>Fold Geometry</p><p>- Native API bridge may be required</p><p>Camera Transitions</p><p>- Review native camera implementation</p><p>Biometric Authentication</p><p>- Check native biometric capability handling</p><p>The exact integration requirements depend on the target iOS SDK and the React Native libraries being used.</p><h3>5. State preservation</h3><p>Test whether the application preserves:</p><ul><li>Scroll positions.</li><li>Form inputs.</li><li>Selected navigation tabs.</li><li>Media playback position.</li><li>In-progress network operations.</li></ul><p>A layout transition should not unexpectedly reset the user’s progress.</p><p>This is particularly important for applications with long forms, authentication flows, document capture, and media experiences.</p><h3>6. The Testing Strategy: Test Transitions, Not Just Screens</h3><p>One of the biggest mistakes developers can make is testing only the final layout.</p><p>Foldable devices introduce transitions, and those transitions can expose problems that are difficult to reproduce otherwise.</p><h3>Testing Matrix</h3><p>Closed Mode</p><p>- Validate compact layouts and navigation.</p><p>Open Mode</p><p>- Validate expanded layouts and multiple columns.</p><p>Half-Folded Mode</p><p>- Check control and content placement.</p><p>Landscape Mode</p><p>- Verify layout adaptation.</p><p>Display Transition</p><p>- Ensure state is preserved.</p><p>Camera Interaction</p><p>- Test preview and capture behavior.</p><p>Modal Presentation</p><p>- Verify correct positioning.</p><p>Biometric Authentication</p><p>- Validate runtime capability handling.</p><p>For React Native developers, this should include testing both JavaScript-rendered components and native iOS functionality.</p><p>Testing should become part of the regular development and QA process, not something left until release.</p><h3>7. A Practical Modernization Strategy</h3><p>If you’re preparing an existing mobile application for a new form factor, I’d approach the upgrade in the following order.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*x06N2YDUEXR9ELAYWjLHAA.jpeg" /></figure><p><strong>Step 1: Audit the existing application</strong></p><p>Identify hardcoded dimensions, custom navigation components, lifecycle assumptions, and device-specific dependencies.</p><p><strong>Step 2: Review framework and SDK compatibility</strong></p><p>Check React Native or native iOS versions, dependencies, Xcode compatibility, and required lifecycle changes.</p><p><strong>Step 3: Modernize responsive layouts</strong></p><p>Make existing screens adapt to different available dimensions before implementing fold-specific behavior.</p><p><strong>Step 4: Integrate native capabilities</strong></p><p>Add native integrations only where the application genuinely needs platform-specific functionality.</p><p><strong>Step 5: Preserve application state</strong></p><p>Make sure users don’t lose progress during display changes, navigation transitions, or configuration updates.</p><p><strong>Step 6: Test across configurations</strong></p><p>Validate compact, expanded, partially folded, and transitional layouts.</p><p><strong>Step 7: Release incrementally</strong></p><p>Prioritize essential compatibility improvements first. Introduce advanced device-specific experiences only when they provide meaningful value.</p><h3>8. The Bigger Lesson: Build for Adaptability, Not Just Compatibility</h3><p>The arrival of foldable devices is an opportunity to rethink how we approach mobile application development.</p><p>For a long time, developers have optimized applications around specific device dimensions.</p><p>But modern applications need to be more flexible.</p><p>Whether you’re building with SwiftUI, UIKit, React Native, or Flutter, the engineering principles remain similar:</p><ul><li>Avoid unnecessary fixed dimensions.</li><li>Prefer adaptive layout systems.</li><li>Use native platform capabilities where appropriate.</li><li>Keep application state independent of UI configuration.</li><li>Test transitions, not just final layouts.</li><li>Avoid creating unnecessary device-specific implementations.</li></ul><p>And this isn’t just about foldable iPhones.</p><p>The same improvements can benefit iPads, split-screen experiences, larger displays, and future mobile form factors.</p><p><strong>The best application upgrade isn’t one that simply adds support for a new device. It’s one that removes the assumptions preventing the application from adapting to the next one.</strong></p><p>Build adaptive. Reduce technical debt. Let the platform do what it does best.</p><p>Because the next device is probably already challenging the assumptions in your codebase.</p><h3>References and Further Reading</h3><ul><li><a href="https://developer.apple.com/documentation/">Apple Developer Documentation</a></li><li><a href="https://developer.apple.com/documentation/swiftui">SwiftUI Documentation</a></li><li><a href="https://reactnative.dev/docs/usewindowdimensions">React Native Documentation — useWindowDimensions</a></li><li><a href="https://reactnative.dev/docs/native-platform">React Native Documentation — Native Platform</a></li></ul><p>Keep Learning and Keep Sharing :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67ed39ae9992" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Spec-Driven Development With Cursor: From Idea to Working App]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/spec-driven-development-with-cursor-from-idea-to-working-app-c7cf2fa3284b?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7cf2fa3284b</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[react]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Sun, 11 Oct 2026 18:29:17 GMT</pubDate>
            <atom:updated>2026-10-11T18:29:17.833Z</atom:updated>
            <content:encoded><![CDATA[<p><em>An engineering workflow for building with Cursor, preserving context, and shipping AI-generated code with confidence.</em></p><p>AI coding assistants have changed how quickly we can build software. With a well-written prompt, tools like Cursor can generate components, create APIs, refactor modules, and even implement entire features.</p><p>But there is a problem hiding behind that speed.</p><p>As more code gets generated, <strong>the codebase can grow faster than the team’s understanding of it.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dytpcl-NHk0_cVjfnKVw9Q.png" /></figure><p>A feature works today, but the next AI session may implement the same functionality differently. An agent may ignore an existing utility, introduce a new dependency, or change a working component because the original reasoning has disappeared into an old conversation.</p><p>The discussion proposes a useful change: treat specifications as both <strong>inputs to development and outputs from development</strong>. Requirements and plans guide implementation; research, code notes, reviews, and findings preserve what the team learns.</p><p>Let’s explore how to put that idea into practice.</p><h3>1. What is Spec-Driven Development?</h3><p>Spec-Driven Development (SDD) is an approach in which we define the intended behavior and constraints of a feature before implementation, then use that specification to guide coding, testing, and review.</p><p>Instead of relying on a long chat conversation as the source of truth, we maintain structured, version-controlled documents alongside the code.</p><p>The basic principle is simple:</p><p><strong>The specification describes what the software must do. The implementation makes it happen. Tests verify that it does.</strong></p><p>A typical workflow looks like this:</p><pre>Product idea<br>    ↓<br>Requirements / feature specification<br>    ↓<br>Research existing code and patterns<br>    ↓<br>Technical plan and task breakdown<br>    ↓<br>Implementation with Cursor<br>    ↓<br>Tests, review, and verification<br>    ↓<br>Code notes and reusable findings<br>    ↺<br>Update the specification when needed</pre><p>Every stage produces an artifact that can be reviewed, reused, and improved.</p><p>This does not mean writing documentation for every small change. It means establishing a lightweight engineering contract for work that is complex enough to benefit from one.</p><h3>2. Why AI-assisted development needs better structure</h3><p>Consider a familiar workflow:</p><ol><li>Ask Cursor to build a feature.</li><li>Review the generated code.</li><li>Ask it to fix a few problems.</li><li>Discover a regression.</li><li>Explain the original requirements again.</li><li>Start another conversation and repeat the process.</li></ol><p>The issue is not necessarily the model’s coding ability. It is that requirements, decisions, and discoveries are scattered across prompts, diffs, and conversations.</p><p>Without persistent context, an agent can make technically plausible changes that are inconsistent with the architecture or product requirements.</p><h3>The shift: from prompt-driven to spec-driven</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qpMEgCK3bQHEL1mGqXHZaA.png" /></figure><p>SDD does not eliminate mistakes or guarantee correct output. It gives developers a much better way to detect mistakes, understand decisions, and prevent repeated work.</p><h3>3. The complete SDD workflow</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AhRDdEbupuQ12rVB_l2aKQ.png" /></figure><h3>Phase 1: Define the product requirements</h3><p>Start with the problem, not the implementation.</p><p>Create a prd.md file that describes the user problem, expected outcome, scope, and constraints.</p><p>For example, imagine we are adding a saved-items feature to an existing React Native application.</p><p>The product requirement might be:</p><blockquote><em>Users should be able to save an item for later, view their saved items, remove an item, and retain their saved list after reopening the application.</em></blockquote><p>That statement describes the desired behavior without dictating the component structure or state-management library.</p><h3>Phase 2: Document the technical context</h3><p>Create a tech_brief.md file covering the relevant architecture, conventions, dependencies, and constraints.</p><p>For an existing mobile application, this might include:</p><ul><li>Current React Native version and supported platforms.</li><li>Navigation and state-management patterns.</li><li>Existing API clients and authentication behavior.</li><li>Reusable UI components and design conventions.</li><li>Persistence requirements and testing tools.</li><li>Performance, accessibility, and security constraints.</li></ul><p>This step is particularly valuable in an established codebase. Cursor should investigate the project’s actual implementation rather than assume that a greenfield architecture is appropriate.</p><h3>Phase 3: Write the feature specification</h3><p>Create a requirements.md file that turns the product idea into observable behavior.</p><p>A useful specification includes:</p><ul><li>Context and problem statement.</li><li>Goals and non-goals.</li><li>User stories and scenarios.</li><li>Acceptance criteria.</li><li>Dependencies and error cases.</li><li>Relevant constraints.</li></ul><p>For example:</p><p><strong>Feature:</strong> Save an item for later</p><p><strong>User story:</strong> As a user, I want to save an item so I can find it again without searching for it.</p><p><strong>Acceptance criteria:</strong></p><ul><li>AC-01: A user can save an eligible item.</li><li>AC-02: Saving an already-saved item does not create a duplicate.</li><li>AC-03: The saved-items screen displays saved items.</li><li>AC-04: A user can remove a saved item.</li><li>AC-05: Saved items remain available after the app restarts.</li><li>AC-06: Loading and error states are handled without crashing the screen.</li></ul><p>Notice how these requirements can be tested independently of the eventual implementation.</p><h3>Phase 4: Research before coding</h3><p>Ask Cursor to inspect the codebase and create a research.md file.</p><p>The goal is to discover existing patterns before introducing new ones.</p><p>Research should identify:</p><ul><li>Relevant screens, components, hooks, and services.</li><li>Existing persistence or API mechanisms.</li><li>Reusable utilities and design-system components.</li><li>Related tests and architectural conventions.</li><li>Potential regressions, dependencies, and unanswered questions.</li></ul><p>For example, if the app already has a storage abstraction, the agent should investigate whether it can be reused instead of introducing a second persistence library.</p><p>Research is not a formality. It is the stage where assumptions are challenged before they become code.</p><h3>Phase 5: Create a technical plan</h3><p>Once research is reviewed, create a plan.md file.</p><p>The plan describes how the requirements can be implemented within the existing architecture.</p><p>A sample task breakdown:</p><ol><li>Define the saved-item data model.</li><li>Extend the existing persistence or API layer.</li><li>Add save and remove operations.</li><li>Implement the saved-items screen.</li><li>Connect the screen to navigation.</li><li>Add unit and integration tests.</li><li>Verify persistence, error handling, and regression behavior.</li></ol><p>Each task should have a clear scope and a way to verify completion.</p><p>The plan should not prescribe every line of code. Leave implementation details to the developer and agent, within the boundaries established by the specification and architecture.</p><h3>Phase 6: Implement in small, reviewable increments</h3><p>Now ask Cursor to implement the approved plan.</p><p>Rather than requesting the entire feature in one giant prompt, work through related tasks in manageable increments. Review the diffs and tests after each meaningful step.</p><p>If the agent discovers that an existing API cannot support the required behavior, it should explain the discovery and propose an update to the plan or specification before silently changing scope.</p><h3>Phase 7: Verify the implementation</h3><p>The implementation is not complete just because the screen renders or the happy-path demo works.</p><p>Verify every acceptance criterion using appropriate automated tests and, where necessary, manual checks.</p><p>For the saved-items example, test duplicate saves, removal, restart persistence, loading failures, and behavior when no items have been saved.</p><p>Also run the project’s normal quality checks, such as linting, type checking, unit tests, integration tests, and relevant platform builds.</p><h3>Phase 8: Capture what was learned</h3><p>This is the step that makes the workflow more powerful over time.</p><p>After implementation, save a concise record of:</p><ul><li>code.md: what changed and why.</li><li>review.md: review feedback and corrections.</li><li>findings.md: discoveries, pitfalls, and reusable patterns.</li></ul><p>Update tasks.md and the specification when the actual implementation differs from the original plan.</p><p>Commit the relevant specifications, tests, and code together so future developers can reconstruct both what happened and why.</p><h3>4. A practical Cursor implementation</h3><p>Here is a simple way to introduce this workflow without immediately adopting a specialized framework.</p><p>Start by creating a folder for the feature:</p><pre>docs/<br>  prd.md<br>  tech_brief.md<br><br>specs/<br>  saved-items/<br>    requirements.md<br>    research.md<br>    plan.md<br>    tasks.md<br>    code.md<br>    review.md<br>    findings.md</pre><p>The filenames are conventions, not mandatory standards. A small team can start with fewer files and add structure as needed.</p><h3>Step A: Ask Cursor to research</h3><p>Open the existing project in Cursor and ask it to read the relevant product and technical documents.</p><p>Example prompt:</p><blockquote><em>Read </em><em>docs/prd.md, </em><em>docs/tech_brief.md, and </em><em>specs/saved-items/requirements.md.</em></blockquote><blockquote><em>Inspect the existing codebase for related screens, navigation, persistence, and tests.</em></blockquote><blockquote><em>Create </em><em>specs/saved-items/research.md containing the files inspected, existing patterns, reusable utilities, risks, and unanswered questions.</em></blockquote><blockquote><em>Do not modify application code yet. Do not assume a dependency or architecture without evidence from the repository.</em></blockquote><p>Review the findings before moving forward.</p><h3>Step B: Ask Cursor to create the plan</h3><blockquote><em>Based on the approved requirements and research, create </em><em>specs/saved-items/plan.md and </em><em>tasks.md.</em></blockquote><blockquote><em>Map each task to one or more acceptance criteria. Include dependencies, likely files to change, test requirements, and risks.</em></blockquote><blockquote><em>Follow the existing project conventions. Flag any requirement that cannot be implemented with the current architecture. Do not implement the feature yet.</em></blockquote><p>At this point, the developer can catch missing API behavior, unnecessary dependencies, or an overly broad implementation before code changes begin.</p><h3>Step C: Implement the approved tasks</h3><blockquote><em>Implement the tasks in </em><em>specs/saved-items/tasks.md using the requirements and technical plan as the source of truth.</em></blockquote><blockquote><em>Reuse existing utilities and patterns wherever appropriate. Add or update tests for the acceptance criteria. Do not introduce unrelated refactors or silently expand the feature scope.</em></blockquote><blockquote><em>If the specification is ambiguous or the plan conflicts with the codebase, stop and explain the conflict before making a significant design change.</em></blockquote><p>This gives Cursor a stable reference rather than asking it to reconstruct the requirements from chat history.</p><h3>Step D: Run a specification-based review</h3><blockquote><em>Review the implementation against </em><em>requirements.md, </em><em>plan.md, and </em><em>tasks.md.</em></blockquote><blockquote><em>Check every acceptance criterion and identify the corresponding test or verification step. Report missing behavior, regressions, architectural inconsistencies, and unnecessary changes.</em></blockquote><blockquote><em>Save the findings in </em><em>review.md. Do not claim that a test passed unless it was actually executed and the result was observed.</em></blockquote><p>Fix the reported issues, rerun the relevant tests, and record the final result.</p><h3>Step E: Preserve the learnings</h3><blockquote><em>Create or update </em><em>code.md and </em><em>findings.md.</em></blockquote><blockquote><em>Summarize the files changed, design decisions, tests executed, known limitations, and reusable patterns discovered. Identify any difference between the original plan and the delivered implementation.</em></blockquote><blockquote><em>Update the task status and propose specification changes if the requirements or architecture need to evolve.</em></blockquote><p>This final step ensures that the next developer — or the next Cursor session — has useful context without needing to reconstruct the entire conversation.</p><h3>5. Connect requirements to tests</h3><p>One of the strongest ways to make SDD practical is to connect every acceptance criterion to evidence.</p><p>For example:</p><p>Requirement =&gt; Verification<br>AC-01: Save an item =&gt; Unit test for the save operation<br>AC-02: Prevent duplicates =&gt; Test saving the same item twice<br>AC-03: Display saved items =&gt; Screen or integration test<br>AC-04: Remove an item =&gt; Test the removal operation and updated list<br>AC-05: Persist across restarts =&gt; Persistence or integration test<br>AC-06: Handle errors =&gt; Test the error state and recovery behavior</p><p>This is a traceability matrix. It gives developers and reviewers a concrete way to answer a crucial question: <strong>How do we know the implementation satisfies the requirements?</strong></p><h3>6. Make SDD a team habit, not a documentation project</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5Fb_IxFtoL7lD5ySbDvxNw.jpeg" /></figure><p>A workflow is only useful if developers actually follow it.</p><p>Start with a pilot involving two or three meaningful features. Avoid imposing the full process on trivial UI changes, small bug fixes, or straight forward cleanup tasks.</p><p>Use a few simple rules:</p><p><strong>Keep specifications lightweight.</strong> Capture decisions that influence behavior, architecture, compatibility, or future work. Do not document every coding action.</p><p><strong>Version-control the artifacts.</strong> Keep the specifications close to the code so changes can be reviewed and tracked together.</p><p><strong>Make the workflow discoverable.</strong> Store reusable Cursor instructions or project rules in the repository. Make it clear which documents the agent must consult before implementation.</p><p><strong>Automate repetitive setup.</strong> Templates and commands can create the standard feature folder and starter files, reducing the friction of following the process.</p><p><strong>Review findings regularly.</strong> Revisit recurring risks, unresolved issues, and lessons from previous implementations. Promote useful findings into shared project rules when appropriate.</p><p><strong>Allow the process to evolve.</strong> If developers repeatedly skip a document, ask whether it adds value or whether its content belongs somewhere simpler.</p><p>The objective is not more paperwork. It is less repeated investigation and fewer avoidable mistakes.</p><h3>7. Common mistakes to avoid</h3><p><strong>Writing implementation details too early.</strong> A specification should establish expected behavior and constraints. Technical decisions belong in the research and planning stages unless the architecture already mandates them.</p><p><strong>Trusting generated plans without review.</strong> An AI-generated plan can be detailed and still be wrong. Check it against the real codebase and the actual requirements.</p><p><strong>Treating passing tests as complete proof.</strong> Tests can be incomplete or incorrectly written. Review their coverage and inspect the implementation, particularly around security, persistence, and error handling.</p><p><strong>Letting documents drift from the code.</strong> If implementation changes the design, update the relevant artifacts. Otherwise, the specifications become misleading.</p><p><strong>Using the same ceremony for every task.</strong> Apply the full workflow where the cost of ambiguity or regression justifies it. Use a short prompt for a genuinely small change.</p><p><strong>Assuming AI eliminates engineering responsibility.</strong> Developers remain responsible for scope, architecture, code review, validation, and release decisions.</p><h3>8. How to know whether it is working</h3><p>Measure the outcome rather than the number of documents created.</p><p>Useful metrics include:</p><ul><li>Rework caused by missed requirements.</li><li>Defects found after merging or releasing a feature.</li><li>Time spent investigating previously solved problems.</li><li>Percentage of acceptance criteria with corresponding verification.</li><li>Time required for a new engineer to understand an existing feature.</li><li>Frequency of duplicated functionality or inconsistent patterns.</li></ul><p>Establish a baseline before the pilot and compare results afterward. Avoid claiming that SDD improves productivity by a specific percentage without measurements from your own team.</p><p>The most valuable signal is whether developers spend less time reconstructing intent and correcting avoidable mistakes — and more time delivering the right behavior.</p><h3>Conclusion: Make the specification the memory of your codebase</h3><p>AI coding assistants are excellent at accelerating implementation, but speed alone does not create maintainable software.</p><p>Teams also need a reliable way to preserve intent, architecture, decisions, and lessons learned.</p><p>Spec-Driven Development provides that structure:</p><p><strong>Specify → Research → Plan → Implement → Verify → Capture Learnings.</strong></p><p>The key insight from the Cursor discussion is to preserve the outputs of development, not just the instructions that went into it. Research notes, code summaries, review findings, and reusable discoveries can become valuable context for the next feature.</p><p>Start with one meaningful feature. Create a small set of specifications. Use Cursor to research, plan, implement, and verify against them. Commit the useful artifacts alongside the code, then refine the workflow based on what your team learns.</p><p>You do not need a complicated framework to begin.</p><p>You need a shared source of truth — and the discipline to keep it useful.</p><p><em>More Info:</em></p><ul><li><a href="https://github.com/Fission-AI/OpenSpec">OpenSpec: An open-source approach to spec-driven changes</a></li><li><a href="https://codelabs.developers.google.com/sdd-adk-antigravity">Google Codelab: Spec-driven development with Spec Kit</a></li></ul><p>Keep Learning and Keep Sharing :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7cf2fa3284b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Figma Design to Code with MCP + Cursor ]]></title>
            <link>https://blog.stackademic.com/from-figma-design-to-code-with-mcp-cursor-989655d1ba1d?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/989655d1ba1d</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Sun, 20 Sep 2026 20:31:49 GMT</pubDate>
            <atom:updated>2026-09-24T01:59:12.250Z</atom:updated>
            <content:encoded><![CDATA[<p>Have you ever received a Figma design and thought:</p><blockquote><em>“Now I have to manually inspect every spacing, color, font, component, and dimension… 😩”</em></blockquote><p>What if Cursor could <strong>read the Figma design directly and help turn it into code?</strong></p><p>That’s where <strong>MCP (Model Context Protocol)</strong> comes in.</p><p>With Figma’s MCP server connected to Cursor, your workflow can look like this:</p><pre>🎨 Figma Design<br>      ↓<br>   🔗 MCP<br>      ↓<br>   🤖 Cursor<br>      ↓<br> 💻 Production Code</pre><p>Instead of giving an AI a screenshot and asking it to guess the design, MCP can provide structured design context such as components, variables, layout information, and other design details.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LeYVBvdtMdhW8R-rbNL1pg.png" /></figure><h3>🎨 Step 1: Start with a Figma Design</h3><p>Imagine your designer gives you this mobile screen:</p><pre>┌─────────────────────────┐<br>│  ←  Profile             │<br>│                         │<br>│      👤                 │<br>│    John Doe             │<br>│  john@example.com       │<br>│                         │<br>│  ┌───────────────────┐  │<br>│  │ Edit Profile      │  │<br>│  └───────────────────┘  │<br>│                         │<br>│  ⚙ Settings             │<br>│  🔔 Notifications       │<br>│  🚪 Logout              │<br>└─────────────────────────┘</pre><p>Normally, you’d inspect the Figma file and manually translate it into React, React Native, SwiftUI, etc.</p><p>With Figma MCP, you can give Cursor the <strong>Figma selection link</strong>.</p><p>In Figma:</p><p><strong>Right-click the frame → Copy link to selection</strong></p><p>Then paste that link into Cursor. Figma’s remote MCP server is link-based, so the selected frame or layer becomes the context for the request.</p><h3>🔌 Step 2: Connect Figma MCP to Cursor</h3><p>The easiest current setup is through Cursor’s plugin flow.</p><p>In Cursor:</p><pre>Command Palette<br>      ↓<br>Open Chat<br>      ↓<br>/add-plugin figma<br>      ↓<br>Add Plugin<br>      ↓<br>Cursor Settings<br>      ↓<br>Tools &amp; MCP<br>      ↓<br>Connect Figma</pre><p>Figma currently recommends the <strong>remote MCP server</strong> for most users because it provides the broadest set of features.</p><p>Cursor also supports MCP servers through its MCP configuration and can automatically use available MCP tools when they are relevant to a request.</p><h3>🤖 Step 3: Give Cursor the Figma Design</h3><p>Now comes the interesting part.</p><p>Paste your Figma link into Cursor and ask:</p><blockquote><strong><em>“Implement this Figma screen in React Native. Use the existing components in my project and match the spacing, typography, colors, and layout from the design.”</em></strong></blockquote><p>The workflow becomes:</p><pre>FIGMA<br>          │<br>          │ Design context<br>          ▼<br>      FIGMA MCP<br>          │<br>          │ Components<br>          │ Variables<br>          │ Layout<br>          │ Design tokens<br>          ▼<br>        CURSOR<br>          │<br>          │ AI generates code<br>          ▼<br>    REACT NATIVE</pre><p>Figma’s MCP server is designed to provide structured design context to coding agents rather than simply sending a screenshot.</p><h3>💻 Step 4: Cursor Generates the Code</h3><p>For example, Cursor might generate a React Native component like:</p><pre><br>const ProfileScreen = () =&gt; {<br>  return (<br>    &lt;View style={styles.container}&gt;<br>      &lt;Header title=&quot;Profile&quot; /&gt;<br>      &lt;Avatar /&gt;<br>    &lt;Text style={styles.name}&gt;<br>        John Doe<br>      &lt;/Text&gt;<br>      &lt;Text style={styles.email}&gt;<br>        john@example.com<br>      &lt;/Text&gt;<br>      &lt;Button title=&quot;Edit Profile&quot; /&gt;<br>      &lt;MenuItem<br>        icon=&quot;settings&quot;<br>        title=&quot;Settings&quot;<br>      /&gt;<br>      &lt;MenuItem<br>        icon=&quot;bell&quot;<br>        title=&quot;Notifications&quot;<br>      /&gt;<br>      &lt;MenuItem<br>        icon=&quot;logout&quot;<br>        title=&quot;Logout&quot;<br>      /&gt;<br>    &lt;/View&gt;<br>  );<br>};<br></pre><p>The important part isn’t just generating JSX.</p><p>The goal is for the AI to understand the <strong>design context</strong> and use the structure, variables, components, and layout information from the Figma file.</p><h3>🧩 Even Better: Use Your Existing Components</h3><p>This is where MCP becomes particularly interesting for teams.</p><p>Suppose your project already has:</p><pre>Button<br>Typography<br>Avatar<br>Header<br>Spacing<br>Colors<br>Icons</pre><p>Instead of generating completely new components, tell Cursor:</p><blockquote><strong><em>“Use the existing components from our codebase wherever possible. Do not create duplicate components.”</em></strong></blockquote><p>Now you can combine:</p><pre>Figma Design<br>      +<br>Your Codebase<br>      +<br>Figma MCP<br>      ↓<br>Cursor<br>      ↓<br>Reusable Production Code</pre><p>Figma also supports <strong>Code Connect</strong>, which can help map Figma components to the actual components used in your codebase.</p><h3>🔄 The Real Power: Design → Code → Design</h3><p>MCP isn’t necessarily a one-way workflow anymore.</p><p>The newer Figma MCP capabilities can also allow agents to create or modify native Figma content, depending on the setup and permissions.</p><p>So the workflow can become:</p><pre>🎨 Figma<br>   │<br>   │ MCP<br>   ▼<br>🤖 Cursor<br>   │<br>   ▼<br>💻 Code<br>   │<br>   │ Iterate<br>   ▼<br>🎨 Figma</pre><p>This creates a much tighter collaboration loop between <strong>designers and developers</strong>.</p><h3>🚀 Why This Is Interesting</h3><p>Traditional workflow:</p><pre>Figma<br>  ↓<br>Developer inspects design<br>  ↓<br>Measures spacing<br>  ↓<br>Copies colors<br>  ↓<br>Checks fonts<br>  ↓<br>Writes components<br>  ↓<br>Adjusts UI<br>  ↓<br>Compare with Figma<br>  ↓<br>Repeat 😅</pre><p>MCP-assisted workflow:</p><pre>Figma<br>  ↓<br>MCP<br>  ↓<br>Cursor<br>  ↓<br>Existing components + design context<br>  ↓<br>Code<br>  ↓<br>Review &amp; refine</pre><p>It doesn’t eliminate the developer.</p><p>It reduces the amount of <strong>manual translation between design and code</strong>.</p><h3>🧠 The Key Idea</h3><p>MCP isn’t magic code generation.</p><p>Think of it as a <strong>context bridge</strong>.</p><pre>MCP<br>              │<br>              ▼<br>┌─────────────┴─────────────┐<br>│                           │<br>Figma                    Cursor<br>│                           │<br>Design                     Code<br>Components                 Components<br>Variables                  Logic<br>Layout                     APIs<br>Tokens                     Tests</pre><p>The better the design system and the better the codebase structure, the more useful this workflow becomes.</p><h3>🎯 Final Takeaway</h3><p>If you’re already using <strong>Figma + Cursor</strong>, MCP is worth exploring.</p><p>Instead of:</p><blockquote><strong><em>“Here’s a screenshot. Please recreate it.”</em></strong></blockquote><p>you can move toward:</p><blockquote><strong><em>“Here’s the Figma design. Understand its structure and implement it using my existing codebase.”</em></strong></blockquote><p>That’s the real value of MCP:</p><p><strong>Less guessing. More context. Better design-to-code workflows. 🚀</strong></p><p>And we’re only getting started.</p><p>Keep Learning and Keep Sharing :)</p><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us"><strong>here</strong></a><strong>.</strong></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=989655d1ba1d" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/from-figma-design-to-code-with-mcp-cursor-989655d1ba1d">From Figma Design to Code with MCP + Cursor 🚀</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Is React Native 0.86 Worth the Upgrade ?]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/is-react-native-0-86-worth-the-upgrade-3fc069217f31?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/3fc069217f31</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 19:55:10 GMT</pubDate>
            <atom:updated>2026-08-04T19:55:10.196Z</atom:updated>
            <content:encoded><![CDATA[<p>Official release notes explicitly state that <strong>0.86 has no user-facing breaking changes</strong></p><blockquote><strong><em>“I already have a React Native application running in production. Is React Native 0.86 worth the upgrade?”</em></strong></blockquote><p>It depends on your needs. If you’re already on a recent React Native version and your app is stable, there’s no urgent reason to upgrade immediately.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1Nn0rvvxSbUW2tzBF-JYyg.png" /></figure><p>However, React Native 0.86 includes improvements such as <strong>more reliable layout measurements, better Android edge-to-edge support, Hermes and Metro updates, developer tooling enhancements, and numerous bug fixes and stability improvements</strong>. If any of these address issues you’re facing, upgrading can provide tangible benefits.</p><h3>1. Introduction</h3><blockquote><em>React Native upgrades have historically been something developers approach carefully. A version bump can affect native dependencies, Gradle, CocoaPods, third-party libraries, animations, and CI/CD pipelines.</em></blockquote><p><strong>React Native 0.86 is interesting because it takes a different approach: it brings important improvements while introducing no user-facing breaking changes.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*I40OTIbj7tlPRQL4SRjM4Q.png" /></figure><h3>2. What’s New in React Native 0.86?</h3><h3>1. 🚀 Android Edge-to-Edge</h3><p>React Native 0.86 improves Android 15+ edge-to-edge behavior, including fixes for:</p><ul><li>measureInWindow</li><li>KeyboardAvoidingView</li><li>Dimensions</li><li>StatusBar</li><li>Modal behavior</li><li>Navigation bar contrast</li></ul><p>You could include a practical example showing what developers may notice in an existing application.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eIvn4r5x3Qnrc3222ZYfVw.png" /></figure><h3>🛠️ React Native DevTools Improvements</h3><p>Developers can now test appearance-mode behavior directly from React Native DevTools without changing the device’s system setting.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OYJhOsyCvPD7YvVmUie2FA.png" /></figure><h3>🌐 React Native’s New Home</h3><p>React Native, React, Metro, Yoga and the React Native website moved from the <strong>Facebook GitHub organization to the React organization</strong> as part of the transition toward the React Foundation.</p><h3>3. Are There Really No Breaking Changes?</h3><h3>Short answer: No user-facing breaking changes.</h3><p>React Native explicitly states that applications on <strong>0.85 should be able to upgrade to 0.86 without changes to application code</strong>.</p><p><strong>Breaking changes </strong>and <strong>Deprecations / behavior changes / dependency compatibility</strong></p><p>For example, 0.86 deprecates:</p><pre>ViewUtil.getUIManagerType</pre><p>and the second argument of:</p><pre>AppRegistry.setComponentProviderInstrumentationHook</pre><p>These aren’t immediate upgrade blockers, but we should know about them because deprecated APIs are candidates for future removal.</p><h3>4. Other Changes Developers Should Know</h3><p>This can be a more technical section.</p><p>Discuss:</p><p>JSI improvements</p><ul><li>TypedArray / Uint8Array</li><li>ArrayBuffer.detached</li><li>String.length</li><li>isInteger</li></ul><p>New JavaScript error creation APIs</p><ul><li>PerformanceObserver behavior</li><li>Modal style behavior</li><li>Animated mounting synchronization</li><li>Headless JS module registration</li></ul><h3>5. React Native 0.85 vs 0.86</h3><p>AreaRN 0.85RN 0.86Breaking changesSome<strong>None user-facing</strong>AnimationNew animation backendFurther improvementsAndroidExisting edge-to-edge work<strong>Major edge-to-edge fixes</strong>DevToolsImprovements<strong>Appearance emulation</strong>JSIExisting APIs<strong>Additional JSI capabilities</strong>Upgrade riskMedium<strong>Lower</strong></p><p>The comparison should emphasize that <strong>0.85 was a larger behavioral/dependency change</strong>, while 0.86 is more focused on polish, compatibility and developer experience.</p><h3>6. What About Developers on RN 0.72 / 0.74?</h3><p>Based on the kinds of React Native projects you’ve been working with.</p><p>If you are on 0.72:</p><blockquote><em>“Just upgrade directly to 0.86.”</em></blockquote><p><strong>0.72 → 0.86 is a very different upgrade experience from 0.85 → 0.86.</strong></p><p>There are several intermediate React Native changes to account for, so developers should use the <strong>React Native Upgrade Helper</strong> and review each version transition rather than treating it as a single package update. React Native’s own upgrade documentation recommends using Upgrade Helper for these project-file changes.</p><h3>7. Third-Party Libraries: The Real Upgrade Risk</h3><p>Check for Below packages</p><ul><li>react-native-reanimated</li><li>Navigation libraries</li><li>Gesture Handler</li><li>Firebase</li><li>Sentry</li><li>Native SDKs</li><li>Camera libraries</li><li>Maps</li><li>Payment SDKs</li><li>Custom native modules</li></ul><p>The key point:</p><blockquote><strong><em>React Native 0.86 may have no user-facing breaking changes, but your dependencies can still introduce upgrade problems.</em></strong></blockquote><h3>8. Android Checklist Before Upgrade</h3><p>Checklist:</p><pre>☐ Check React Native version<br>☐ Check React version<br>☐ Check Node.js version<br>☐ Check Android Gradle Plugin<br>☐ Check Gradle version<br>☐ Check Kotlin version<br>☐ Check compileSdk / targetSdk<br>☐ Check native modules<br>☐ Check Reanimated compatibility<br>☐ Test Android 15 edge-to-edge<br>☐ Test keyboard behavior<br>☐ Test StatusBar<br>☐ Test Modal<br>☐ Run release build</pre><h3>9. iOS Checklist</h3><pre>☐ Check Xcode version<br>☐ Check CocoaPods<br>☐ Run pod install<br>☐ Verify native modules<br>☐ Test Debug build<br>☐ Test Release build<br>☐ Test physical device<br>☐ Test CI/CD build</pre><h3>10. How to Upgrade</h3><p>Checkout with this</p><pre>git checkout -b upgrade/react-native-086</pre><p>Then use the React Native Upgrade Helper and update the relevant dependencies/project files.</p><p>For a new Community CLI project, the official release documentation provides:</p><pre>npx @react-native-community/cli@latest init MyProject --version latest</pre><p>For existing applications, React Native recommends <strong>Upgrade Helper</strong> alongside the upgrading documentation.</p><h3>🟢 Definitely consider upgrading</h3><p>If you’re on:</p><ul><li>RN 0.85</li><li>A well-maintained project</li><li>Current native dependencies</li><li>Android 15 compatibility is important</li></ul><h3>🟡 Upgrade carefully</h3><p>If you’re on:</p><ul><li>RN 0.80–0.84</li><li>Large production application</li><li>Many native modules</li><li>Custom Android/iOS code</li></ul><h3>🔴 Don’t rush</h3><p>If you’re on:</p><ul><li>RN 0.72/0.73 with lots of custom native code</li><li>Unmaintained third-party libraries</li><li>A release currently in stabilization</li></ul><h3>12. Final Verdict</h3><blockquote><strong><em>React Native 0.86 isn’t a revolutionary release — and that’s actually a good thing.</em></strong></blockquote><blockquote><em>Its biggest advantage is that it delivers meaningful Android edge-to-edge improvements, better DevTools, JSI enhancements and other fixes without introducing user-facing breaking changes.</em></blockquote><blockquote><em>For teams already on React Native 0.85, upgrading to 0.86 should be relatively straightforward. For older applications, the upgrade should still be treated as a migration project because the real risk often comes from native dependencies rather than React Native itself.</em></blockquote><blockquote><strong><em>So, should you upgrade?</em></strong></blockquote><blockquote><strong><em>Yes — if your dependencies are ready and you’ve tested your production-critical flows.</em></strong></blockquote><p>React Native 0.86 is currently an <strong>active supported release</strong>, according to the official React Native release schedule.</p><p>Keep Learning and Keep Sharing :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3fc069217f31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Android Developer Verification: Everything You Need to Know (2026 Guide)]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/android-developer-verification-everything-you-need-to-know-2026-guide-a4197792c9af?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/a4197792c9af</guid>
            <category><![CDATA[android]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 19:23:18 GMT</pubDate>
            <atom:updated>2026-07-05T19:23:18.551Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Last Updated: July 2026</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SlcHA-2Q642ngArCNz9Ncw.png" /></figure><p>Google is making the Android ecosystem safer by introducing <strong>Android Developer Verification</strong>, a mandatory verification program for developers publishing apps through Google Play and, eventually, outside Google Play as well.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CJgyLbjamznT92RiiG--5A.png" /></figure><p>The initiative aims to increase transparency, reduce malware, and make it harder for malicious developers to repeatedly distribute harmful applications.</p><h3>Why Google Introduced Android Developer Verification</h3><p>Android’s open ecosystem has always allowed developers to distribute apps through multiple channels. While this openness has many benefits, it has also made it easier for malicious actors to distribute fake or harmful applications.</p><p>According to Google’s official announcement, its analysis found that <strong>users encounter over 90 times more malware from sideloaded sources than from Google Play</strong>. To address this, Google introduced Android Developer Verification as an additional layer of security while maintaining Android’s openness.</p><h3>What Is Android Developer Verification?</h3><p>Android Developer Verification is a process that verifies the identity of developers before their apps can be distributed on certified Android devices.</p><p>The verification process helps Google:</p><ul><li>Verify the identity of developers.</li><li>Increase transparency for users.</li><li>Prevent banned developers from repeatedly creating new accounts.</li><li>Reduce malware and fraudulent applications.</li><li>Improve trust across the Android ecosystem.</li></ul><h3>Google Play Developer Verification vs Android Developer Verification</h3><p>Although they sound similar, there are two related verification programs.</p><h3>Google Play Developer Verification</h3><p>This applies to developers publishing apps through the Google Play Store. Developers verify their identity through the Play Console.</p><h3>Android Developer Verification</h3><p>Announced in <strong>August 2025</strong>, this broader program also covers apps distributed <strong>outside Google Play</strong>, including third-party app stores and direct APK distribution.</p><h3>Official Timeline</h3><p>Google has announced the following rollout schedule:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*M7zIkRn3i-6ywMQWblvIuA.png" /></figure><p><strong>September 30, 2026 </strong>Apps installed on certified Android devices in <strong>Brazil, Indonesia, Singapore, and Thailand</strong> must be registered to verified developers. <strong>2027 onwards </strong>Global rollout planned.</p><p>What Information Must Developers Verify?</p><p>Depending on the account type, Google requires different information.</p><h3>Personal Developer Accounts</h3><p>Developers typically need to provide:</p><ul><li>Government-issued photo ID</li><li>Legal name</li><li>Address verification through the linked Google Payments profile</li></ul><h3>Organization Accounts</h3><p>Organizations generally need:</p><ul><li>Business information</li><li>Legal organization details</li><li>Linked Google Payments profile</li><li><strong>D-U-N-S Number</strong> (unless exempt, such as certain government organizations)</li></ul><h3>Verification Process</h3><p>The verification process usually consists of the following steps:</p><ol><li>Sign in to Play Console.</li><li>Open the Developer Verification section.</li><li>Verify your Payments Profile.</li><li>Upload the requested identity or organization documents.</li><li>Confirm your developer information.</li><li>Submit for review.</li><li>Wait for Google’s approval.</li></ol><p>Developers can generally begin verification <strong>60 days before their assigned deadline</strong> in Play Console.</p><h3>Information Visible to Users</h3><p>After verification, Google may display verified developer information to help users identify legitimate publishers.</p><p>Depending on the account type, this may include:</p><ul><li>Developer name</li><li>Organization name</li><li>Country or address</li><li>Contact information</li></ul><p>This improves transparency and user confidence when installing apps.</p><h3>Benefits of Verification</h3><h3>Improved User Trust</h3><p>Verified developers appear more credible, encouraging users to install their apps with confidence.</p><h3>Stronger Security</h3><p>Verification makes it more difficult for scammers to create multiple anonymous developer accounts.</p><h3>Better Transparency</h3><p>Users can see verified publisher information before downloading an app.</p><h3>Policy Compliance</h3><p>Completing verification ensures compliance with Google’s latest developer policies and avoids publishing interruptions.</p><h3>What Happens If You Don’t Verify?</h3><p>Failure to complete verification by the required deadline may result in:</p><ul><li>Inability to publish new apps.</li><li>Restrictions on app updates.</li><li>Apps becoming unavailable on certified Android devices in applicable regions.</li><li>Developer account restrictions until verification is completed.</li></ul><h3>Best Practices</h3><p>To avoid delays during verification:</p><ul><li>Keep your legal name consistent across all documents.</li><li>Ensure your Google Payments profile is up to date.</li><li>Upload clear, high-quality scans of identification documents.</li><li>Respond promptly to any requests for additional information.</li><li>Enable two-factor authentication on your Google account.</li></ul><h3>Frequently Asked Questions</h3><h3>Is verification mandatory?</h3><p>Yes. Google is gradually making developer verification mandatory for all Android developers distributing apps through Google Play and, over time, for apps distributed outside Google Play on certified Android devices.</p><h3>Do existing developers need to verify?</h3><p>Yes. Existing Play Console developers are being asked to complete verification according to deadlines assigned within the Play Console.</p><h3>Will this stop sideloading?</h3><p>No. Android continues to support sideloading. However, starting with the initial rollout in September 2026, apps installed on certified Android devices in certain countries must be registered to a verified developer, with an advanced flow available for experienced users.</p><h3>Conclusion</h3><p>Android Developer Verification represents one of Google’s most significant security initiatives in recent years. By verifying developer identities and increasing transparency, Google aims to create a safer Android ecosystem while preserving the platform’s openness.</p><p>Whether you’re an independent developer, a startup, or an enterprise, completing verification early will help ensure uninterrupted app publishing and strengthen user trust. Staying informed about Google’s evolving verification requirements is now an essential part of Android app development.</p><blockquote><strong><em>As digital security becomes increasingly important, similar developer verification programs could be adopted by other app stores in the future. Verifying developer identities helps build user trust, reduce malicious apps, and establish a safer experience across mobile platforms. Developers should stay prepared for these evolving standards as they are likely to become a common industry practice.</em></strong></blockquote><p>Keep Learning and Keep Sharing :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a4197792c9af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Native OTA Updates After App Center: A Practical Alternative with Stallion]]></title>
            <link>https://blog.stackademic.com/react-native-ota-updates-after-app-center-a-practical-alternative-with-stallion-d0ca0dc2b7a9?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0ca0dc2b7a9</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[mobile]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 19:01:50 GMT</pubDate>
            <atom:updated>2026-06-18T13:51:43.241Z</atom:updated>
            <content:encoded><![CDATA[<p>For years, many React Native teams relied on Microsoft’s App Center CodePush to deliver Over-the-Air (OTA) updates. It allowed developers to push JavaScript changes instantly without waiting for App Store or Google Play review cycles.</p><p>When App Center’s services were discontinued, many teams were left searching for a reliable replacement.</p><p>Recently, I explored Stallion as an alternative OTA solution for React Native applications, and the experience was surprisingly straightforward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VjpVM0ssGOQXep3tbv8wdw.png" /></figure><h3>Why OTA Updates Matter</h3><p>Imagine discovering a small bug in production:</p><ul><li>A typo on a critical screen</li><li>A broken validation message</li><li>A minor UI issue</li><li>A business logic fix written in JavaScript</li></ul><p>Without OTA updates, the process typically involves:</p><ol><li>Creating a new build</li><li>Uploading it to the App Store and Play Store</li><li>Waiting for review and approval</li><li>Waiting for users to update</li></ol><p>This process can take hours or even days.</p><p>OTA updates solve this problem by delivering JavaScript bundle updates directly to users while keeping the native application binary unchanged.</p><h3>The Challenge After App Center</h3><p>When App Center OTA updates became unavailable, many React Native developers started evaluating alternatives.</p><p>The ideal replacement should provide:</p><ul><li>Easy React Native integration</li><li>Reliable update delivery</li><li>Version management</li><li>Rollback support</li><li>Affordable pricing</li><li>Simple deployment workflows</li></ul><p>This is where Stallion caught my attention.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wHeNW5E7uhXUi6Un2PWpUA.png" /></figure><h3>My Experience with Stallion</h3><p>Setting up Stallion was much easier than expected.</p><p>The integration process required only a few configuration steps before I could publish OTA updates.</p><p>What stood out:</p><h3>1. Fast Integration</h3><p>The setup process fits naturally into existing React Native projects.</p><p>There is no need to redesign your deployment workflow.</p><h3>2. Quick Production Fixes</h3><p>After deployment, JavaScript changes can be delivered rapidly without requiring a new store submission.</p><p>This is especially useful for:</p><ul><li>Bug fixes</li><li>Text changes</li><li>UI improvements</li><li>Feature flags</li><li>Business logic updates</li></ul><h3>3. Free Tier Availability</h3><p>For small teams, startups, and side projects, having a free tier makes experimentation easy.</p><h3>4. Better Developer Productivity</h3><p>The biggest advantage is speed.</p><p>Instead of waiting for app store approval cycles, developers can respond quickly to production issues and improve user experience faster.</p><h3>Getting Started with Stallion OTA Updates</h3><p>After creating an application in the Stallion dashboard, integrating OTA updates into a React Native project requires only a few steps.</p><h3>Step 1: Install the SDK</h3><pre>npm install @stallion/react-native</pre><p>or</p><pre>yarn add @stallion/react-native</pre><h3>Step 2: Configure Stallion</h3><p>Initialize Stallion when your application starts.</p><pre>import Stallion from &#39;@stallion/react-native&#39;;<br><br>await Stallion.initialize({<br>  appId: &#39;YOUR_APP_ID&#39;,<br>  environment: &#39;production&#39;,<br>});</pre><p>Replace YOUR_APP_ID with the application identifier from the Stallion dashboard.</p><h3>Step 3: Check for Updates</h3><p>You can check for available updates during app startup.</p><pre>import Stallion from &#39;@stallion/react-native&#39;;<br><br>async function checkForUpdates() {<br>  try {<br>    const update = await Stallion.checkForUpdate();if (update?.available) {<br>      await Stallion.downloadUpdate();<br>      await Stallion.installUpdate();<br>    }<br>  } catch (error) {<br>    console.error(&#39;Update failed:&#39;, error);<br>  }<br>}</pre><h3>Step 4: Publish an OTA Update</h3><p>Once you’ve made JavaScript changes, publish a new bundle.</p><pre>stallion release \<br>  --platform android \<br>  --environment production</pre><p>For iOS:</p><pre>stallion release \<br>  --platform ios \<br>  --environment production</pre><h3>Step 5: Roll Out to Users</h3><p>After publishing, compatible app versions will automatically receive the updated JavaScript bundle without requiring a new App Store or Google Play release.</p><p>This workflow is ideal for:</p><ul><li>Fixing production bugs</li><li>Updating UI components</li><li>Correcting copy or translations</li><li>Adjusting business logic</li><li>Enabling feature flags</li></ul><h3>Example Use Case</h3><p>Imagine you discover an incorrect validation message on your login screen:</p><pre>// Before<br>setError(&#39;Password is invalid&#39;);</pre><pre>// After<br>setError(&#39;Please enter a valid password&#39;);</pre><p>Instead of creating a new store build and waiting for approval, you can publish an OTA update through Stallion and have the fix delivered to users within minutes.</p><h3>Important Limitations of OTA Updates</h3><p>OTA updates are powerful, but they are not magic.</p><p>You still need a new App Store or Play Store release when changing:</p><ul><li>Native Android code</li><li>Native iOS code</li><li>Native libraries</li><li>Application permissions</li><li>Build configurations</li><li>Native SDK integrations</li><li>Certain bundled assets</li></ul><p>OTA updates only affect the JavaScript layer of your React Native application.</p><p>Understanding this limitation is essential for planning releases correctly.</p><h3>When OTA Updates Make the Most Sense</h3><p>OTA updates work best for:</p><p>✅ Bug fixes</p><p>✅ UI improvements</p><p>✅ Copy updates</p><p>✅ Business logic changes</p><p>✅ Feature toggles</p><p>✅ Minor enhancements</p><p>Store releases remain necessary for:</p><p>❌ Native module updates</p><p>❌ SDK upgrades</p><p>❌ Permission changes</p><p>❌ Build configuration changes</p><h3>Final Thoughts</h3><p>The discontinuation of App Center forced many React Native teams to rethink their OTA update strategy.</p><p>After testing Stallion, I found it to be a practical and developer-friendly alternative for delivering React Native OTA updates.</p><p>For teams that value rapid iteration and faster production fixes, OTA updates remain one of the most valuable tools in the React Native ecosystem.</p><p>The ability to fix issues in minutes instead of days can have a significant impact on both development velocity and user satisfaction.</p><p>If your team previously depended on App Center CodePush, exploring modern OTA solutions like Stallion is definitely worth considering.</p><p>Have you migrated away from App Center? I’d be interested to hear which OTA solution your team chose and why.</p><p>Keep Learning and Keep Sharing :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0ca0dc2b7a9" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/react-native-ota-updates-after-app-center-a-practical-alternative-with-stallion-d0ca0dc2b7a9">React Native OTA Updates After App Center: A Practical Alternative with Stallion</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Native Stack in 2026 (Complete Developer Stack Guide) ]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/react-native-stack-in-2026-complete-developer-stack-guide-4dacbec2f8c6?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/4dacbec2f8c6</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Thu, 09 Apr 2026 20:19:28 GMT</pubDate>
            <atom:updated>2026-04-09T20:19:28.555Z</atom:updated>
            <content:encoded><![CDATA[<p>In 2026, building a React Native app is no longer about picking a framework.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VCgAdzgt4J5ohOVFgkCfzA.png" /></figure><p>It’s about choosing the <strong>right combination of tools</strong> across:</p><ul><li>Development</li><li>State management</li><li>Backend</li><li>Performance</li><li>Monetization</li><li>Observability</li></ul><p>Most guides stop at “React Navigation + Redux.”</p><p>That’s outdated.</p><p>This guide covers the <strong>real production stack used in 2026</strong>.</p><h3>⚡ The 2026 Reality</h3><p>Modern React Native apps are:</p><ul><li>Type-safe</li><li>Offline-capable</li><li>AI-assisted during development</li><li>Backend-flexible</li><li>Performance-optimized by default</li></ul><p>👉 If your stack doesn’t reflect this, you’ll struggle to scale.</p><h3>🧱 1. Language &amp; Developer Experience</h3><h3>✅ TypeScript (Non-Negotiable)</h3><ul><li>Type safety</li><li>Better tooling</li><li>Fewer runtime bugs</li></ul><p>👉 Every serious React Native app in 2026 uses TypeScript.</p><h3>🤖 AI-Powered Development</h3><p>Modern IDE choices:</p><ul><li>Cursor</li><li>Windsurf</li><li>VS Code + Copilot</li><li>Anti-Gravity AI</li></ul><p>👉 These tools:</p><ul><li>Generate components</li><li>Write hooks</li><li>Debug faster</li></ul><p><strong>Reality:</strong> AI is now part of the stack, not optional.</p><h3>📱 2. App Framework</h3><h3>🚀 Expo + Expo Router</h3><ul><li>Expo → core framework</li><li>Expo Router → file-based navigation</li></ul><p>Why this combo?</p><ul><li>Faster development</li><li>Cleaner routing (Next.js style)</li><li>Better scalability</li></ul><h3>⚙️ Expo Application Services (EAS)</h3><ul><li>Build</li><li>Deploy</li><li>OTA updates</li></ul><p>👉 This replaces complex CI/CD for most apps.</p><h3>🧭 3. Navigation</h3><h3>Expo Router (Preferred)</h3><ul><li>File-based routing</li><li>Deep linking support</li><li>Cleaner structure</li></ul><p>👉 React Navigation still exists under the hood.</p><h3>🧠 4. State Management</h3><h3>Zustand (Primary)</h3><ul><li>Minimal boilerplate</li><li>Fast</li><li>Easy to scale</li></ul><p>👉 Perfect for most apps.</p><h3>TanStack Query (Server State)</h3><ul><li>API caching</li><li>Background sync</li><li>Retry logic</li></ul><p>👉 Separates server state from UI state (huge improvement).</p><h3>📝 5. Forms &amp; Validation</h3><h3>React Hook Form + Zod</h3><ul><li>Performant forms</li><li>Schema validation</li></ul><p>👉 Clean, scalable, and type-safe.</p><h3>💾 6. Storage Layer</h3><h3>Local Storage Options</h3><h4>⚡ React Native MMKV</h4><ul><li>Ultra-fast key-value storage</li><li>Best for tokens, flags</li></ul><h4>🗄️ Expo SQLite</h4><ul><li>Structured local database</li><li>Offline-first apps</li></ul><h3>🧬 ORM / Database Layer</h3><ul><li>Drizzle → lightweight &amp; modern</li><li>Prisma → powerful but heavier</li></ul><p>👉 Use only if your app needs structured queries.</p><h3>🌐 7. Backend Choices</h3><h3>🔥 Supabase</h3><ul><li>Open-source Firebase alternative</li><li>Auth + DB + Realtime</li></ul><h3>⚡ InstantDB</h3><ul><li>Real-time sync out of the box</li></ul><p>👉 Choose based on:</p><ul><li>Simplicity vs flexibility</li></ul><h3>🔌 Expo API Routes</h3><ul><li>Build backend inside Expo app</li><li>Great for small APIs</li></ul><p>👉 Perfect for MVPs and internal logic.</p><h3>🎨 8. Styling System</h3><p>Modern options:</p><ul><li>StyleSheet (default)</li><li>Unistyles (performance-focused)</li><li>Uniwind / NativeWind (utility-first)</li><li>Expo UI (component system)</li></ul><p>👉 Trend: move toward <strong>design systems + utility styling</strong></p><h3>🎬 9. Animations &amp; Gestures</h3><h3>Must-Have:</h3><ul><li>Reanimated</li><li>Gesture Handler</li></ul><p>👉 Required for smooth, native-level UX.</p><h3>🔐 10. Authentication</h3><h3>Clerk (Modern Choice)</h3><ul><li>Easy integration</li><li>Secure</li><li>Scalable</li></ul><p>Alternative:</p><ul><li>Supabase Auth</li></ul><h3>💰 11. Monetization</h3><h3>RevenueCat</h3><ul><li>Subscriptions</li><li>In-app purchases</li></ul><p>👉 Saves months of native work.</p><h3>📊 12. Analytics &amp; Tracking</h3><h3>Options:</h3><ul><li>PostHog → product analytics</li><li>Adobe Analytics → enterprise</li><li>Custom events (recommended)</li></ul><p>👉 Track:</p><ul><li>User behavior</li><li>Conversion</li><li>Retention</li></ul><h3>🚨 13. Error Tracking &amp; Monitoring</h3><h3>Tools:</h3><ul><li>Sentry</li><li>Quantum Metrics</li></ul><p>👉 Detect crashes before users complain.</p><h3>🧪 14. Code Quality &amp; Reviews</h3><h3>CodeRabbit</h3><ul><li>AI code reviews</li><li>PR suggestions</li></ul><p>👉 Improves code quality automatically.</p><h3>🧩 Example Complete Stack (2026)</h3><h3>🚀 MVP / Startup Stack</h3><ul><li>TypeScript</li><li>Expo + Expo Router</li><li>Zustand</li><li>TanStack Query</li><li>Supabase</li><li>React Hook Form + Zod</li><li>MMKV</li><li>Reanimated</li><li>EAS</li></ul><p>👉 Perfect for fast shipping.</p><h3>🏢 Production-Scale Stack</h3><ul><li>TypeScript</li><li>Expo / CLI</li><li>Zustand + TanStack Query</li><li>Clerk Auth</li><li>Supabase / Prisma</li><li>SQLite + MMKV</li><li>Sentry</li><li>PostHog</li><li>RevenueCat</li></ul><h3>⚠️ Common Mistakes (Still Happening)</h3><p>❌ Adding every tool from day one<br>❌ Using Prisma for small apps<br>❌ Ignoring offline storage<br>❌ Skipping analytics<br>❌ Not using TypeScript</p><h3>🌍 Real-World Insight (India &amp; Emerging Markets)</h3><ul><li>Low-end devices dominate</li><li>Network is unreliable</li><li>App size matters</li></ul><p>👉 So prioritize:</p><ul><li>MMKV over heavy storage</li><li>Lightweight UI</li><li>Offline-first design</li></ul><h3>🔥 Final Recommendation</h3><p>Start with:</p><ul><li>Expo + Expo Router</li><li>TypeScript</li><li>Zustand</li><li>TanStack Query</li><li>Supabase</li><li>MMKV</li></ul><p>Then scale gradually.</p><h3>💡 Closing Thought</h3><p>In 2026, the best developers don’t use more tools.</p><p>They use <strong>the right tools at the right time</strong>.</p><p>👉 Keep your stack lean.<br>👉 Ship fast.<br>👉 Optimize later.</p><h3>👇 What’s Next?</h3><p>If you’re building a real app (like a labour marketplace), I can help you:</p><ul><li>Set up this full stack</li><li>Create a starter template</li><li>Optimize for performance</li></ul><h3>Quick Explanation of the Layers</h3><ul><li><strong>Frontend</strong> → Expo + TypeScript + Router</li><li><strong>UI Layer</strong> → Styling system (Unistyles / NativeWind / Expo UI)</li><li><strong>State Layer</strong> → Zustand + TanStack Query</li><li><strong>Forms</strong> → React Hook Form + Zod</li><li><strong>Storage</strong> → MMKV + SQLite</li><li><strong>API Layer</strong> → Expo API Routes</li><li><strong>Backend</strong> → Supabase / Prisma / InstantDB</li><li><strong>Services</strong> → Auth, Analytics, Payments, Monitoring</li></ul><p>Keep Learning and Keep Sharing 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4dacbec2f8c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cursor AI: The Tool That’s Changing How Developers Write Code]]></title>
            <link>https://medium.com/@hrusikesh251.nalanda/cursor-ai-the-tool-thats-changing-how-developers-write-code-37491e1c1868?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/37491e1c1868</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[reactjs]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Mon, 23 Mar 2026 19:21:14 GMT</pubDate>
            <atom:updated>2026-03-23T19:21:14.655Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oSMjWpt152wP513HDY8cng.png" /></figure><p>AI is changing how developers write code. Instead of typing everything manually, developers can now <strong>collaborate with AI inside their editor</strong>.</p><p>One of the most powerful tools leading this shift is <strong>Cursor AI code editor</strong>.</p><p>Cursor is an <strong>AI-native code editor</strong> that allows developers to write, refactor, and debug code using simple natural language prompts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hbjyyeGzwPk1xmeQSNvaw.png" /></figure><h3>Why Cursor AI is Getting Popular</h3><p>Cursor helps developers work faster by combining coding and AI assistance in one place.</p><p>Key benefits:</p><p>⚡ Faster code generation<br> 🐞 Instant debugging help<br> 🧠 Code explanations for complex logic<br> 🚀 Rapid prototyping</p><p>Instead of writing boilerplate code, developers can simply <strong>ask the AI to generate it</strong>.</p><h3>How I Used Cursor in My Demo Project</h3><p>To test Cursor AI, I created a small demo project and used AI prompts to speed up development.</p><h3>Step 1: Open the Project in Cursor</h3><p>After installing Cursor, I opened my project folder just like a normal editor.</p><p>Cursor automatically understands the <strong>context of the entire codebase</strong>. Login or Signup and provide github access to use it further and you can follow below screenshots attached.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3J63iqKRcGnTuqbH0gaUYQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MFokPRmwE7qtbV4Ho1vMTQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*neLx8wJTgeOjwcYRhmxBcA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZgyYMudTcz-4fRhppRVDg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0hbjyyeGzwPk1xmeQSNvaw.png" /></figure><h3>Step 2: Ask AI to Fix Error in Code</h3><p>Instead of fixing code manually, I used prompts like:</p><pre>yarn ios not working getting below error</pre><p>Cursor fixed the code instantly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zyTybOL4cKs7Ytl9W6uRIw.png" /></figure><h3>Step 3: Refactor Existing Code</h3><p>I also tried improving existing code using prompts such as:</p><pre>Refactor this function and improve performance.</pre><p>Cursor analyzed the file and suggested a cleaner implementation.</p><h3>Step 4: Debug Errors</h3><p>When an error appeared, I simply asked:</p><pre>Why is this code failing?</pre><p>Cursor explained the issue and suggested the fix.</p><p>This saved a lot of <strong>debugging time</strong>.</p><h3>The Future of Development</h3><p>Tools like Cursor show how software development is evolving.</p><p>Developers are moving from <strong>writing every line of code</strong> to <strong>guiding AI to build solutions faster</strong>.</p><p>The result?</p><p>Better productivity, faster development cycles, and more time for innovation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L3X-3aSrMAB8Kwdq2Rq_DA.png" /></figure><h3>Final Thoughts</h3><p>Cursor AI is more than just another coding tool — it’s a <strong>new way of building software</strong>.</p><p>If you haven’t tried it yet, open one of your projects in Cursor and start prompting.</p><p>You might be surprised how quickly your next feature gets built.</p><p>Keep Learning and Keep Sharing .</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=37491e1c1868" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[React Native 2026 Edition Interview Questions]]></title>
            <link>https://blog.stackademic.com/react-native-2026-edition-interview-questions-801f4f2bbe1b?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/801f4f2bbe1b</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Tue, 03 Feb 2026 13:29:34 GMT</pubDate>
            <atom:updated>2026-02-04T06:53:46.928Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9r5BEz-QywSFBOH8MOet3w.png" /></figure><h3>🧪 Part 1: Common Interview Questions React native</h3><h3>1️⃣ What is the React Native New Architecture?</h3><p><strong>Answer:</strong><br> The New Architecture modernizes how React Native communicates with native code. It replaces the old asynchronous bridge with:</p><ul><li><strong>JSI (JavaScript Interface)</strong> — allows direct communication between JS and native</li><li><strong>TurboModules</strong> — faster, lazily loaded native modules</li><li><strong>Fabric</strong> — the new rendering system for UI</li></ul><p>This results in <strong>better performance, lower memory usage, and smoother animations</strong>, especially in complex apps.</p><h3>2️⃣ What problems did the old Bridge have?</h3><p><strong>Answer:</strong><br> The old bridge was asynchronous and relied on JSON serialization. This caused:</p><ul><li>Performance bottlenecks</li><li>Delays in UI updates</li><li>High memory overhead</li></ul><p>The New Architecture removes this bottleneck with direct calls via JSI.</p><h3>3️⃣ What is Fabric in React Native?</h3><p><strong>Answer:</strong><br> Fabric is the <strong>new rendering engine</strong>. It improves:</p><ul><li>Faster UI updates</li><li>Better layout calculations</li><li>Smoother gestures and animations</li></ul><p>It also aligns React Native more closely with how React works internally.</p><h3>4️⃣ What are TurboModules?</h3><p><strong>Answer:</strong><br> TurboModules are the new native module system. Key benefits:</p><ul><li>Lazy loading (loaded only when used)</li><li>Faster execution</li><li>Type safety via Codegen</li><li>Works directly through JSI (no bridge)</li></ul><h3>5️⃣ How do you upgrade a React Native project safely?</h3><p><strong>Answer:</strong></p><ol><li>Use <strong>React Native Upgrade Helper</strong> to compare changes</li><li>Upgrade one minor version at a time</li><li>Clear caches (watchman, node_modules, Gradle)</li><li>Update native dependencies (CocoaPods, Gradle, SDK versions)</li><li>Test on real Android &amp; iOS devices</li><li>Check third-party libraries compatibility</li></ol><h3>6️⃣ What are common issues during RN upgrades?</h3><p><strong>Answer:</strong></p><ul><li>Android build failures (Gradle/plugin mismatch)</li><li>iOS pod install errors</li><li>Deprecated APIs removed</li><li>Libraries not supporting New Architecture</li><li>Hermes engine incompatibility in older packages</li></ul><h3>7️⃣ What is Hermes and why is it important?</h3><p><strong>Answer:</strong><br> Hermes is the optimized JavaScript engine for React Native.</p><p>Benefits:</p><ul><li>Faster app startup</li><li>Lower memory usage</li><li>Smaller app size</li><li>Better performance profiling tools</li></ul><p>Most modern RN apps use Hermes by default.</p><h3>8️⃣ FlashList vs FlatList?</h3><p><strong>Answer:</strong></p><pre>| Feature          | FlatList      | FlashList        |<br>| ---------------- | ------------- | ---------------- |<br>| Performance      | Good          | Much faster      |<br>| Large data sets  | Can lag       | Highly optimized |<br>| Item measurement | Manual tuning | Auto-optimized   |<br>| Memory usage     | Higher        | Lower            |</pre><p>FlashList is preferred for <strong>feeds, chats, e-commerce lists</strong>.</p><h3>9️⃣ How do you optimize performance in React Native?</h3><p><strong>Answer:</strong></p><ul><li>Use <strong>FlashList</strong> for large lists</li><li>Memoize components (React.memo)</li><li>Use useCallback and useMemo</li><li>Avoid inline functions in render</li><li>Use <strong>Reanimated</strong> for animations (runs on UI thread)</li><li>Enable <strong>Hermes</strong></li><li>Use Fabric-compatible libraries</li></ul><h3>🔟 What is Reanimated and why is it better than Animated API?</h3><p><strong>Answer:</strong><br> Reanimated runs animations on the <strong>UI thread instead of the JS thread</strong>, so animations remain smooth even if JS is busy.</p><p>Latest versions support:</p><ul><li>Shared element transitions</li><li>Gesture-based animations</li><li>Layout animations</li></ul><h3>1️⃣1️⃣ What is Codegen in React Native?</h3><p><strong>Answer:</strong><br> Codegen automatically generates native code for TurboModules and Fabric components based on TypeScript/Flow definitions.<br> It ensures:</p><ul><li>Type safety</li><li>Better performance</li><li>Less manual native coding</li></ul><h3>1️⃣2️⃣ What is Bridgeless Mode?</h3><p><strong>Answer:</strong><br> Bridgeless Mode removes the old bridge entirely. Apps run fully on JSI + Fabric + TurboModules, reducing overhead and improving startup time.</p><h3>1️⃣3️⃣ How do you debug performance issues?</h3><p><strong>Answer:</strong></p><ul><li>Use <strong>Flipper</strong> (network, layout, logs)</li><li>Use <strong>Hermes profiler</strong></li><li>Check React DevTools Profiler</li><li>Track re-renders using why-did-you-render</li><li>Monitor memory leaks in native modules</li></ul><h3>1️⃣4️⃣ How do you secure a React Native app?</h3><p><strong>Answer:</strong></p><ul><li>Use <strong>secure storage</strong> (Keychain/Keystore/MMKV secure)</li><li>Enable HTTPS with certificate pinning</li><li>Obfuscate Android builds (Proguard/R8)</li><li>Jailbreak/root detection if needed</li><li>Avoid storing secrets in JS code</li></ul><h3>1️⃣5️⃣ What is the difference between Expo and React Native CLI?</h3><p><strong>Answer:</strong></p><pre>| Expo                                           | CLI                 |<br>| ---------------------------------------------- | ------------------- |<br>| Faster setup                                   | More native control |<br>| Managed workflow                               | Full native access  |<br>| OTA updates built-in                           | Manual setup        |<br>| Limited native customization (unless prebuild) | Full flexibility    |</pre><h3>1️⃣6️⃣ How does navigation work in modern React Native apps?</h3><p><strong>Answer:</strong><br> Most apps use <strong>React Navigation</strong> with:</p><ul><li>Stack Navigator</li><li>Bottom Tabs</li><li>Drawer</li><li>Native Stack (better performance)</li></ul><p>It integrates well with gestures and deep linking.</p><h3>1️⃣7️⃣ What testing tools are used in React Native?</h3><p><strong>Answer:</strong></p><ul><li><strong>Jest</strong> — unit testing</li><li><strong>React Native Testing Library</strong> — component testing</li><li><strong>Detox</strong> — end-to-end testing</li><li><strong>Maestro</strong> (gaining popularity for mobile E2E)</li></ul><h3>1️⃣8️⃣ How do you handle app state in large RN apps?</h3><p><strong>Answer:</strong></p><ul><li>Context API (small apps)</li><li>Redux Toolkit</li><li>Zustand (lightweight modern choice)</li><li>Recoil / Jotai in some apps</li></ul><h3>1️⃣9️⃣ What are best practices for handling large apps?</h3><p><strong>Answer:</strong></p><ul><li>Modular folder structure</li><li>Separate UI &amp; business logic</li><li>Use TypeScript</li><li>Lazy load screens</li><li>Optimize images and assets</li><li>Monitor performance regularly</li></ul><h3>2️⃣0️⃣ What’s one recent RN change that impacted development?</h3><p><strong>Answer:</strong><br> The gradual rollout of the <strong>New Architecture</strong> changed how libraries are written. Many older native modules needed rewrites for TurboModules/Fabric compatibility. Modern apps must ensure libraries support the new system for best performance.</p><h3>🧪 Part 2: Live Coding Challenges (React Native Interviews)</h3><p>These are very common in <strong>mid–senior RN interviews</strong>.</p><h3>🧩 Challenge 1: Build a Searchable List</h3><p><strong>Task:</strong><br> Create a screen with:</p><ul><li>A search input</li><li>A list of items</li><li>Filtering happens as user types</li></ul><p><strong>What interviewer checks:</strong></p><ul><li>useState usage</li><li>FlatList optimization</li><li>Proper keyExtractor</li><li>Debouncing (bonus)</li></ul><p><strong>Basic Solution Idea:</strong></p><pre>const DATA = [&quot;Apple&quot;, &quot;Banana&quot;, &quot;Mango&quot;, &quot;Orange&quot;, &quot;Pineapple&quot;];</pre><pre>export default function SearchList() {<br>  const [query, setQuery] = useState(&quot;&quot;);</pre><pre>  const filtered = DATA.filter(item =&gt;<br>    item.toLowerCase().includes(query.toLowerCase())<br>  );</pre><pre>  return (<br>    &lt;View&gt;<br>      &lt;TextInput<br>        placeholder=&quot;Search...&quot;<br>        value={query}<br>        onChangeText={setQuery}<br>      /&gt;<br>      &lt;FlatList<br>        data={filtered}<br>        keyExtractor={(item) =&gt; item}<br>        renderItem={({ item }) =&gt; &lt;Text&gt;{item}&lt;/Text&gt;}<br>      /&gt;<br>    &lt;/View&gt;<br>  );<br>}</pre><h3>🧩 Challenge 2: Counter with useReducer</h3><p><strong>Task:</strong> Build a counter with Increment, Decrement, Reset.</p><p><strong>Checks:</strong> Understanding of useReducer vs useState.</p><pre>function reducer(state, action) {<br>  switch (action.type) {<br>    case &quot;inc&quot;: return { count: state.count + 1 };<br>    case &quot;dec&quot;: return { count: state.count - 1 };<br>    case &quot;reset&quot;: return { count: 0 };<br>    default: return state;<br>  }<br>}</pre><h3>🧩 Challenge 3: API Fetch with Loading &amp; Error</h3><p><strong>Task:</strong> Fetch API data and show:</p><ul><li>Loader</li><li>Error state</li><li>List result</li></ul><p><strong>Checks:</strong> async/await, useEffect, cleanup</p><h3>🧩 Challenge 4: Optimized List Rendering</h3><p><strong>Task:</strong> Render 1000 items efficiently.</p><p><strong>Expected:</strong></p><ul><li>Use <strong>FlashList</strong> or optimized FlatList props</li><li>Use React.memo</li><li>Avoid inline functions</li></ul><h3>🧩 Challenge 5: Custom Hook</h3><p><strong>Task:</strong> Write useNetworkStatus hook.</p><p><strong>Checks:</strong></p><ul><li>Custom hooks knowledge</li><li>Event listeners cleanup</li></ul><h3>🧩 Challenge 6: Form Validation</h3><p><strong>Task:</strong> Build login form with validation.</p><p><strong>Checks:</strong> Controlled inputs, error states, regex validation.</p><h3>🧩 Challenge 7: Dark Mode Toggle</h3><p><strong>Task:</strong> Implement light/dark theme switch.</p><p><strong>Checks:</strong> Context API, re-render optimization.</p><h3>🧩 Challenge 8: Debounced Search</h3><p><strong>Task:</strong> Search API only after user stops typing.</p><p><strong>Checks:</strong> setTimeout + cleanup or lodash debounce.</p><h3>🧩 Challenge 9: Navigation Flow</h3><p><strong>Task:</strong> Two screens: List → Details, pass params.</p><p><strong>Checks:</strong> React Navigation basics.</p><h3>🧩 Challenge 10: Animation Task</h3><p><strong>Task:</strong> Animate a box moving across screen.</p><p><strong>Expected (modern answer):</strong> Use <strong>Reanimated</strong>, not old Animated API.</p><h3>🏗️ Part 3: System Design for a React Native App</h3><p>Now we move to <strong>senior-level questions</strong>.</p><h3>🎯 Question:</h3><p><strong>“Design a scalable React Native app like Instagram / E-commerce / Food Delivery.”</strong></p><h3>🧱 1. App Architecture</h3><p><strong>Expected Answer:</strong></p><pre>Presentation Layer → UI Components<br>Business Logic Layer → Hooks / Services<br>Data Layer → API + Local Storage</pre><p>Use:</p><ul><li>Feature-based folder structure</li><li>Separation of concerns</li></ul><h3>🗂 2. Folder Structure</h3><pre>src/<br> ├── components/<br> ├── screens/<br> ├── navigation/<br> ├── services/<br> ├── hooks/<br> ├── store/<br> ├── utils/<br> └── assets/</pre><h3>🔄 3. State Management</h3><p>Interviewer expects reasoning:</p><pre>| App Size | Solution                |<br>| -------- | ----------------------- |<br>| Small    | Context API             |<br>| Medium   | Redux Toolkit / Zustand |<br>| Large    | Redux + RTK Query       |</pre><p>Explain:</p><ul><li>Global vs local state separation</li><li>Server cache vs UI state</li></ul><h3>🌐 4. Networking Layer</h3><p>Best practice:</p><ul><li>Axios or Fetch wrapper</li><li>Interceptors for auth tokens</li><li>Centralized error handling</li><li>Retry logic for failures</li></ul><h3>💾 5. Offline Support</h3><p>Senior-level bonus:</p><ul><li>Use <strong>MMKV / AsyncStorage</strong></li><li>Cache API responses</li><li>Background sync when internet returns</li></ul><h3>🚀 6. Performance Strategy</h3><p>Mention:</p><ul><li>FlashList for long lists</li><li>Hermes enabled</li><li>Lazy load screens</li><li>Image optimization</li><li>Avoid unnecessary re-renders</li><li>Fabric-compatible libraries</li></ul><h3>🔐 7. Security Design</h3><ul><li>Secure token storage (Keychain/Keystore)</li><li>Certificate pinning</li><li>Code obfuscation</li><li>Biometric login (if needed)</li></ul><h3>🔔 8. Push Notifications</h3><p>Design flow:</p><p>App → Firebase/APNs → Backend → Device</p><p>Handle:</p><ul><li>Foreground vs background</li><li>Deep linking from notifications</li></ul><h3>📦 9. CI/CD Pipeline</h3><p>Modern RN apps use:</p><ul><li>GitHub Actions / Bitrise</li><li>Fastlane for builds</li><li>OTA updates (CodePush / Expo Updates)</li></ul><h3>🧪 10. Testing Strategy</h3><pre>| Type      | Tool               |<br>| --------- | ------------------ |<br>| Unit      | Jest               |<br>| Component | RN Testing Library |<br>| E2E       | Detox / Maestro    |</pre><h3>🎯 Final Pro Tip for Interviews</h3><p>When answering system design:</p><p>✅ Talk about <strong>scalability</strong><br> ✅ Mention <strong>performance</strong><br> ✅ Cover <strong>security</strong><br> ✅ Include <strong>offline support</strong><br> ✅ Explain <strong>trade-offs</strong></p><p>That combination screams <strong>“hire this developer”</strong> 😄</p><p>Keep Learning and Keep Sharing 😄</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=801f4f2bbe1b" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/react-native-2026-edition-interview-questions-801f4f2bbe1b">React Native 2026 Edition Interview Questions</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[16KB Page Size Alignment in React Native: What It Is & How to Fix It]]></title>
            <link>https://blog.stackademic.com/16kb-page-size-alignment-in-react-native-what-it-is-how-to-fix-it-ab3a8bb56d29?source=rss-1012a21dc6fa------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab3a8bb56d29</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[google]]></category>
            <dc:creator><![CDATA[Hrusikesh Swain]]></dc:creator>
            <pubDate>Fri, 09 Jan 2026 20:52:12 GMT</pubDate>
            <atom:updated>2026-01-12T07:09:39.236Z</atom:updated>
            <content:encoded><![CDATA[<p>Modern Android devices (Android 14/15+ with 16KB page sizes) require native libraries (.so files) in your APK to be <strong>properly 16KB aligned</strong>. If not, apps may crash, fail to install, or get rejected by Google Play.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EILLJW0TwAHzWoH2adPd_g.png" /></figure><h3>🧠 Why It matters?</h3><ul><li>Android 15+ Requirement: Devices with 16KB page sizes require proper alignment</li><li>Performance: Properly aligned libraries load faster and use memory more efficiently</li><li>Google Play Store: Apps with misaligned libraries may be rejected</li><li>Crash Prevention: Misaligned libraries can cause runtime crashes</li></ul><h3>Checking Alignment</h3><h3>Using the Analysis Script</h3><p>We have a script to check alignment in your APK:</p><pre>./scripts/analyze_apk.sh android/app/build/outputs/apk/release/app-release.apk</pre><p>This will show:</p><ul><li>Library name</li><li>React Native package name (if applicable)</li><li>16KB alignment status (YES/NO)</li></ul><pre>https://github.com/hrusikeshswain/16kbMarkDownScript/blob/main/analyze_apk.sh</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YyfkGzxYxsL3kVGU8iIDeQ.jpeg" /></figure><h3>Using Android Studio</h3><ol><li>Open Android Studio</li><li>Build &gt; Analyze APK</li><li>Select your APK file</li><li>Navigate to lib/ folder</li><li>Check alignment status for each .so file</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GT0lT7VWxunpRyXBdCT3bg.png" /></figure><h3>Fixing Alignment Issues</h3><h3>Method 1: Use zipalign (Recommended)</h3><pre># Align your APK<br>zipalign -v -p 4 unaligned.apk aligned.apk</pre><pre># Verify alignment<br>zipalign -c -v 4 aligned.apk</pre><pre># Sign the aligned APK (if needed)<br>apksigner sign --ks your-keystore.jks aligned.apk</pre><h3>Method 2: Configure Gradle Build</h3><p>Ensure your android/app/build.gradle.kts or build.gradle includes proper alignment:</p><pre>android {<br>    // ... other config<br>    <br>    buildTypes {<br>        release {<br>            // Ensure zipalign is enabled<br>            isMinifyEnabled = true<br>            // ... other config<br>        }<br>    }<br>}</pre><p>The Android Gradle Plugin automatically aligns APKs during the build process for release builds.</p><h3>Method 3: Update React Native</h3><p>Newer versions of React Native handle alignment automatically. Update to ensure proper alignment:</p><pre># Check your React Native version<br>npm list react-native</pre><pre># Update React Native<br>npm install react-native@latest<br># or<br>yarn add react-native@latest</pre><h3>Minimum React Native Version Compatibility</h3><h3>React Native 0.77.0+ (Current)</h3><ul><li>✅ Automatic 16KB alignment in release builds</li><li>✅ Proper zipalign configuration in Gradle</li><li>✅ Compatible with Android Gradle Plugin 8.0+</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xSv7dwt0IBd_fAnQwKxUGA.png" /></figure><h3>Ensuring Alignment in Your Build</h3><h3>1. Update Android Gradle Plugin</h3><p>In android/build.gradle.kts:</p><pre>buildscript {<br>    ext {<br>        buildToolsVersion = &quot;34.0.0&quot;  // Use latest<br>        minSdkVersion = 21<br>        compileSdkVersion = 34<br>        targetSdkVersion = 34<br>    }<br>    <br>    dependencies {<br>        classpath(&quot;com.android.tools.build:gradle:8.1.0&quot;)  // Use 8.0+<br>    }<br>}</pre><h3>2. Configure Build Types</h3><p>In android/app/build.gradle.kts:</p><pre>android {<br>    buildTypes {<br>        release {<br>            // These ensure proper alignment<br>            isMinifyEnabled = true<br>            isShrinkResources = true<br>            proguardFiles(<br>                getDefaultProguardFile(&quot;proguard-android-optimize.txt&quot;),<br>                &quot;proguard-rules.pro&quot;<br>            )<br>        }<br>    }<br>    <br>    // Ensure proper signing<br>    signingConfigs {<br>        release {<br>            // Your signing config<br>        }<br>    }<br>}</pre><h3>3. Post-Build Verification Script</h3><p>Add to package.json:</p><pre>{<br>  &quot;scripts&quot;: {<br>    &quot;android:build:release&quot;: &quot;cd android &amp;&amp; ./gradlew assembleRelease&quot;,<br>    &quot;android:verify:alignment&quot;: &quot;./scripts/analyze_apk.sh android/app/build/outputs/apk/release/app-release.apk&quot;,<br>    &quot;android:align:apk&quot;: &quot;zipalign -v -p 4 android/app/build/outputs/apk/release/app-release.apk android/app/build/outputs/apk/release/app-release-aligned.apk&quot;<br>  }<br>}</pre><h3>🔧 Common 16KB Alignment Issues &amp; Fixes</h3><h3>1. All libraries show misaligned</h3><ul><li>Use <strong>Android Gradle Plugin 8.0+</strong>.</li></ul><p>Rebuild clean:</p><ul><li>./gradlew clean assembleRelease</li></ul><h3>2. Some React Native libraries misaligned</h3><ul><li>Update React Native to the latest version.</li><li>Update dependencies (npm update / yarn upgrade).</li><li>Clear build cache:</li><li>cd android &amp;&amp; ./gradlew clean</li></ul><h3>3. Third-party native libraries misaligned</h3><ul><li>Check for library updates and patch packages.</li><li>Report issues to the maintainer.</li><li>Use post-build zipalign as a temporary workaround.</li></ul><h3>📦 RReact Native Library Alignment Status</h3><ul><li><strong>react-native-screens</strong> → ✔ 3.27.0+</li><li><strong>react-native-reanimated</strong> → ✔ 3.6.0+</li><li><strong>react-native-webview</strong> → ✔ OK</li><li><strong>hermes-engine</strong> → ✔ Auto-aligned</li><li><strong>react-native-pdf</strong> → ⚠ Verify after updates</li></ul><h3>⭐ Best Practices</h3><ul><li><strong>Always check alignment before release</strong></li><li>./scripts/analyze_apk.sh your-release.apk</li><li><strong>Use release builds</strong> for alignment tests.</li><li><strong>Keep dependencies updated</strong>.</li><li><strong>Automate alignment checks</strong> in CI/CD.</li><li><strong>Track library alignment status</strong> in documentation.</li></ul><h3>🤖 CI/CD Example (GitHub Actions)</h3><pre>- name: Check APK Alignment<br>  run: |<br>    ./scripts/analyze_apk.sh android/app/build/outputs/apk/release/app-release.apk<br>    if ./scripts/analyze_apk.sh android/app/build/outputs/apk/release/app-release.apk | grep -q &quot;NO&quot;; then<br>      echo &quot;❌ Misaligned libraries found!&quot;<br>      exit 1<br>    fi</pre><h3>🛠 Troubleshooting</h3><p><strong>Everything misaligned?</strong><br> → Probably debug APK. Rebuild release.</p><p><strong>zipalign missing?</strong><br> → Install Build-Tools 34.0.0.</p><p><strong>CI fails but local works?</strong><br> → Make sure CI installs the Android SDK + build-tools.</p><p>Github link</p><p><a href="https://github.com/hrusikeshswain/16kbMarkDownScript">https://github.com/hrusikeshswain/16kbMarkDownScript</a></p><p>Keep Learning and Keep Shring :)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab3a8bb56d29" width="1" height="1" alt=""><hr><p><a href="https://blog.stackademic.com/16kb-page-size-alignment-in-react-native-what-it-is-how-to-fix-it-ab3a8bb56d29">16KB Page Size Alignment in React Native: What It Is &amp; How to Fix It</a> was originally published in <a href="https://blog.stackademic.com/">Stackademic</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>