<?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 Nikos Aggelidis on Medium]]></title>
        <description><![CDATA[Stories by Nikos Aggelidis on Medium]]></description>
        <link>https://medium.com/@naggelidis?source=rss-801582defdbf------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*k78T5vZklV_2SCmtSTPqag.jpeg</url>
            <title>Stories by Nikos Aggelidis on Medium</title>
            <link>https://medium.com/@naggelidis?source=rss-801582defdbf------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 11:40:20 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@naggelidis/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[Kotlin Multiplatform: Making One Feature Work Well on Two Platforms]]></title>
            <link>https://naggelidis.medium.com/kotlin-multiplatform-making-one-feature-work-well-on-two-platforms-d8b1ac5bec20?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8b1ac5bec20</guid>
            <category><![CDATA[kotlin-multiplatform]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 15:51:01 GMT</pubDate>
            <atom:updated>2026-11-16T15:51:01.536Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1GOQo_psOWDaalCbXYL3vw.png" /></figure><p>An Android app and an iOS app can show different screens while needing to make exactly the same decision. A search result should follow the same filtering rules. A saved item should be considered outdated under the same conditions. A calculation should produce the same answer. Kotlin Multiplatform, or KMP, lets developers implement those shared behaviors in Kotlin and use them across platforms. The useful starting point is choosing a feature whose behavior should stay consistent, then checking whether sharing it makes that feature easier to maintain.</p><h3>What KMP Shares and What Remains Separate</h3><p>KMP does not require replacing an existing interface. An app can keep SwiftUI on iOS and Jetpack Compose on Android while using a shared Kotlin module, a separately organized piece of code that both applications depend on. Kotlin’s <a href="https://kotlinlang.org/docs/multiplatform/multiplatform-create-first-app.html">introductory documentation</a> explains this arrangement: the shared code is compiled for Android through Kotlin/JVM and for iOS through Kotlin/Native, which produces native code. The iOS application can consume that code through a framework. These remain separate applications with their own builds and platform integrations.</p><p>Sharing the interface is another available choice. <a href="https://kotlinlang.org/docs/multiplatform/compose-multiplatform-and-jetpack-compose.html">Compose Multiplatform</a> extends Jetpack Compose to additional platforms, including iOS. It can be used alongside KMP to share UI code, but adopting shared logic does not commit a project to shared screens. The earlier article <a href="https://naggelidis.medium.com/swiftui-vs-jetpack-compose-two-declarative-frameworks-two-platform-philosophies-7ffd177f43c7">SwiftUI vs Jetpack Compose: Two Declarative Frameworks, Two Platform Philosophies</a> explores the UI side in more detail. Here, the focus is what happens underneath those screens when both applications depend on the same implementation.</p><h3>Start With One Feature and Clear Rules</h3><p>Consider an illustrative product search feature. Both applications let someone enter a query, display matching products, and open a result. Suppose the agreed behavior is to remove surrounding spaces, reject an empty query, and show previously loaded results if refreshing fails. The screens may arrange controls differently, but the query rules and decisions about saved results should agree. This gives the shared module a specific purpose. It owns the behavior that would otherwise need two implementations and two sets of updates whenever the requirements change.</p><p>Before moving code, make that behavior precise. “Show saved results” leaves several questions unanswered. Results for which query? How old can they be? Should the screen explain that refreshing failed? For this example, a clearer rule might be to retain the last successful result for the same normalized query and mark it as outdated when a refresh fails. That is an illustrative product decision, not a KMP default. Sharing code makes an agreed rule reusable, but it cannot resolve an ambiguous requirement.</p><h3>Where Shared and Platform Code Belong</h3><p>The project structure helps enforce where that rule belongs. KMP uses source sets, groups of source files with their own dependencies and target platforms. Shared Kotlin typically lives in commonMain, while androidMain and iosMain contain platform-specific implementations. Common code must use APIs available to its configured targets, so an Android dependency cannot simply be moved into the shared directory and expected to work on iOS. Kotlin’s <a href="https://kotlinlang.org/docs/multiplatform/multiplatform-share-on-platforms.html">code-sharing documentation</a> explains how these relationships work. For the search feature, query normalization belongs naturally in common code because it does not need either operating system.</p><p>Fetching results introduces dependencies beyond simple Kotlin functions. Ktor, for example, provides a multiplatform HTTP client, with an engine handling the actual network requests for each supported target. Its <a href="https://ktor.io/docs/client-engines.html">engine documentation</a>describes the available choices and their differences. This allows request handling to be shared while the underlying network implementation varies. It also means dependency selection deserves an early check. A library that works in an Android project may not support every target needed by a shared module.</p><p>Platform-specific functionality can be supplied through a small interface, an agreement describing the operations shared code needs. For example, search logic could receive a storage component that can read and save results without knowing how the storage works internally. KMP also provides expect and actual declarations: common code declares an expected operation, and platform code supplies its implementation. The compiler connects them for the selected target, as described in the <a href="https://kotlinlang.org/docs/multiplatform/multiplatform-expect-actual.html">official documentation</a>. Choose the mechanism that keeps the dependency understandable. A platform abstraction is useful when it expresses a real need, but wrapping every function adds work without necessarily improving the design.</p><h3>Make the Shared API Usable From Swift</h3><p>For a module consumed by Swift, the next important step is to inspect its API, the functions and types exposed to callers. A Kotlin implementation can look clear internally while being awkward to use from iOS. Build a small Swift caller early and examine how it receives results, handles missing values, and distinguishes failures. Kotlin’s <a href="https://kotlinlang.org/docs/native-objc-interop.html">Swift and Objective-C interoperability documentation</a> describes the framework-based route through Objective-C, including ways to refine the exported interface. Keeping internal helpers out of the public API reduces the number of details both applications must understand.</p><p>This area is evolving, so older explanations need care. As of November 2026, the official <a href="https://kotlinlang.org/docs/native-swift-export.html">Swift export documentation</a>describes direct Swift export as Alpha, with breaking changes expected. It documents support for exporting suspending Kotlin functions as Swift asynchronous functions and Kotlin flows as AsyncSequence. Suspending functions can pause while waiting for work, while flows represent values arriving over time. Those capabilities are useful, but the documented integration restrictions and type limitations still matter. Evaluate the export route supported by the project rather than assuming every Kotlin API will appear identically in Swift.</p><h3>Define Request Ordering and Failure Behavior</h3><p>The search example makes asynchronous behavior concrete. Someone types “ca,” then quickly changes it to “camera.” If the first request finishes last, its results must not replace the newer ones. A reasonable design cancels obsolete work where possible and checks that an arriving response still belongs to the active query before displaying it. The module’s contract should also explain what happens when the caller stops observing results. These are behaviors to implement and test explicitly. Successful compilation across the language boundary does not demonstrate that request ordering or cancellation works as intended.</p><p>Expected failures deserve the same attention. “No matching products” is a successful empty result, while “could not refresh” means the request failed. Combining both into an empty list removes information the interface needs. For this feature, the shared layer could return products together with freshness information and a defined failure category. Each application could then choose appropriate wording and presentation. That keeps the meaning consistent while leaving room for platform-specific interaction. A useful API gives callers enough information to respond without requiring them to interpret networking internals.</p><h3>Shared Storage Code Does Not Mean Shared Data</h3><p>Shared storage also needs careful terminology. Reusing database code does not make the Android and iOS applications use one physical database. Each installation has its own local data unless a separate synchronization mechanism connects it to a service. In the illustrative search feature, both applications might follow the same caching rules while holding different saved results because their users performed different searches. KMP can share the implementation of those rules. Decisions about synchronization, stale data, and conflicting updates remain part of the product design.</p><h3>Test Shared Behavior and Both Integrations</h3><p>Testing should follow the feature across both platforms. KMP supports common tests in commonTest, and Kotlin’s <a href="https://kotlinlang.org/docs/multiplatform/multiplatform-run-tests.html">testing tutorial</a> distinguishes these from platform-specific tests. Query normalization and result-selection rules can be tested with shared inputs and expected outputs. Configure the relevant target test tasks explicitly rather than treating an Android test run as evidence about iOS execution. Then test the Swift-facing API and each application’s integration. Shared tests protect reusable behavior, while integration tests check that the applications actually consume it correctly.</p><p>For the search feature, the most informative tests include responses arriving out of order, refresh failure with saved results, refresh failure without saved results, and leaving the screen during a request. These cases reveal more than a successful network call alone. They also expose a trade-off in sharing: a corrected rule can benefit both applications, but an incorrect rule can affect both as they adopt the change. Review and testing should reflect that wider responsibility.</p><h3>Include Builds and Delivery in the Evaluation</h3><p>The build process is part of the evaluation. Kotlin, Gradle, the Android Gradle plugin, and Xcode have compatibility requirements, documented in Kotlin’s <a href="https://kotlinlang.org/docs/multiplatform/multiplatform-compatibility-guide.html">compatibility guide</a>. Before expanding a shared module, verify that both applications build and test in the automated pipeline used to deliver them. Also decide how they receive updates to the module and who investigates a failure spanning Kotlin and Swift. A working demonstration on one developer’s machine leaves those practical costs unanswered.</p><p>A useful pilot therefore includes one complete feature path. Connect a screen to the shared behavior, exercise failure cases, run it on both platforms, and make a small requirement change afterward. Observe the work involved in implementing that change, reviewing it, diagnosing failures, and delivering it. Measure build time, application size, or runtime behavior when those affect the product. These observations provide a more useful basis for adoption than the percentage of code moved into a shared directory.</p><h3>Decide Whether Sharing Earns Its Place</h3><p>KMP is a stronger candidate when both applications repeatedly need the same rules and developers on both sides can maintain the shared implementation. Its value may be smaller when the applications serve substantially different needs or when most work involves distinct platform integrations. Keeping native interfaces also means continuing to maintain two UI implementations. Sharing more code can be worthwhile, but each additional responsibility should earn its place through clearer behavior or reduced maintenance effort.</p><p>The first milestone can be modest: one feature with an understandable Kotlin implementation, a usable Swift interface, explicit failure behavior, and tests running on both targets. That is enough to reveal whether the approach fits the application and the people maintaining it. Expand from there when the evidence supports it. A shared module becomes valuable when changing a product rule becomes easier to implement and verify across both applications.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8b1ac5bec20" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Start Coding in 2026: A Practical Guide for Complete Beginners]]></title>
            <link>https://naggelidis.medium.com/how-to-start-coding-in-2026-a-practical-guide-for-complete-beginners-cd8f4d4d9b6f?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/cd8f4d4d9b6f</guid>
            <category><![CDATA[fundamentals]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 19 Oct 2026 16:14:38 GMT</pubDate>
            <atom:updated>2026-10-19T16:14:38.110Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ccBKBMFWCM_RbXgW1KVpmQ.png" /></figure><h3><em>From understanding how software works to writing your first program and using AI coding tools without depending on them.</em></h3><h3>Where Do You Actually Start?</h3><p>Learning to code in 2026 is easier to access than ever, but deciding where to start can still be difficult. There are hundreds of tutorials, programming languages, development tools, and AI assistants that promise to help people build software. Someone with no technical background can now describe an application in plain English and receive working code within seconds. That is useful, but it creates an important question: if a tool can write the code, what exactly should someone learn? The answer starts with understanding how software works, not just knowing which buttons to press or which instructions to give an AI assistant. This guide explains the fundamentals, introduces the tools available today, and walks through writing a real program. The goal isn’t simply to get something running. It’s to understand why it works, recognize when something is wrong, and gradually become capable of building and improving software independently.</p><h3>What Is Programming, Really?</h3><p>Programming is the process of creating instructions that a computer can execute. Consider a calculator. It receives two numbers, performs a requested operation, and displays a result. The computer doesn’t independently decide what the calculation should mean. Someone has defined the instructions that determine how it behaves. Programming is about expressing those instructions using a programming language, while software development includes the broader process of understanding problems, designing solutions, testing their behavior, and maintaining them over time.</p><p>A useful way to understand nearly every program is through three concepts: input, processing, and output. An expense tracker receives amounts entered by a user, calculates a total, and displays the remaining budget. A weather application receives location information, obtains forecast data, and displays the weather. An online store receives product selections, calculates an order, and processes a purchase. These applications are very different in complexity, but the underlying idea is similar. Information enters a system, rules are applied to it, and a result is produced.</p><h3>What Actually Happens When Code Runs?</h3><p>A computer ultimately executes machine instructions understood by its processor. Programming languages allow people to describe operations at a higher level without manually writing those machine instructions. Different languages use different methods to translate or execute code. Python, for example, commonly runs through an interpreter that processes Python programs using its own execution system. A developer writes instructions in a file, the runtime executes them, and the program interacts with memory, files, and other resources as needed.</p><p>Memory temporarily holds information that a running program needs, such as a name entered by a user or the total of several numbers. Files and databases can store information so that it remains available after a program stops. The operating system manages many of the resources programs use, including memory, storage, and access to hardware. None of this requires advanced computer science knowledge at the beginning, but understanding the difference between code, execution, memory, and permanent storage helps explain why programs behave as they do.</p><h3>Learn to Think in Instructions Before Writing Code</h3><p>One of the most useful programming skills is breaking a problem into smaller, logical steps. Imagine building a simple application that determines whether someone has exceeded a weekly budget. Before choosing a language, the problem can be described in ordinary words. First, define the available budget. Then receive the expenses, calculate their total, subtract it from the budget, and display the remaining amount. If the result is negative, display a warning. These steps form an algorithm, which is simply a sequence of instructions for solving a problem.</p><p>This way of thinking matters because programming languages change, while the logic behind a solution is often transferable. Someone who understands how to calculate a total, compare values, and decide what happens next can express those operations in Python, JavaScript, Swift, Kotlin, or another language. Someone who only memorizes code may struggle when asked to solve a slightly different problem. Before writing any program, it helps to ask what information is needed, what rules should be applied, what result is expected, and what could go wrong. These questions are basic software design, even when the project contains only a few lines.</p><h3>The Fundamentals Every Beginner Should Understand</h3><p>Most programs rely on a relatively small set of concepts. Variables allow information to be referenced by name, such as a product price or the number of items in a shopping cart. Data types describe the kind of information being handled, including text, numbers, and true-or-false values. Conditions allow software to make decisions based on rules. Loops repeat instructions when an operation needs to happen more than once. Functions group related instructions so they can be reused and understood separately. Data structures, such as lists and dictionaries, organize information in ways that make it easier to access and process.</p><p>These ideas become more useful when connected to a real problem. A shopping cart needs variables for prices, a list of products, a loop to calculate the total, and conditions to decide whether a discount applies. A function could calculate the final price. The same concepts appear in much larger systems, even though those systems may contain thousands of files and additional layers of complexity. The purpose of learning fundamentals is not to memorize definitions. It is to understand which concept solves which problem, why it is needed, and what happens when it is used incorrectly.</p><h3>Understanding the Difference Between Syntax and Logic</h3><p>Syntax refers to the rules for writing instructions in a programming language. Just as written languages have grammar, programming languages require particular characters, keywords, and structures. Logic describes what those instructions are intended to accomplish. A program can have correct syntax and still produce an incorrect result. For example, a budget calculator might subtract the budget from expenses instead of subtracting expenses from the budget. The computer may execute the instructions successfully, but the calculation is wrong.</p><p>This distinction is particularly important when learning with AI. An assistant can generate syntactically valid code that doesn’t match the actual requirements. Understanding what the program should do makes it possible to recognize the difference. A useful habit is to describe the expected behavior before running the code and then compare the actual result with that expectation. This is the beginning of reasoning about software rather than simply following instructions.</p><h3>Choosing Your First Programming Language</h3><p>There is no universally correct first programming language. JavaScript is useful for interactive websites, Python is common in automation, backend development, and data processing, Swift is used for native Apple applications, and Kotlin is widely used for Android development. HTML describes webpage content, while CSS controls how that content is presented. Although HTML and CSS are essential web technologies, they don’t serve the same purpose as general-purpose programming languages.</p><p>For someone without a particular specialization in mind, Python is a practical starting choice because simple programs can be written with readable syntax and relatively little setup. It also has extensive documentation and learning resources. That doesn’t mean everyone should start with Python. Someone whose clear objective is creating interactive websites could reasonably begin with HTML, CSS, and JavaScript. The important decision is to choose a direction and spend enough time with one language to understand its fundamentals before trying to learn several others.</p><h3>Writing Your First Program Without Installing Anything</h3><p>A beginner doesn’t need to install a complicated development environment to start programming. <a href="https://colab.research.google.com/">Google Colab</a> allows Python code to run inside a web browser using notebooks. It provides free access with usage limits, and a Google account is normally needed to save and work with notebooks. Open Colab, create a new notebook, and locate the first code cell. A code cell is an editable area where Python instructions can be entered and executed. Enter the following code and click the Run button or press Shift + Enter.</p><pre>print(&quot;Hello, world!&quot;)</pre><pre>name = input(&quot;What is your name? &quot;)</pre><pre>print(f&quot;Nice to meet you, {name}!&quot;)</pre><p>The first instruction displays a message using print(). The second asks the user to enter a name using input() and stores the response in a variable called name. The final instruction combines text with that variable to create a personalized message. The f before the quotation marks allows a value to be inserted directly into text. If someone enters Alex, the result includes Nice to meet you, Alex!. The program demonstrates input, processing, output, variables, and sequential execution. The computer follows the instructions in order and uses the information entered by the user to determine the final result.</p><p>Before moving forward, change the greeting, rename the variable consistently, and run the program again. Try removing a quotation mark or changing the capitalization of print. The program may stop with an error, and that is useful information. The aim is to see how individual instructions affect execution, rather than treating the example as something that should only be copied.</p><h3>Why Variables, Conditions, and Loops Matter</h3><p>Consider the difference between a program that always displays the same message and one that changes its behavior based on user input. The second needs a way to store information and make decisions. A variable provides a name for a value, while a condition allows the program to check whether something is true. The following example uses a person’s age to determine which message appears.</p><pre>age = 20</pre><pre>if age &gt;= 18:<br>    print(&quot;Adult&quot;)<br>else:<br>    print(&quot;Under 18&quot;)</pre><p>The comparison age &gt;= 18 checks whether the age is greater than or equal to 18. If the condition is true, the first message appears. Otherwise, the second message appears. The spaces at the beginning of the print() lines are significant because Python uses indentation to identify instructions that belong together. A loop works differently: rather than choosing between alternative instructions, it repeats an operation. These concepts are called control flow because they determine which instructions execute and when.</p><p>The important part isn’t the exact Python syntax. It is understanding why a program needs to store a value, compare it with another value, and take an action based on the result. Once these relationships are clear, learning another programming language becomes less about discovering completely new ideas and more about learning different ways of expressing familiar ones.</p><h3>Building Your First Useful Application</h3><p>A small expense tracker is a good first project because its behavior is familiar and doesn’t require a graphical interface, server, or database. The application will start with a weekly budget, accept several expenses, calculate their total, and display whether the user remains within the available amount. It also needs to handle basic mistakes, such as someone entering letters instead of a number. Create another code cell in Google Colab and enter the following program.</p><pre>budget = 50.0<br>spent = 0.0</pre><pre>while True:<br>    answer = input(&quot;Enter an expense or &#39;done&#39;: &quot;).strip()</pre><pre>    if answer.lower() == &quot;done&quot;:<br>        break</pre><pre>    try:<br>        amount = float(answer)<br>    except ValueError:<br>        print(&quot;Please enter a valid number.&quot;)<br>        continue</pre><pre>    if amount &lt; 0:<br>        print(&quot;Expenses cannot be negative.&quot;)<br>        continue</pre><pre>    spent += amount</pre><pre>remaining = budget - spent</pre><pre>print(f&quot;Total spent: {spent:.2f}&quot;)<br>print(f&quot;Remaining: {remaining:.2f}&quot;)</pre><pre>if remaining &lt; 0:<br>    print(&quot;You are over budget.&quot;)<br>else:<br>    print(&quot;You are within budget.&quot;)</pre><p>Start by entering 12.50, then 8, and finally done. The program will calculate a total of 20.50 and a remaining budget of 29.50. It works because spent begins at zero and increases every time a valid amount is entered. The while loop continues receiving information until the user types done. The float() function converts entered text into a number, while the try and except statements handle invalid conversions. The final condition checks whether the remaining budget is below zero and selects the appropriate message.</p><p>What matters most is understanding why those instructions exist. Without a loop, the program would need a fixed number of expense entries. Without a condition, it couldn’t decide when the user wanted to finish. Without storing the accumulated amount, it couldn’t calculate the total. Without input validation, invalid text could stop the program. Each concept solves a specific problem. The program is deliberately simple: it doesn’t save expenses permanently or provide a visual interface, and ordinary floating-point numbers aren’t the preferred way to represent money in production financial applications. Reliable financial calculations typically use decimal arithmetic or integer values representing the smallest currency unit. These are examples of additional requirements that become important as software moves beyond a learning exercise.</p><h3>Understanding the Design Behind the Implementation</h3><p>Getting the expense tracker to run is only the beginning. The next question is whether the solution makes sense. For example, should the budget be fixed or entered by the user? Should expenses be stored individually or only added together? Should the application allow corrections? What happens if the user closes it? These questions concern behavior and design rather than programming syntax. A different set of requirements could lead to a different implementation, even if the programming language remains unchanged.</p><p>Try extending the program by allowing the user to enter a budget at the beginning. Then consider storing individual expenses in a list so they can be displayed later. Break the calculations into a function once the code becomes harder to read. Before adding each feature, describe what should happen and which existing instructions need to change. This develops a skill that remains important at every level of software engineering: choosing a solution based on requirements instead of adding complexity simply because it is possible.</p><h3>How to Recognize and Fix Errors</h3><p>Not every error means the same thing. A syntax error means the language rules have been violated. A runtime error occurs while the program is executing, such as trying to convert invalid text into a number without handling the failure. A logic error occurs when the program executes but produces the wrong result. These categories require different approaches. Syntax and runtime errors often produce messages identifying the problem, while logic errors need to be discovered by comparing actual behavior with expected behavior.</p><p>Debugging is the process of investigating why something isn’t working. The simplest approach is to reproduce the problem, identify which instruction is involved, inspect the values being used, and make one change at a time. Printing intermediate values can help reveal where a calculation becomes incorrect. More advanced development environments include debuggers that pause execution and allow variables to be inspected. Learning to debug is more valuable than memorizing solutions because it provides a way to investigate problems that haven’t been encountered before.</p><h3>Testing Is Part of Understanding the Code</h3><p>A program that runs successfully once hasn’t necessarily been implemented correctly. Testing means checking what happens under different conditions and confirming that the behavior matches the requirements. For the expense tracker, entering values totaling less than 50 should produce a positive remaining amount. Entering exactly 50 should produce zero, while entering more than 50 should produce a negative remaining amount and the appropriate warning. Invalid input should be handled without unexpectedly terminating the application. These examples cover normal behavior, boundary conditions, and incorrect input.</p><p>As programs grow, tests can be automated so that the same checks run whenever the code changes. Testing also forces developers to clarify what software is supposed to do. If two people disagree about the expected result, the problem might be an unclear requirement rather than an incorrect implementation. A useful rule for beginners is to decide what should happen before asking whether the code works.</p><h3>Moving to a Proper Development Environment</h3><p>Once basic programming concepts become familiar, the next step is to write code in files stored on a computer. <a href="https://code.visualstudio.com/">Visual Studio Code</a> is a free code editor available for major desktop operating systems. Python can be installed through <a href="https://www.python.org/downloads/">python.org</a>, while Microsoft’s Python extension adds features such as code completion, debugging, and language support. The editor is where code is written, while the Python interpreter is the software that executes it. These are separate components, and installing an editor alone doesn’t necessarily install Python.</p><p>A Python file usually ends with .py, such as expenses.py. The program can be executed through the editor or a terminal using a command such as python expenses.py or python3 expenses.py, depending on the system and installation. The terminal is simply a text-based interface for interacting with the operating system. It may seem unfamiliar initially, but basic commands for navigating folders, running programs, and viewing output are enough to begin. Microsoft&#39;s <a href="https://code.visualstudio.com/docs/python/python-tutorial">Python tutorial for VS Code</a>explains the setup in more detail.</p><h3>Understanding How Real Applications Fit Together</h3><p>A working script is different from an application used by many people, but the underlying programming concepts remain relevant. A typical application may include a frontend, which handles what users see and interact with, and a backend, which processes requests and handles operations that shouldn’t depend entirely on the user’s device. A database stores organized information that needs to be retrieved or updated later. An API defines how different software components communicate, commonly through requests and responses sent across a network.</p><p>Consider an appointment-booking application. A user selects an available time through a website or mobile application. The backend checks whether the appointment is still available, saves the reservation in a database, and returns a confirmation. If several people request the same slot, the system must prevent conflicting bookings. This example introduces business rules, data storage, network communication, and the need to handle failures. It also shows why software development involves designing how components work together, not just creating screens.</p><h3>Understanding Libraries, Frameworks, and Dependencies</h3><p>As projects grow, developers rarely write every piece of functionality from scratch. Libraries provide existing code for common tasks, while frameworks offer a broader structure for building applications. These tools can reduce repetitive work, but they introduce dependencies: software components that a project relies on. A dependency can have its own updates, requirements, and potential security issues. Beginners should understand what a tool provides before adding it to a project.</p><p>For example, a basic calculator doesn’t require a large application framework. A website with several pages and interactive features may benefit from one, depending on its requirements. The choice should follow the problem, not the popularity of a particular technology. Understanding the underlying language and programming concepts makes it easier to evaluate whether an external tool is actually necessary.</p><h3>Git, GitHub, and Working With Changes</h3><p>Software evolves through changes, and those changes need to be tracked. <a href="https://git-scm.com/">Git</a> is a version-control system that records changes to files and allows earlier versions to be inspected or restored. <a href="https://github.com/">GitHub</a> is a platform where Git repositories can be hosted and shared. A repository contains a project’s files and version history. A commit records a set of changes, while a branch allows work to be developed separately before it is combined with other changes.</p><p>These tools become especially useful when working with other developers or AI coding agents. If a generated change introduces a problem, version control makes it easier to identify what changed. Beginners can start with creating a repository, saving a working version, making a small modification, and recording another commit. The <a href="https://docs.github.com/en/get-started/using-github/hello-world">GitHub Hello World guide</a> introduces these concepts without requiring previous experience.</p><h3>Understanding AI Assistants, Coding Copilots, and AI Agents</h3><p>AI tools are now part of many development workflows, but they don’t all work in the same way. A conversational AI assistant, such as ChatGPT, Claude, or Gemini, can explain concepts, generate examples, answer questions, and help investigate errors. A coding assistant integrated into an editor, such as GitHub Copilot, can suggest code while someone types and help explain or modify existing files. An AI coding agent goes further by using tools to inspect a project, edit files, execute commands, and sometimes run tests across multiple steps.</p><p>The key distinction is between generating an answer and taking actions. When someone asks a chatbot how to write a function, it can return an example for the person to inspect and use. When someone asks a coding agent to implement a feature, the agent may search the project, identify relevant files, modify them, and attempt to verify the result. Different products increasingly combine these capabilities, so the categories are not strict boundaries. Understanding what permissions a tool has and what actions it can perform is more important than the label used to describe it.</p><h3>Which AI Tool Should a Beginner Choose?</h3><p>For someone learning programming fundamentals, a conversational assistant is usually enough at first. ChatGPT, Claude, and Gemini can all be used to ask questions, request explanations, and practice concepts. The choice can depend on accessibility, interface preferences, usage limits, and how useful the explanations are for the individual learner. There is no need to subscribe to several services or repeatedly switch between models to begin learning. A suitable starting approach is to use one assistant alongside an actual programming environment and compare its explanations with the code’s behavior.</p><p>Once someone is comfortable writing code in an editor, GitHub Copilot can become useful for code suggestions and explanations directly inside the development environment. Cursor offers an editor with AI-assisted workflows, including modes for asking questions and carrying out code changes. Tools such as Claude Code and OpenAI Codex are designed for coding tasks that may involve reading project files, making edits, and executing commands. Google also offers Gemini Code Assist with agent capabilities in supported development environments. These are examples of available tools rather than a ranking of which is best. Their features, access requirements, supported environments, and prices can change, so the official documentation should be checked before choosing one.</p><p>For a beginner, the most practical choice depends on the task. Use a conversational assistant to understand a concept, an editor assistant when working through existing code, and an agent when a clearly defined task requires changes across a project. Full agent workflows are not necessary for writing a first Python program. Introducing them too early can make learning more confusing because the tool may solve problems before the learner understands how those problems arise.</p><h3>How to Use AI to Learn the Fundamentals</h3><p>The most useful AI questions focus on understanding rather than simply obtaining a finished solution. Instead of asking an assistant to build a calculator, ask it to explain what information a calculator needs, how the operations should be organized, and which programming concepts are involved. A practical prompt is: “I’m learning Python with no programming background. Explain how variables, conditions, and functions work using a calculator example. Then give me a small exercise without showing the answer.” Once the exercise is completed, the assistant can review the solution and explain possible improvements.</p><p>Another useful approach is to ask for reasoning behind an implementation: “Explain why this program uses a loop instead of repeating the same instructions. What would happen if the loop were removed?” This type of question helps connect syntax with software behavior. AI can also compare alternative approaches, but recommendations should be tested rather than accepted automatically. The objective is to become increasingly capable of making decisions without assistance, even while continuing to use AI for efficiency.</p><h3>Working With AI Coding Agents Without Losing Control</h3><p>When moving from chat-based assistance to coding agents, it becomes important to define tasks precisely. A vague instruction such as “improve this application” leaves considerable room for interpretation. A more useful request is: “Review the expense tracker and suggest how to separate calculations from user input. Explain the changes before modifying any files, keep the program’s behavior unchanged, and add tests for the calculations.” This identifies the objective, establishes boundaries, and asks for a way to verify the outcome.</p><p>Coding agents may have access to files, terminal commands, development tools, and external services depending on their configuration. A beginner should review proposed changes, understand what commands will run, and avoid granting unnecessary permissions. For unfamiliar tools, start with read-only or approval-based workflows where available, use Git to protect working versions, and check the differences between files before accepting changes. Sensitive information such as passwords, private keys, and customer data shouldn’t be exposed to an assistant without appropriate safeguards. An agent reporting that a task is complete is not proof that the implementation is correct. Its changes still need to be understood and tested.</p><h3>Why Understanding Fundamentals Still Matters With AI</h3><p>AI can generate a function faster than a beginner can write it, but the developer still needs to know whether that function solves the correct problem. Consider asking an agent to add discounts to an online store. The implementation might calculate a discount correctly for ordinary purchases but handle rounding incorrectly, apply promotions in the wrong order, or ignore a business rule. Recognizing these issues requires understanding data, calculations, conditions, expected behavior, and testing. The same principle applies to authentication, personal information, network failures, and many other areas where mistakes have real consequences.</p><p>Fundamentals provide the ability to question an implementation. Why was this data structure selected? Why does this function require that information? What happens if the network is unavailable? Why does the program need to store this value permanently? Could the same result be achieved with a simpler design? These are not questions reserved for experienced engineers. They are habits that can begin with a small program and develop as projects become more complex. AI can help write code, but understanding is what allows someone to evaluate it.</p><h3>A Practical 30-Day Starting Plan</h3><p>During the first week, focus on how programs execute instructions. Learn variables, data types, user input, output, and basic calculations. Write several small examples and modify each one without copying a complete solution. During the second week, introduce conditions, loops, functions, and lists. Use them to expand the expense tracker and handle different inputs. Before running code, describe what should happen and why. During the third week, install Python and VS Code, write programs as files, learn basic terminal commands, and practice debugging errors. Create a Git repository for a small project and record changes as the project develops.</p><p>During the fourth week, select one manageable project and finish it. A shopping-list manager, personal task organizer, simple quiz, or text-based appointment tracker is enough. Define what the program should do, identify the necessary information, write the logic, test different scenarios, and document how to run it. Use AI for explanations and feedback, but complete at least some exercises without generated solutions. There is no guarantee that everyone will reach the same level after 30 days. The target is to establish a repeatable learning process and demonstrate a basic understanding of programming through working code.</p><h3>Reliable Resources for Continuing</h3><p><a href="https://cs50.harvard.edu/python/">Harvard’s CS50 Introduction to Programming with Python</a> provides free course materials designed for learners with or without previous programming experience. It includes exercises on functions, conditions, loops, exceptions, testing, files, and other topics. <a href="https://www.freecodecamp.org/learn/">freeCodeCamp</a> offers interactive programming lessons, while <a href="https://developer.mozilla.org/en-US/docs/Learn_web_development">MDN Learn Web Development</a> provides structured material for people interested in websites and browser technologies. The <a href="https://www.python.org/about/gettingstarted/">Python Beginner’s Guide</a> is another useful starting reference. The official Python tutorial is valuable as knowledge develops, although it assumes some familiarity with programming concepts.</p><p>For AI development tools, the official resources for <a href="https://docs.github.com/en/copilot">GitHub Copilot</a>, <a href="https://cursor.com/docs">Cursor</a>, <a href="https://code.claude.com/docs">Claude Code</a>, <a href="https://developers.openai.com/codex">OpenAI Codex</a>, and <a href="https://cloud.google.com/products/gemini/code-assist">Gemini Code Assist</a> explain their supported workflows and requirements. Reading the documentation matters because capabilities and permissions can differ between products and change over time. A beginner doesn’t need every tool on this list. One programming course, one coding environment, and optionally one AI assistant provide enough resources to start.</p><h3>What Should You Learn After the Basics?</h3><p>The next direction depends on what someone wants to build. Web development typically involves HTML, CSS, JavaScript, and eventually server-side concepts. Mobile development involves platform tools and languages such as Swift for iOS or Kotlin for Android. Python can lead toward automation, backend development, and data analysis. Other areas include game development, cybersecurity, embedded systems, and machine learning, each with additional knowledge requirements. People interested in AI applications can also learn about APIs, data handling, model limitations, and how AI services are integrated into software.</p><p>Regardless of the direction, some topics remain important: writing understandable code, organizing responsibilities, testing behavior, handling errors, managing changes with Git, protecting sensitive information, and understanding how different parts of a system communicate. More advanced subjects such as algorithms, data structures, software architecture, performance, and security become increasingly relevant as projects grow. Learning should gradually move from following examples toward designing and completing projects independently.</p><h3>What Does It Mean to Know How to Code?</h3><p>Knowing how to code isn’t measured by the number of languages someone has tried, the number of tutorials completed, or how quickly an AI agent can generate an application. A more meaningful early measure is the ability to understand a problem, describe the logic needed to solve it, express that logic in code, and verify the result. Someone who can build a small expense tracker, explain its decisions, identify its limitations, and improve it has established a practical foundation. Larger applications require broader knowledge, but the underlying process remains familiar.</p><h3>Start With Understanding, Then Build</h3><p>The first step into programming doesn’t need to be complicated. Choose a language that fits your interests, learn how instructions and data work, write a small program, and gradually improve it. Use AI when it helps explain unfamiliar concepts, compare approaches, or investigate errors, but don’t allow generated implementations to replace understanding. The tools available today can make development faster and learning more accessible. What remains valuable is the ability to understand a problem, make sensible decisions, recognize mistakes, and determine whether the software actually does what it should. That is the foundation worth building from the beginning.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cd8f4d4d9b6f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building Engineering Depth in the AI Era]]></title>
            <link>https://naggelidis.medium.com/building-engineering-depth-in-the-ai-era-a0dd440507cf?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/a0dd440507cf</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[continuous-improvement]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technical-interview]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 19:24:59 GMT</pubDate>
            <atom:updated>2026-10-12T19:24:59.817Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*n5S74lP2nyeg6kh1Ol8fiQ.png" /></figure><p>Artificial intelligence has changed how software engineers work. Code can be generated in seconds, unfamiliar concepts can be explained immediately, and technical problems can be explored without spending hours searching through different sources. Most discussions around these capabilities focus on productivity, automation, and faster delivery. Yet one of the most valuable opportunities receives considerably less attention: using AI to become a more knowledgeable and technically capable engineer.</p><p>Software engineering has always required continuous learning. Programming languages evolve, frameworks introduce new patterns, and architectural decisions become more complex as systems grow. Experience remains essential, but professional responsibilities do not always expose engineers to everything they need to understand. Someone can spend years delivering production features while having limited exposure to certain aspects of concurrency, memory management, system design, or performance optimization. AI creates an opportunity to explore those areas deliberately, improve existing knowledge, and prepare for technical challenges beyond everyday responsibilities, including technical interviews.</p><p>The difference is in how the technology is used. Asking AI for an explanation provides information. Using it to challenge assumptions, identify weaknesses, simulate problems, and evaluate decisions can develop understanding. That distinction matters because access to knowledge and the ability to apply it are not the same thing.</p><h3>Understanding What You Know and What You Don’t</h3><p>One of the hardest parts of technical development is identifying knowledge gaps accurately. Engineers often recognize terminology, understand common implementations, and feel comfortable discussing technologies they regularly use. However, familiarity can create an impression of understanding that disappears when a problem is presented outside its usual context.</p><p>Consider concurrency. A developer might understand that asynchronous operations allow work to proceed without blocking execution, yet struggle to explain what happens when multiple operations access the same mutable state. They might know how to launch asynchronous tasks but be less confident about cancellation, task ownership, error propagation, or execution order. These differences are difficult to detect through passive reading because recognizing an explanation is easier than producing one independently.</p><p>AI can help assess understanding through progressively more challenging questions. Instead of asking for a general explanation of concurrency, an engineer can request a technical assessment that begins with fundamentals and gradually introduces realistic problems. The questions should require explanations, predictions, and decisions rather than only definitions. For example, the learner could examine a short implementation, predict its behavior, identify possible failures, and justify a solution before receiving any feedback.</p><p>A useful assessment also distinguishes between different types of weaknesses. Missing a concept entirely is different from understanding it but applying it incorrectly. Similarly, an engineer may reach a reasonable conclusion while being unable to explain the reasoning clearly. AI can help identify these patterns through follow-up questions, although its judgments should not be treated as automatically correct. The result should be a practical picture of what needs further investigation, supported by examples of what the learner could and could not explain.</p><h3>Building Knowledge Through a Structured Learning Process</h3><p>Once a knowledge gap has been identified, the next challenge is deciding how to address it. Reading unrelated explanations or asking random technical questions may introduce useful information, but it rarely produces a clear picture of progress. A more effective approach is to organize learning around the concepts required to understand a subject and the engineering decisions that depend on them.</p><p>Suppose an engineer wants to become more confident with application architecture. Starting immediately with complex design patterns may not be the most useful approach. It may be necessary to revisit component responsibilities, dependencies, state management, testing boundaries, and data flow first. AI can help map these relationships, identify prerequisites, and propose an order of study that connects foundational concepts with practical engineering problems.</p><p>This process becomes more valuable when each subject has a clear learning objective. Understanding dependency injection, for example, should go beyond knowing its definition or recognizing a constructor that accepts dependencies. An engineer should be able to explain why it can improve testability, how dependency lifetime affects behavior, when shared dependencies introduce risks, and why adding another abstraction is not always justified. The subject is understood more deeply when the engineer can decide whether to use the technique, not simply demonstrate how to implement it.</p><p>AI can adapt the depth of discussion as knowledge develops. An unfamiliar topic can begin with a simple explanation and a small example before expanding into implementation details, edge cases, and architectural consequences. An experienced engineer may skip the introductory material and focus directly on tradeoffs, performance, or failure scenarios. The objective is not to make every subject unnecessarily complex but to reach the depth required to reason about it confidently.</p><h3>Moving From Explanations to Active Problem-Solving</h3><p>Reading an accurate explanation does not guarantee that the information has been learned. Understanding becomes more reliable when someone must retrieve knowledge, apply it to a new situation, and explain the result without assistance. AI is particularly useful here because it can generate exercises, change their difficulty, and respond to the learner’s reasoning.</p><p>A practical approach is to study a concept briefly and then attempt a problem before asking AI for a solution. Consider an API request that times out after the server has already processed it. Should the client retry automatically? What happens if the operation creates an order or processes a payment? Could repeating the request cause the same action to occur twice? These questions introduce the concept of idempotency, where repeating an operation has the same intended effect as performing it once. More importantly, they require the learner to connect networking behavior, backend responsibilities, failure handling, and system design.</p><p>Rather than presenting the final answer immediately, AI can act as an interviewer or technical mentor by introducing information gradually. It might first ask what assumptions the proposed solution makes, then introduce a new constraint, and finally compare alternative approaches. If a learner proposes retrying every failed request, AI can ask what would happen if the server completed the operation but the response never reached the client. The discussion then moves naturally toward request identifiers, duplicate detection, and the responsibilities of the client and server.</p><p>The method works equally well with code. AI can generate a small implementation containing a race condition, a resource leak, an incorrect test, or an architectural problem. The learner investigates the behavior, explains the underlying cause, and proposes a correction. Only afterward should the implementation and reasoning be reviewed. This encourages problem-solving rather than answer recognition and helps connect abstract knowledge with situations engineers encounter in real systems.</p><p>Another useful technique is to explore counterexamples. After learning when a particular solution works, ask AI to generate a scenario where it becomes ineffective or introduces unnecessary complexity. Understanding the limitations of a technique is often what separates familiarity from the ability to make an engineering decision.</p><h3>Developing Technical Judgment Through Tradeoffs</h3><p>As engineering responsibilities expand, technical growth becomes less about learning individual technologies and more about understanding how decisions affect an entire system. Many engineering problems do not have a universally correct answer. Different solutions may be reasonable depending on requirements, constraints, and the costs a team is willing to accept.</p><p>AI can support this development by presenting scenarios where several approaches are technically valid. Imagine designing a mobile application that must remain usable without an internet connection. The discussion might begin with local storage and later expand into synchronization, conflicting updates, data ownership, and recovery after failed operations. A simple cache may be enough for information that only needs to be displayed, while user-generated changes introduce questions about which version of the data should take priority and how conflicts should be resolved.</p><p>Instead of requesting the best architecture, an engineer can use AI to evaluate alternatives under changing conditions. What happens when data must be synchronized across multiple devices? How should the application behave when the server rejects an offline change? What changes when sensitive information is stored locally? Which parts of the architecture become more difficult to test or maintain?</p><p>The purpose of these discussions is not to reach the most sophisticated design. It is to understand which requirements justify complexity and which decisions create future costs. AI can expose missing assumptions, offer alternative perspectives, and challenge proposed solutions, but its recommendations still require independent evaluation. For meaningful architectural decisions, the ability to explain why a simpler solution is sufficient can be just as important as knowing how to implement a more advanced one.</p><p>This approach also makes learning transferable across platforms. Concepts such as ownership, cancellation, state consistency, error handling, and separation of responsibilities appear in different forms across iOS, Android, backend services, and distributed systems. Comparing how technologies address the same underlying problem helps engineers build knowledge that remains useful beyond a specific framework or programming language.</p><h3>Using AI for Technical Interview Preparation</h3><p>Technical interviews provide a useful application of structured AI-assisted learning. They require engineers to explain knowledge clearly, reason about unfamiliar problems, and demonstrate how they approach decisions under limited time. Practical experience helps, but daily work does not necessarily prepare someone to discuss every technical subject without documentation or familiar code.</p><p>AI can turn interview preparation into an interactive process rather than a collection of questions and memorized answers. A preparation session can begin by defining the target role, expected experience level, technical subjects, and preferred question format. The model can then present questions one at a time, wait for an answer, evaluate the reasoning, and introduce follow-up questions where necessary.</p><p>For example, an iOS interview might cover Swift fundamentals, ARC, concurrency, UIKit, SwiftUI, networking, testing, and architecture. An Android interview could examine Kotlin, coroutines, Jetpack Compose, application lifecycle, and similar engineering concerns. The same method can be applied to backend, frontend, or full-stack roles by changing the technical scope rather than the learning process.</p><p>Multiple-choice questions are useful for identifying misunderstandings quickly, but the explanation following each answer is more important than the result itself. When an answer is incorrect, AI should explain why the selected option is wrong, why the correct option is appropriate, and what the remaining alternatives actually represent. This prevents interview preparation from becoming an exercise in remembering which option was correct.</p><p>Consider a memory-management question where the expected answer involves a weak reference. A useful explanation should not stop at saying that weak references can help prevent retain cycles. It should examine object ownership, strong references, the conditions that create a cycle, and why introducing weak references everywhere would be incorrect. A single question can therefore reveal several related concepts and provide direction for further study.</p><p>However, multiple-choice exercises mainly test recognition and selection. They should be combined with open-ended questions, code analysis, debugging challenges, and architectural discussions that require independent explanations. A realistic interview simulation should not reveal the answer through hints or repeatedly steer the candidate toward the expected response.</p><h3>Preparing for Different Levels of Engineering Responsibility</h3><p>Interview preparation becomes more effective when questions reflect the type of reasoning expected for a particular role. A junior engineer may be asked to explain a concept and demonstrate its basic implementation. A mid-level engineer may need to identify a problem in an existing implementation and explain how to resolve it. A senior engineer may be expected to evaluate multiple solutions, consider system-level consequences, and explain decisions under incomplete requirements.</p><p>The same technical subject can be explored at all three levels. With concurrency, an introductory question might ask what a race condition is. A more advanced scenario could involve identifying unsafe access to shared state in asynchronous code. A broader engineering discussion might examine how to coordinate several operations while considering performance, cancellation, failure recovery, and maintainability.</p><p>This progression is useful because engineering seniority is not simply a measure of how many advanced concepts someone knows. It also involves the scope of problems they can handle, the decisions they can justify, and their ability to work with uncertainty. Technical knowledge remains important at every level, but the expectations surrounding its application change.</p><p>AI can generate scenarios tailored to these differences, including situations where requirements are incomplete or several alternatives appear reasonable. For example, a system-design exercise might ask how to migrate an existing application to a new architecture without interrupting feature delivery. The discussion could involve incremental migration, compatibility, testing strategy, team coordination, and rollback options. The strength of the answer would depend less on naming a particular architectural pattern and more on identifying risks, defining constraints, and explaining a workable approach.</p><p>It is important to treat these exercises as preparation rather than certification. Companies define engineering levels differently, and an AI model cannot reliably determine professional seniority from a limited set of responses. What it can do is expose a learner to a wider range of technical expectations and help them practice communicating their reasoning.</p><h3>Turning Incorrect Answers Into Measurable Progress</h3><p>One of the most common weaknesses in technical preparation is focusing on the number of questions completed rather than the knowledge gained from them. Answering fifty questions may feel productive, but the result means little if the same mistakes continue to appear or if correct answers depend on remembering familiar examples.</p><p>AI can help track performance by topic and difficulty, but the assessment must go beyond a single score. A useful record distinguishes between correct answers supported by sound reasoning, partially correct explanations, unsupported guesses, and clear misunderstandings. This makes it easier to identify whether a subject needs more theoretical study, practical exercises, or communication practice.</p><p>An incorrect answer should lead to a new learning activity rather than simply repeating the original question. If someone misunderstands asynchronous cancellation, the next exercise should test the same underlying knowledge in a different context. If the learner can correctly explain the new situation without hints, that provides stronger evidence of understanding than remembering the previous answer.</p><p>Progress should also be tested after some time has passed. Returning to a subject after several days, without first reviewing the explanation, helps reveal whether the knowledge has been retained. Mixing topics during later sessions adds another useful challenge because real engineering problems rarely announce which concept is required. A debugging scenario may involve networking, concurrency, state management, and error handling simultaneously.</p><p>For interview preparation, practice should eventually move from guided learning to independent assessment. Early sessions can include explanations, examples, and hints. Later sessions should remove those aids, introduce unfamiliar questions, and ask the learner to explain decisions within realistic time constraints. Technical communication should also be evaluated: whether the answer addresses the question, states important assumptions, and explains tradeoffs clearly without unnecessary detail.</p><p>Scores can indicate progress within a particular practice format, but they should not be confused with interview readiness. Stronger evidence comes from consistent performance across unfamiliar problems, the ability to explain answers independently, and practical application beyond the original exercise.</p><h3>Keeping AI-Assisted Learning Reliable</h3><p>An interactive learning process is only useful when the information supporting it is trustworthy. AI models can produce convincing explanations that contain incorrect assumptions, outdated API behavior, or technical details that do not apply to the relevant platform version. They can also evaluate a valid answer incorrectly or favor an unnecessarily complicated solution.</p><p>Verification must therefore be part of learning rather than something performed only when a problem occurs. Official documentation should be used to confirm language behavior, framework guarantees, and platform-specific requirements. Small experiments, automated tests, and reproducible examples can help establish whether an explanation matches actual system behavior. When multiple solutions are possible, comparing their assumptions and limitations is more useful than accepting the model’s preferred answer immediately.</p><p>AI is most valuable when it makes technical claims easier to investigate, not when it becomes the final authority on those claims. A learner should feel comfortable questioning an explanation, asking for supporting evidence, and testing whether the behavior changes under different conditions.</p><p>There is also a risk of becoming dependent on continuous guidance. If every challenge is immediately followed by a request for the solution, little opportunity remains to develop independent reasoning. A useful learning process deliberately includes moments when AI is unavailable: explaining a concept from memory, solving an unfamiliar exercise, reviewing code independently, or making an architectural decision before comparing it with alternatives.</p><p>The objective is to use assistance where it accelerates understanding while preserving the effort required to develop the underlying skill.</p><h3>Making Technical Growth a Continuous Practice</h3><p>Building technical depth does not require studying every subject or following an exhausting daily routine. A focused learning process can be organized around a small number of activities: identifying a specific weakness, understanding the relevant concepts, applying them to unfamiliar problems, reviewing mistakes, and revisiting the subject later to test retention.</p><p>AI can help maintain this process by organizing learning objectives, adapting exercises to previous results, and suggesting related topics once the fundamentals become clear. Someone learning a new mobile platform might begin with language and lifecycle concepts before progressing toward architecture and performance. An engineer preparing for broader technical responsibilities might focus on system boundaries, failure handling, tradeoffs, and the long-term consequences of design decisions. Someone preparing for interviews might emphasize a balance of foundational questions, practical scenarios, technical communication, and independent assessments.</p><p>The structure can remain consistent even as the goals change. What matters is that learning produces capabilities that can be demonstrated beyond the original conversation. An engineer should gradually become more comfortable explaining unfamiliar code, questioning proposed solutions, connecting concepts across technologies, and making decisions without depending on generated answers.</p><p>AI makes technical exploration more accessible and can reduce the effort required to discover what to study next. It does not eliminate the need for practice, real implementations, independent reasoning, or learning from experienced colleagues. Those activities remain central to professional growth.</p><p>The real opportunity is to treat AI as more than a productivity tool. It can become a structured environment for developing knowledge, testing assumptions, preparing for technical interviews, and strengthening engineering judgment. Its value is not measured by the amount of information it generates, but by the understanding and capabilities an engineer develops through using it.</p><p><strong>The outcome that matters is not how much AI can do for an engineer, but how much more that engineer can understand and accomplish independently.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a0dd440507cf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Engineering Beyond Code Generation]]></title>
            <link>https://naggelidis.medium.com/engineering-beyond-code-generation-273816a51676?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/273816a51676</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-10-05T14:51:01.503Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3xOyOlt1nsXFQn9luSudKw.png" /></figure><p>Software development has always evolved through abstraction. Higher level languages removed the need to manage many low level details, frameworks reduced repetitive implementation work, search engines changed how developers found answers, and automation took over large parts of building, testing, and deployment. Generative AI continues that evolution, but it reaches further into the engineering process because it can participate directly in implementation, investigation, testing, documentation, review, and increasingly larger development tasks through coding agents. As implementation becomes easier to generate, the important question is no longer how much code an engineer can produce, but which engineering abilities become more valuable when producing code is no longer the difficult part.</p><p>Prompt engineering is often presented as one of those abilities, but that explanation is too narrow. Clear instructions, relevant context, and precise constraints improve AI output, yet a well written prompt can still produce the wrong solution. An engineer can request a clean abstraction around a concept that should not exist, generate comprehensive tests for a misunderstood requirement, or create a technically elegant implementation in the wrong part of the system. The valuable skill is therefore not simply knowing how to make AI produce better code, but understanding the problem well enough to decide what should be built, where it belongs, which constraints matter, and how the result should be evaluated.</p><h3>Code Is Becoming Cheaper, Engineering Decisions Are Not</h3><p>AI can reduce the effort required to produce an initial implementation, and there is little reason to preserve repetitive work simply because it once required human effort. Writing predictable transformations, creating basic test data, preparing documentation, or exploring an unfamiliar API are all examples where automation can remove unnecessary friction. This is useful progress because engineering time can move toward work that requires more understanding and judgment. The important distinction is that faster implementation does not remove the decisions that surround implementation.</p><p>Before code is written, someone still needs to understand the actual problem, identify the relevant constraints, decide where responsibility belongs, determine how existing behavior must be preserved, and consider what happens when expected conditions are not met. After implementation, someone must still decide whether the result is correct, maintainable, observable, secure, and appropriate for the wider system. These responsibilities remain regardless of how quickly an implementation can be produced. In some situations they become more important because an incorrect assumption can now become a large change much faster than before.</p><p>This changes where engineering value is concentrated. When implementation is expensive, turning an idea into working code represents a large part of the effort. When implementation becomes cheaper, the quality of the decisions surrounding that implementation becomes more visible. AI can accelerate a good decision, but it can accelerate a poor one with the same efficiency, which means speed only creates value when the direction is correct.</p><h3>Seniority Is Built Through Engineering Judgment</h3><p>Seniority is sometimes described as a progression through increasingly advanced technologies, but technical knowledge alone does not explain the difference between levels of engineering maturity. Experience is often more visible in the quality of decisions made when the answer is incomplete, ambiguous, or dependent on tradeoffs. Experienced engineers have usually seen simple abstractions become long term dependencies, temporary solutions remain for years, apparently harmless assumptions create production problems, and sophisticated designs become unnecessary complexity. Those experiences gradually create patterns of recognition that influence future decisions.</p><p>An experienced engineer may notice that a simple boolean will probably evolve into several states, that a convenient dependency is introducing unwanted coupling, or that a retry mechanism can create duplicate operations. Another engineer may recognize that a new abstraction duplicates a concept that already exists, or that a small API change creates compatibility problems for several consumers. These observations do not come primarily from knowing more syntax. They come from repeatedly seeing how technical decisions behave after implementation and understanding the relationship between a local change and its wider consequences.</p><p>AI can explain concurrency, caching, transactions, state management, architecture, and distributed systems with impressive clarity. Access to that knowledge is useful, but knowing the definition of a problem is different from developing the instinct to recognize it in an actual system. Judgment develops when engineers repeatedly connect decisions with outcomes, including decisions that eventually prove to be wrong. This is one reason seniority remains relevant even when increasingly sophisticated implementations can be generated automatically.</p><h3>The Risk Is Unexamined Delegation</h3><p>Avoiding AI in order to protect engineering skills would be the wrong response. Software development has always involved deciding which complexity deserves human attention and which complexity can safely be delegated to tools. There is little educational value in repeatedly writing boilerplate that is already understood, manually producing predictable mappings, or spending significant time searching for syntax that has simply been forgotten. AI can remove this friction and create more time for investigation, design, validation, and understanding.</p><p>The risk appears when engineers also delegate the work that creates understanding. Debugging an unfamiliar system forces someone to form hypotheses about how the system behaves. Tracing data through several components builds an understanding of ownership and boundaries. Comparing different implementations requires reasoning about tradeoffs, while investigating why an apparently correct solution failed creates knowledge that is difficult to obtain from a successful first attempt. These activities can be difficult, but some of that difficulty is part of the learning process rather than unnecessary friction.</p><p>If every unfamiliar problem immediately becomes a request for AI to provide a complete solution, the task may be completed faster while part of the learning process disappears. This is particularly relevant while engineering judgment is still developing because evaluating an answer requires some understanding of the concepts behind it. A more productive approach is to form an initial hypothesis, ask AI to challenge or extend it, compare the generated explanation with the actual system, predict what a proposed change will affect, and verify whether those predictions were correct. AI can accelerate learning without replacing the reasoning that makes the learning valuable.</p><h3>Problem Framing Matters More Than Prompting</h3><p>Prompting matters because AI systems need context. A vague request usually produces a generic solution, while a request that includes expected behavior, relevant constraints, architectural boundaries, and validation requirements gives the system a much stronger foundation. The important point is that those details do not come from prompt technique alone. They usually come from understanding the problem and the system in which that problem exists.</p><p>A simple request to add caching requires very little context. A meaningful engineering request needs to explain what may safely be cached, how long stale data remains acceptable, which events invalidate the stored value, what data boundaries must remain isolated, what should happen when the cache is unavailable, and how the system should behave after a failed refresh. The second request is likely to produce a better result, not because it uses more sophisticated wording, but because the engineer understands which constraints define the problem.</p><p>This distinction becomes more important as AI tools improve. Models will become better at interpreting incomplete instructions, gathering context, and asking relevant questions, which will gradually reduce the importance of specific prompting techniques. The more durable skill is knowing which questions need to be answered in the first place. Experienced engineers understand which requirements are flexible, which behaviors represent system invariants, which decisions are cheap to reverse, and which decisions create long term commitments.</p><h3>Generated Code Still Requires Engineering Ownership</h3><p>AI generated code can look highly convincing. Naming may be consistent, abstractions may appear reasonable, comments may sound professional, and the implementation may follow patterns already present in the project. The code may compile immediately and generated tests may pass, but none of these qualities prove that the solution is correct. A polished implementation is still a technical claim that needs to be validated against the behavior the system is expected to provide.</p><p>The engineer needs to understand what assumptions exist inside the generated implementation. It is important to know which inputs it expects, which states it treats as impossible, which dependencies it relies on, which failures it handles, and which parts of the surrounding system were outside the context available to the model. Surface quality can make these questions easier to overlook because readable code naturally feels more trustworthy. AI generated output therefore requires the same engineering ownership as human written code, even when the initial implementation appears complete.</p><p>Testing provides evidence, but generated tests also need independent reasoning. When the same system creates both an implementation and its tests, both can share the same misunderstanding of the requirement. Everything can pass while the feature remains conceptually wrong because the tests verify what the generated code already does rather than what the system is supposed to do. Effective testing still requires thinking about invariants, boundaries, invalid input, repeated operations, interrupted execution, concurrency, compatibility, and unexpected states.</p><h3>Context Matters More as Agents Become More Capable</h3><p>Coding agents can inspect repositories, search for related implementations, modify multiple files, execute commands, run tests, react to failures, and continue toward a broader objective. These capabilities create significant leverage, but access to a repository does not automatically create a complete understanding of the system. Code rarely contains every reason behind its current structure, and many important constraints exist outside the implementation itself.</p><p>An agent may find a strange condition without knowing that it exists because of a previous production incident. It may find two similar implementations without knowing that one is part of an ongoing migration. It may identify an apparently unnecessary field without knowing that another consumer depends on it, or understand the current architecture while missing a product constraint that has never been documented. Experienced engineers often create value precisely by connecting information across these boundaries and understanding which constraints are intentional, historical, temporary, or likely to change.</p><p>This makes good engineering practices more important rather than less important. Clear architecture, reliable documentation, explicit interfaces, meaningful tests, observable behavior, manageable changes, and well defined ownership make systems easier for both humans and agents to understand. AI does not remove the need for these practices, because it benefits directly from the quality of the environment around it. A poorly documented system with weak tests and unclear boundaries does not become well engineered because an agent can modify it faster.</p><h3>AI Agents Need Clear Engineering Boundaries</h3><p>An AI assistant normally operates within a relatively narrow interaction, while an agent can work across a much larger technical surface. It may inspect files, modify code, execute commands, run tests, and iterate until a task appears complete. That additional autonomy creates useful leverage, but it also increases the importance of defining boundaries before the work begins.</p><p>A request to improve an architecture gives an agent a large decision space. A task that defines the expected outcome, relevant modules, interfaces that must remain stable, dependencies that should not be introduced, and validation that must succeed creates a controlled environment in which the agent can operate. The difference is similar to the difference between vague and effective delegation between engineers. Good delegation communicates intent, relevant context, constraints, ownership, and the definition of success.</p><p>As agent capability grows, engineering work can shift from supervising every implementation detail toward designing the boundaries within which implementation can safely happen. That does not reduce the need for technical understanding because defining useful boundaries requires a strong understanding of the system. The larger the area an agent can change, the more important it becomes to control the possible impact, keep changes understandable, provide reliable validation, and preserve human review where decisions carry meaningful risk.</p><h3>More Code Does Not Mean More Productivity</h3><p>AI can increase the amount of code produced within a given period, but software development does not create value by maximizing code output. Code still needs to be understood, reviewed, integrated, tested, deployed, observed, maintained, and eventually changed again. Increasing the speed of one stage does not automatically increase the capacity of all the stages around it. A larger amount of generated code can therefore move a bottleneck rather than remove it.</p><p>If an engineer can generate a much larger change in the same amount of time, a reviewer does not automatically gain an equivalent increase in the ability to understand that change. Testing environments do not become faster, integration risk does not disappear, and the amount of context required for future maintenance can increase. Local implementation speed can improve while overall delivery remains limited by review, testing, integration, or understanding. Engineering productivity needs to be considered at the level of the whole development system rather than only at the point where code is created.</p><p>The most valuable use of AI is therefore not always generating more implementation. Sometimes the better use is investigating whether an existing capability already solves the requirement, comparing architectural approaches before a decision is made, identifying duplicated logic, preparing a migration plan, generating meaningful test scenarios, or reviewing a proposed change. In some cases the strongest engineering outcome is discovering that less code needs to be written.</p><h3>Building Craftsmanship in an AI Assisted Environment</h3><p>Learning software engineering in this environment does not require pretending that AI does not exist. Engineers entering the field will naturally work with tools that can answer questions, explain unfamiliar code, generate implementations, investigate failures, and suggest alternatives. The challenge is using those capabilities without removing the reasoning required to become independent. AI should shorten unnecessary work without shortening the process of understanding the important parts of a problem.</p><p>A useful habit is to develop an initial opinion before asking AI for the complete answer. The opinion does not need to be correct because its purpose is to force the engineer to build a model of the problem before seeing a generated solution. When an alternative arrives, there is then something meaningful to compare against. If the prediction was wrong, understanding why it was wrong becomes part of the learning process.</p><p>Generated code should also be treated as material to study when the underlying concept is unfamiliar. Understanding why an abstraction was introduced, why state belongs in a particular component, why an operation needs to be asynchronous, or what would happen if a dependency were removed builds knowledge that cannot be replaced by simply accepting a working result. Debuggers, runtime inspection, documentation, logs, network traffic, and unfamiliar code written by other engineers remain valuable because they expose how systems actually behave.</p><p>A useful working model is to predict, generate, inspect, and prove. An engineer first predicts what is happening and what kind of solution may be appropriate, then uses AI to generate an explanation, proposal, or implementation. The result is inspected against the real system and the original reasoning, then validated using tests, runtime behavior, documentation, measurements, or other relevant evidence. The objective is not to make the first prediction correct every time, but to gradually improve the mental models behind future predictions.</p><h3>Fundamentals Still Matter</h3><p>There is a temptation to believe that deeper technical knowledge becomes less important when AI can explain technical concepts on demand. In practice, those fundamentals remain the mental models needed to judge generated solutions when systems behave in unexpected ways. Networking matters when requests behave differently under latency, retries, or partial connectivity. Concurrency matters when state changes unexpectedly under simultaneous work, database knowledge matters when consistency assumptions fail, and security matters whenever data or authority crosses a boundary.</p><p>Distributed system concepts remain relevant when ordering, duplication, partial failure, and eventual consistency become part of a workflow. Architecture still matters when a locally convenient solution creates long term coupling, and understanding data structures still matters when behavior changes as data volume grows. Engineers do not need to memorize every detail of every technical domain, but they need enough understanding to recognize which concepts are relevant to a problem and when a generated solution deserves deeper investigation.</p><p>AI can make these fundamentals easier to study. It can explain the same idea at different levels, generate practical examples, compare alternative approaches, create exercises, and challenge existing assumptions. This makes AI a powerful learning tool when it is used to deepen understanding. The important distinction is between using AI to understand something and using AI so that understanding is no longer considered necessary.</p><h3>Seniority Becomes Visible Beyond the Code</h3><p>As generated code improves, engineers with different levels of experience may produce implementations that look similarly polished. Naming can be clean, architecture can appear consistent, tests can be extensive, and documentation can be readable regardless of who initiated the generation. The difference in engineering ability may therefore become less visible in the surface quality of the final implementation and more visible in the decisions made before, during, and after it.</p><p>One engineer may recognize that the requested feature conflicts with an existing system invariant before implementation starts. Another may notice that a generated design creates an unnecessary dependency, question whether an API contract is appropriate, identify that a migration has no safe rollback path, or reduce a large generated patch to a much smaller solution. These decisions may not appear prominently in the final code, but they often determine whether the result is good engineering.</p><p>The same difference appears during review. A less experienced reviewer may focus primarily on whether the generated implementation looks clean and follows existing conventions. A more experienced reviewer may also question whether the implementation should exist, whether responsibility belongs in that component, whether the new abstraction creates future cost, and whether the evidence actually proves the expected behavior. These are not new responsibilities created by AI, but AI makes them easier to distinguish from implementation ability.</p><h3>Engineering Judgment Remains the Craft</h3><p>Software craftsmanship has never truly been about how difficult it is to type the final implementation. The craft lies in understanding the problem, understanding enough of the system around it, choosing between imperfect alternatives, recognizing risk, and making decisions that continue to make sense after the code reaches production. AI changes the mechanics around this process, but it does not remove the need for those decisions to be good.</p><p>AI can shorten the path from an idea to an implementation, make experimentation cheaper, help engineers investigate unfamiliar areas faster, generate alternatives that would have taken longer to explore manually, and allow experienced engineers to work effectively across a larger technical surface. It can also make it easier to create software that nobody fully understands. The difference depends on how the tool is used and how much engineering judgment remains involved in the process.</p><p>The useful response is neither to reject AI nor to treat every generated answer as progress. Engineers need to become better at deciding which work should be automated, which work requires deeper investigation, which outputs require stronger verification, and which decisions should remain deliberate. Less experienced engineers need to use AI without skipping the process of building mental models, while experienced engineers need to use it to increase leverage without losing control of architecture, quality, and technical direction.</p><p>Engineering beyond code generation means using increasingly capable tools without confusing generation with understanding. The durable advantage is not being able to produce the most code or construct the most sophisticated prompt. It is understanding what deserves to be built, why it should be built that way, how to prove that it works, and what consequences the decision creates for the system around it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=273816a51676" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing Mobile Apps for Change: How Architecture Reduces Migration Cost]]></title>
            <link>https://naggelidis.medium.com/designing-mobile-apps-for-change-how-architecture-reduces-migration-cost-a881fa540302?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/a881fa540302</guid>
            <category><![CDATA[cross-platform]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[clean-code]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[platform-engineering]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-09-28T14:51:01.729Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uEohiPydrqClP2gk7R-Gaw.png" /></figure><h3>Future-Proofing Is the Wrong Goal</h3><p>Every major mobile platform release tends to produce the same kind of story. One application requires weeks of migration work, another needs only a handful of changes, and somebody eventually explains that their application was already prepared because it had been built with clean code, modular architecture, and very few shortcuts. There is some truth behind that idea, but taken literally it can be misleading. No team can know exactly what Apple or Google will change several years from now. No architecture can predict a new lifecycle requirement, an unexpected device category, a rendering change, a privacy restriction, a new windowing model, or an API that does not yet exist. What good architecture can do is something much more practical. It can determine how far a platform change is allowed to travel through the application.</p><p>That distinction is the foundation of building mobile software that ages well. The objective should not be to create an application that never needs migration work. Such an application does not realistically exist. The objective is to prevent every platform change from becoming an application-wide change. If Apple modifies how application windows behave, most business rules should not care. If Android changes how content interacts with system bars, authentication logic should not need to change. If a cross-platform framework updates the way it communicates with its native host, the product’s core domain should ideally remain untouched. Architecture does not eliminate change. It gives change boundaries.</p><h3>Platform Changes Expose Architectural Assumptions</h3><p>This becomes particularly visible during major platform transitions. Apple’s current UIKit guidance for iOS 27 requires applications built with the latest SDK to use the scene-based lifecycle. Applications that do not adopt it can fail to launch. Apple is also emphasizing dynamically resizable applications and specifically recommends auditing older assumptions involving the main screen, device idiom, interface orientation, and application lifecycle. An application written years ago could not have known exactly when those requirements would become mandatory. What its developers could control was whether lifecycle and device assumptions were concentrated around a small set of components or scattered through dozens of unrelated features.</p><p>Android provides the same lesson through different changes. Android 15 made edge-to-edge presentation the default for applications targeting API level 35, which means interfaces that previously relied on the operating system to keep content away from system bars can require explicit inset handling. Google’s adaptive-app guidance also encourages developers to design around the actual window available to the application rather than make decisions from the physical device category. Tablets, foldables, multi-window environments, desktop-style windowing, orientation changes, and resizable application windows all make the old assumption that a device maps to one predictable layout increasingly unreliable.</p><p>The important point is not that teams should have predicted those changes. They could not have. The architectural question is whether an assumption about lifecycle, layout, navigation, system UI, or device characteristics exists in one predictable part of the system or whether the same assumption has quietly become duplicated across the application. The first situation creates a migration. The second creates an investigation.</p><h3>Mobile Architecture Is Larger Than Native Development</h3><p>These examples come from Apple and Google because they control the platforms on which mobile applications actually execute, but the architectural principle is not tied to Swift, Kotlin, UIKit, SwiftUI, Jetpack Compose, or any other particular technology. A mobile application may be written natively, built with Flutter or React Native, share substantial logic through Kotlin Multiplatform, or use another cross-platform approach. It still eventually runs inside environments controlled by Apple and Google.</p><p>Cross-platform frameworks provide valuable abstractions over those environments, but abstraction is not elimination. The operating system still controls lifecycle events, application windows, permissions, notifications, background execution, system UI, accessibility behavior, device capabilities, distribution requirements, and many other parts of the runtime environment. A shared codebase can reduce duplication, but it does not make those platform responsibilities disappear.</p><p>Flutter makes this relationship particularly clear in its own architecture. Flutter renders much of its interface independently rather than translating every widget into an equivalent native control, yet a Flutter application is still hosted by a platform-specific embedder. That embedder is responsible for integrating with the operating system around areas such as application lifecycle, window sizing, input events, threading, and platform communication. When shared code needs capabilities that are not directly exposed by the framework, platform channels bridge the shared application to platform-specific implementations. Cross-platform development therefore does not remove the platform boundary. It adds another architectural layer through which that boundary must be managed.</p><p>The same reasoning applies to other cross-platform technologies. React Native still has a native integration layer. Kotlin Multiplatform explicitly separates shared code from platform implementations where necessary. Future frameworks will make different technical trade-offs, but the architectural question remains the same: which parts of the system represent the product, and which parts exist because of the technology currently used to deliver it?</p><h3>Architecture Should Create a Gradient of Change</h3><p>A useful way to think about resilient mobile architecture is as a gradient of change. Code closest to Apple, Google, the operating system, device capabilities, rendering frameworks, third-party SDKs, and external infrastructure should be expected to change more frequently. Application workflows should usually change for product reasons rather than operating-system reasons. Core business rules should generally be even less sensitive to the framework or platform running them.</p><p>The deeper a platform-specific change travels toward the product domain, the more expensive future migrations tend to become. If a new lifecycle requirement requires modifications in view infrastructure, that is expected. If the same requirement requires changes to pricing rules, eligibility logic, account state handling, and unrelated network models, the architecture has allowed platform concerns to travel further than they should.</p><p>This does not mean the domain must live inside an academic architecture diagram with multiple mandatory layers. It means dependencies should broadly point from volatile implementation details toward more stable application concepts rather than forcing stable product logic to understand every framework used around it.</p><h3>Separate Reasons for Change</h3><p>Consider a simple eligibility rule. An application may need to determine whether a customer is allowed to perform an action. That rule might depend on account state, subscription information, permissions granted by the business, or some contractual condition. None of those concepts inherently belongs to a screen, widget, view controller, composable, Flutter widget, or React component.</p><p>If the rule is implemented directly inside presentation code, however, it becomes coupled to something that changes much more frequently. A redesign can now disturb business behavior. Replacing one UI framework with another can require recovering domain logic from presentation code. Testing the rule may require constructing framework-specific objects that logically have nothing to do with the rule itself.</p><p>Separation of concerns exists to prevent exactly this kind of accidental coupling. Its value is not that an architecture diagram looks cleaner. Its value is that different parts of software can change for different reasons. Presentation changes because the product or platform changes visually. Data access changes because APIs, databases, or persistence strategies evolve. Platform integrations change because the operating system changes. Business rules change because the business changes. When those responsibilities are mixed together, their reasons for changing become mixed together as well.</p><h3>Do Not Confuse Architecture With Pattern Names</h3><p>Clean Architecture, MVVM, MVI, Redux-style state management, coordinators, repositories, use cases, feature modules, dependency injection, and similar approaches can all help, but none of them independently guarantees adaptability. A project can contain hundreds of interfaces, repositories, interactors, controllers, coordinators, and modules while remaining difficult to change. Another project can use a comparatively simple structure while keeping its responsibilities exceptionally clear.</p><p>The useful question is not whether an application can claim to follow a recognized architecture. The useful question is whether a change has an obvious and limited place to happen.</p><p>A practical way to evaluate that is to imagine that one assumption suddenly becomes false. Suppose the application can no longer assume a fixed window size. How many places require modification? Suppose the analytics provider is replaced. How much product logic knows which analytics vendor is being used? Suppose authentication moves to a different SDK. How many features directly import that SDK’s types? Suppose a new platform version changes navigation presentation. Does every feature own navigation mechanics independently? Suppose an API response changes shape while the underlying business concept remains identical. Does that change propagate directly into the UI?</p><p>Those questions reveal architectural coupling much more effectively than counting classes, layers, or modules.</p><h3>Cross-Platform Does Not Mean Platform-Blind</h3><p>The same test should be applied to cross-platform applications. Suppose a Flutter plugin stops being maintained before a major iOS release. Can another implementation replace it behind a small application-facing interface, or are plugin-specific types used throughout the product? Suppose a cross-platform framework changes part of its native integration architecture. Does platform-specific code live near clear boundaries, or has platform detection spread throughout shared application logic?</p><p>Sharing code is valuable, but maximizing the percentage of shared code should never become more important than preserving understandable responsibilities. Some concepts genuinely belong to the product and can be shared almost entirely. Validation rules, formatting rules, domain operations, data transformations, application state transitions, and large parts of networking or persistence can often be platform-independent. Other behaviors belong much more directly to the operating system: permissions, background execution, notifications, secure storage, deep-link entry points, biometric authentication, hardware integration, window behavior, accessibility integration, and platform-specific UI conventions.</p><p>Trying to hide every platform difference behind one universal implementation can sometimes create more complexity than acknowledging the difference explicitly. iOS and Android do not have identical lifecycle models, permission semantics, background-processing rules, UI conventions, or system integrations. A good cross-platform architecture can expose a common capability to the rest of the application while allowing each platform to implement that capability appropriately.</p><p>The application might understand a concept such as requesting notification permission without requiring every feature to understand the individual APIs and edge cases used by iOS and Android. The difference remains where it belongs: close to the platform boundary.</p><h3>Model Capabilities, Not Devices</h3><p>One of the clearest examples of architectural aging is device detection. Developers historically had good reasons to write conditions such as phone versus tablet or portrait versus landscape. Those categories were useful approximations of the environment. They are becoming less reliable as applications run in resizable windows, on foldables, on tablets with several multitasking configurations, on desktop-style environments, through mirroring technologies, and across new device classes.</p><p>Both Apple and Google increasingly encourage developers to respond to available space rather than simplistic assumptions about physical hardware. The architectural principle behind that guidance is broader than responsive UI: model the capability the application actually requires instead of relying on an indirect proxy that happens to describe today’s devices.</p><p>If an application needs enough horizontal space to show two panes, the real condition is available width rather than whether marketing calls the device a tablet. If a feature requires biometric authentication, the important questions concern availability and successful authentication rather than a list of devices expected to support biometrics. If an interaction requires a pointer, keyboard, camera, NFC controller, or particular sensor, capability detection describes the requirement more accurately than assumptions derived from a device model.</p><p>Capability-oriented design survives new hardware categories better because a new device does not automatically require a new branch in business or presentation logic.</p><h3>Keep Platform APIs Close to the Platform</h3><p>Platform APIs should therefore be treated as dependencies with clear ownership. That does not mean wrapping every operating-system function behind a custom abstraction. Mechanical abstraction quickly produces unnecessary code and makes simple functionality harder to follow.</p><p>The goal is to identify platform concepts that have a meaningful chance of changing independently from product logic. Notifications, permissions, location, secure storage, lifecycle, external links, biometrics, background processing, file access, navigation integration, analytics, and hardware capabilities are common candidates.</p><p>A feature should usually consume the capability it needs rather than import the entire implementation mechanism used to provide it. A payments feature may need to know whether authentication succeeded. It should not necessarily need to know which native biometric API produced that result. A profile feature may need to open an external destination. It should not have to understand every platform-level rule used to present that destination.</p><p>The principle is simple: platform knowledge should be deliberately introduced, not casually spread.</p><h3>A Design System Reduces Visual Migration Cost</h3><p>UI architecture deserves special attention because visual changes are often the most visible part of major platform releases. Apple’s Liquid Glass transition illustrates the difference between using system conventions and recreating them independently. Standard platform components can inherit significant parts of updated appearance and behavior automatically, while heavily customized interfaces naturally require more deliberate adaptation.</p><p>That does not make custom UI a bad choice. Many products require a distinct visual language or interaction model. It means customization creates ownership. Once an application replaces platform behavior with its own behavior, maintaining that behavior across future platform changes becomes the application’s responsibility.</p><p>A design system can dramatically reduce that ownership cost. Without one, a button may be implemented differently across many features. Padding, typography, loading states, error presentations, navigation controls, dialogs, sheets, and form elements may each contain slightly different assumptions. A visual platform change then produces many independent migration points.</p><p>With a coherent design system, features consume semantic components and tokens whose implementation can evolve centrally. The design system becomes a boundary between volatile visual implementation and stable product intent.</p><p>The important word is semantic. A design system should not merely replace one framework button with a product-specific wrapper while exposing every platform styling detail to callers. It should represent concepts the product actually uses: primary action, destructive action, validation error, loading state, selected state, content container, navigation destination. How those concepts are rendered can evolve independently.</p><h3>Navigation Is an Architectural Boundary Too</h3><p>Navigation is easy to underestimate because small applications often begin with only a handful of screens. Directly opening the next screen feels simple, and at that scale it usually is. Mature applications eventually need deep links, authentication gates, push-notification entry points, tab hierarchies, modal flows, restoration, experiments, external URLs, and different presentation models depending on available space.</p><p>If each screen owns both the product intent and exact presentation mechanics, navigation becomes expensive to evolve. Separating the request to reach a destination from the mechanism used to present that destination creates room for platform and layout behavior to change without rewriting feature logic.</p><p>A feature may need to communicate that the user wants to view account details. Whether those details appear in a stack, sheet, secondary pane, modal, or another platform-specific structure can then remain a presentation concern. This becomes particularly valuable in cross-platform applications, where identical product intent may still produce slightly different navigation behavior on iOS, Android, compact windows, and larger screens.</p><h3>Do Not Let Transport Models Become the Product Model</h3><p>Data architecture is another major source of hidden migration cost. Network response models are convenient to pass directly through an application because doing so eliminates mapping code. That convenience can become expensive when backend contracts evolve.</p><p>API models exist for transport. Persistence models exist for storage. Presentation models exist because a particular UI needs information in a particular form. Domain models describe concepts meaningful to the product. Sometimes one representation can safely serve more than one purpose, particularly in small applications, but treating that as the default creates coupling between areas that change for unrelated reasons.</p><p>Consider an API response that renames a field, changes optionality, introduces a nested structure, or replaces one representation with another. If the response object is also used directly by the UI, a transport change immediately becomes a presentation change. If the same object is persisted directly, the backend change may also become a database migration.</p><p>Explicit mapping looks like additional work while everything is stable, but it acts as a firewall when systems evolve independently.</p><h3>Persistent Data Is a Long-Term Contract</h3><p>Local data needs additional attention because platform migrations are not the only migrations mobile applications experience. Database schemas change. Cached representations change. Encryption strategies change. Authentication tokens change. Offline data can survive many application versions.</p><p>A new release cannot assume that every user starts from a clean installation. Resilient applications treat persistent data as a versioned contract and test transitions from older representations to newer ones.</p><p>An architecture that works perfectly on a freshly installed simulator but cannot safely open data produced three releases earlier is not truly prepared for change. Data migration belongs to architecture because persistence outlives many implementation details around it.</p><h3>Give State an Explicit Owner</h3><p>State ownership follows the same logic. Mobile UI objects are inherently temporary. Screens disappear. Activities can be recreated. Scenes change state. Windows resize. Processes can be suspended or terminated. Cross-platform frameworks add their own widget or component lifecycles on top of those operating-system behaviors.</p><p>Important state should therefore be owned according to its meaning rather than whichever visual object happens to display it at the moment. A partially completed form, checkout operation, authentication state, or long-running workflow may need a lifetime very different from one specific screen instance.</p><p>This does not mean placing all state in one global store. Global state can produce its own coupling problems. The correct question is how long the state logically belongs to the user journey. Some state belongs to a component, some to a screen, some to a feature flow, some to the authenticated session, and some must survive process termination.</p><p>Explicit ownership makes lifecycle changes easier because developers can reason about what is disposable and what must survive.</p><h3>Concurrency Needs Boundaries as Much as Data Does</h3><p>Concurrency is another area where local shortcuts can become future migration problems. Asynchronous code often grows organically. A network request starts inside a screen, triggers another callback, writes directly to storage, updates UI state, sends analytics, and possibly starts additional background work. Cancellation and ownership remain implicit.</p><p>That code may function correctly for years until a framework introduces stricter concurrency guarantees, lifecycle behavior changes, or several operations begin happening simultaneously. Clear asynchronous boundaries, explicit task ownership, structured cancellation, and predictable state transitions make concurrency changes easier regardless of the language or framework used to implement them.</p><p>The goal is not to guess the next concurrency API. It is to avoid building asynchronous behavior that only works because nobody has yet disturbed the timing assumptions hidden inside it.</p><h3>Third-Party SDKs Belong at the Unstable Edge</h3><p>Mobile products commonly depend on analytics platforms, authentication providers, payment SDKs, crash-reporting tools, mapping frameworks, databases, image pipelines, notification services, experimentation platforms, and many smaller libraries. None of those dependencies is guaranteed to exist forever.</p><p>A library can become unmaintained, commercially unsuitable, incompatible with a new platform release, replaced by a native capability, or fundamentally redesigned. The correct response is not to hide every dependency behind several layers of abstraction. It is to prevent external terminology and external types from becoming the internal language of the whole product.</p><p>If every feature directly understands one analytics vendor’s event objects, replacing that vendor becomes an application-wide migration. If features communicate through a small set of product-oriented analytics concepts and one infrastructure component translates those concepts to the current provider, replacement is much more contained.</p><p>The same principle applies to authentication SDKs, payment providers, mapping frameworks, persistence libraries, and platform plugins.</p><h3>Cross-Platform Frameworks Are Dependencies Too</h3><p>Cross-platform frameworks themselves belong to the dependency graph. A Flutter application includes Flutter, its engine, plugins, build tooling, and platform embedders. React Native has its own runtime and native integration architecture. Kotlin Multiplatform creates different boundaries depending on how much code is shared.</p><p>Those frameworks solve real engineering problems, but they also evolve. They introduce their own migration paths, toolchain requirements, architectural transitions, and plugin ecosystems.</p><p>That is not an argument against cross-platform development. It is an argument for treating the framework as architecture rather than magic. Shared code should remain understandable as shared product code. Platform bridges should remain identifiable as platform bridges. Plugin dependencies should have owners. Native projects should not become mysterious generated directories nobody understands.</p><p>When a platform-level issue eventually leaks through an abstraction, somebody still needs to understand where the application meets iOS or Android.</p><h3>Build Systems Are Part of the Architecture</h3><p>Major migrations are often discussed only in terms of source code, but mobile applications are also products of compilers, package managers, build scripts, signing configurations, SDK versions, deployment targets, CI environments, code-generation steps, and distribution requirements.</p><p>Apple can require a newer SDK for submission. Google can raise target API requirements. Cross-platform frameworks can require newer versions of native tooling. A codebase that depends on undocumented local machine configuration is therefore less adaptable even if its application architecture is excellent.</p><p>Reproducible builds, explicit dependency versions, automated validation, and continuously maintained CI pipelines reduce this risk. If the first stage of a platform migration is spending days rediscovering how the project is supposed to build, the system already has an architectural weakness at the delivery level.</p><p>Build knowledge is part of the product and should be maintained with the same seriousness as application code.</p><h3>Avoid Big-Bang Dependency Upgrades</h3><p>An application that stays reasonably close to current framework, language, SDK, and library versions can usually isolate problems one change at a time. An application that waits several years and then simultaneously upgrades its operating-system SDK, compiler, build system, cross-platform framework, database, navigation library, networking stack, and dozens of dependencies creates its own migration crisis.</p><p>Each individual change may be manageable, but their interactions become difficult to diagnose when they arrive together. Continuous modernization is therefore not only about adopting new technology. It reduces the size of each future step.</p><p>The goal is not to upgrade blindly whenever a new version appears. It is to avoid allowing the distance between the application and its surrounding ecosystem to become so large that normal maintenance eventually turns into reconstruction.</p><h3>Warnings Are Early Migration Signals</h3><p>Compiler warnings and deprecation warnings are architectural information, not merely noise in an IDE. Platform vendors often signal transitions before enforcing them. APIs become discouraged before they become unavailable. Lifecycle changes emit warnings before becoming mandatory. Build systems announce upcoming behavior changes. Frameworks deprecate old integration points before removing them.</p><p>A team that regularly investigates those warnings receives time to migrate intentionally. A team that normalizes hundreds of warnings eventually loses that early-warning mechanism because genuinely important signals become indistinguishable from existing noise.</p><p>Keeping a reasonably clean warning baseline is therefore not aesthetic perfectionism. It preserves one of the cheapest sources of information about future migration work.</p><h3>Tests Should Protect Behavior, Not Implementation</h3><p>Testability is one of the most practical consequences of good architecture because software cannot be changed safely when nobody knows whether the change preserved behavior.</p><p>The objective is not to maximize test count. A large suite of tests that mirrors internal implementation can become another source of rigidity. If replacing one repository implementation or restructuring an internal class causes hundreds of tests to fail while externally observable behavior remains identical, the tests are protecting implementation detail more than product value.</p><p>Different boundaries deserve different types of confidence. Business rules can often be tested quickly and independently. Data mappings can be verified against representative responses. Persistence migrations should be tested against older schemas. Infrastructure integrations may require integration tests. Critical user journeys deserve a smaller number of end-to-end tests. Platform-specific behavior needs tests on the platforms where that behavior actually exists.</p><p>Cross-platform applications need both kinds of confidence: shared tests for genuinely shared behavior and platform-focused tests where iOS and Android intentionally differ.</p><p>A healthy test suite also becomes particularly valuable when a new operating-system version changes behavior without requiring source-code changes. Existing expectations can be run against the new environment to reveal which assumptions are no longer valid.</p><h3>Observability Completes the Feedback Loop</h3><p>Compilation and automated testing are not enough to prove compatibility. A migration can compile successfully and pass all tests while still producing a device-specific crash, unexpected memory growth, degraded startup time, or failure in one particular operating-system configuration.</p><p>Crash reporting, structured logging, performance monitoring, release analytics, and carefully designed technical events shorten the distance between a problem appearing in production and the team understanding it.</p><p>Observability should follow the same architectural rules as other infrastructure. Product features can report meaningful events without directly depending on one monitoring vendor. Infrastructure can decide how those events are transported and stored.</p><p>This keeps another external dependency near the edge of the application while still providing visibility into real-world behavior.</p><h3>Performance Can Cross More Than One Layer</h3><p>Platform and framework upgrades can also expose performance assumptions. A screen that performed acceptably under one rendering engine, framework version, or operating-system release may reveal inefficient layout work, excessive rendering, unnecessary state updates, memory pressure, expensive serialization, or excessive platform-channel traffic under another.</p><p>Cross-platform applications make this especially interesting because performance can cross several boundaries. Product logic, framework runtime, rendering engine, native bridge, third-party SDK, and operating system may all participate in a single interaction.</p><p>Abstraction is still valuable, but teams must understand enough about what exists beneath that abstraction to know where profiling should continue when the high-level layer does not explain the problem.</p><p>Architecture should make responsibility discoverable enough that profiling leads toward a component that can actually be changed.</p><h3>Accessibility Benefits From Semantic Architecture</h3><p>Accessibility provides another reason to prefer meaningful components over purely visual implementations. Platform accessibility capabilities evolve alongside UI frameworks. Standard components often gain accessibility behavior, input support, and adaptation automatically, while heavily customized controls require the application to maintain equivalent semantics deliberately.</p><p>This once again exposes the difference between modeling intent and modeling appearance. A component that knows it represents a button, heading, selected state, validation error, adjustable control, or navigation action has semantics that can be communicated to the operating system. A custom object that knows only how to draw pixels requires those semantics to be reconstructed separately.</p><p>The broader architectural lesson is the same: preserve meaning at stable layers and allow rendering details to evolve around it.</p><h3>Feature Flags Should Be Temporary Architecture</h3><p>Feature flags can make platform migrations safer when used intentionally. Significant behavior does not always need to move from old to new in one release. A new navigation path, rendering implementation, platform integration, or replacement service can sometimes coexist temporarily with the existing version.</p><p>A controlled flag allows the new path to be introduced gradually, compared against the previous one, and disabled if unexpected behavior appears.</p><p>The danger comes when migration flags become permanent distributed conditions. Years of nested feature flags across UI, domain, and infrastructure layers can make application behavior extremely difficult to understand.</p><p>A flag should normally have an owner, a reason, and an expected removal path. The architecture should support temporary coexistence without turning temporary decisions into permanent structure.</p><h3>Design for Incremental Migration</h3><p>The ability to migrate incrementally is one of the strongest indicators that a codebase can absorb change. Large rewrites are attractive because they promise an opportunity to remove old compromises. They also discard years of discovered edge cases and introduce a large amount of new behavior at once.</p><p>A resilient architecture should allow old and new implementations to coexist long enough for change to happen gradually. An iOS application can migrate between UI technologies feature by feature. An Android product can move portions of its interface toward newer frameworks without rebuilding the whole application. A Flutter application can replace a plugin or isolate a native integration without restructuring every feature. A cross-platform product can replace one native bridge while the rest of the shared application remains stable. A design system can introduce new components while older screens continue operating.</p><p>Coexistence is not architectural impurity when it is part of a deliberate migration strategy. In many mature products it is the safest path through change.</p><h3>Document Decisions, Not Every Class</h3><p>Documentation helps preserve architecture, but documenting every class rarely provides much value. The most useful architectural documentation explains boundaries and reasons.</p><p>Why does a feature own a particular state? Why is one SDK hidden behind an interface? Why is a certain capability implemented natively rather than through the shared framework? Why is one model separated from another? Why does one module exist? Why was one dependency intentionally allowed to leak while another was isolated?</p><p>Those decisions are difficult to reconstruct years later from code alone.</p><p>Small architecture decision records can therefore be more valuable than enormous diagrams that become obsolete quickly. Future migrations need to understand not only what the system looks like, but why it ended up that way.</p><h3>Readability Is a Migration Tool</h3><p>Major migrations are rarely performed only by the people who originally wrote the affected code. Engineers need to enter unfamiliar areas and understand responsibilities quickly. Clear naming, explicit dependencies, predictable structure, straightforward control flow, meaningful types, and comments that explain non-obvious reasons all reduce the cognitive cost of change.</p><p>This is where clean code genuinely contributes to future adaptability, but not because short functions magically survive the next operating-system release. Human-identifiable code makes change safer because engineers can understand what they are changing.</p><p>A less experienced developer should be able to follow the main flow of a feature without decoding a private architectural language invented by the team. An experienced engineer should be able to identify boundaries and extension points without reverse-engineering hidden global state.</p><p>Complexity cannot always be removed because products themselves can be complex. Accidental complexity should not be mistaken for sophistication.</p><h3>Naming Makes Architecture Visible</h3><p>Names define the mental model of the system. Types named Manager, Helper, Utils, Common, or similarly broad terms often become places where unrelated responsibilities accumulate because their names provide little resistance to additional behavior.</p><p>A type whose name expresses a specific product or technical responsibility tells a developer something before its implementation is opened. Precise naming makes inappropriate additions easier to notice.</p><p>This may seem minor compared with modularization, dependency inversion, or state management, but architecture ultimately lives in everyday code rather than diagrams. Boundaries that cannot be recognized in source code are difficult to protect.</p><h3>Make Dependencies Explicit</h3><p>Dependency injection contributes to the same visibility when used for its real purpose. Its value is not whether a project uses a dependency-injection framework. Its value is that a component’s dependencies are explicit.</p><p>A component whose required collaborators are visible is easier to understand, test, replace, and reason about. A component that silently reaches into global state or platform singletons can depend on almost anything without its public interface revealing that fact.</p><p>Hidden dependencies become especially expensive during migrations because apparently local changes produce unexpected consequences elsewhere.</p><p>The principle is therefore less about injection technology and more about dependency visibility.</p><h3>Do Not Abstract Everything</h3><p>Too much abstraction creates the opposite problem. An application does not become resilient because everything has an interface, every action has a use case, every value has a wrapper, and every dependency has multiple layers between caller and implementation.</p><p>Every abstraction introduces another concept a developer must learn, name, navigate, maintain, and eventually remove.</p><p>A useful boundary usually appears where two sides have meaningful reasons to change independently. The network and product domain usually do. A vendor SDK and business behavior usually do. Platform capability and feature workflow often do. Persistence representation and UI presentation frequently do.</p><p>Two small classes that always change together may not need an elaborate abstraction simply because a diagram says that every dependency should have one.</p><p>Preparing for future change is not about modeling every imaginable future. It is about preventing today’s implementation choices from unnecessarily defining tomorrow’s entire system.</p><h3>The Real Problem With Shortcuts Is Distribution</h3><p>The idea of avoiding shortcuts also deserves precision. Software delivery always contains compromises. A team that refuses every shortcut can overengineer a product that never ships.</p><p>The dangerous shortcuts are not necessarily the smallest pieces of imperfect code. They are the shortcuts that distribute assumptions.</p><p>A hardcoded workaround inside one clearly owned adapter may be ugly but cheap to remove. The same workaround copied into dozens of screens becomes an architectural problem. A temporary platform condition inside one compatibility component may be entirely reasonable. Platform-version checks scattered through business logic create structural debt.</p><p>The location of technical debt is therefore as important as its existence. Local debt is visible and bounded. Distributed debt changes the shape of the system.</p><p>Teams cannot realistically eliminate all debt. They can try to prevent temporary compromises from becoming global assumptions.</p><h3>Separate Compatibility From Adoption</h3><p>Preparing for a new platform release also means distinguishing compatibility from adoption. A new iOS or Android release may introduce attractive APIs, design conventions, or capabilities without requiring the product to immediately redesign itself around them.</p><p>The first responsibility is usually compatibility. The application launches, behaves correctly, preserves user data, meets distribution requirements, and does not regress critical flows.</p><p>Adoption is a separate decision about whether new platform capabilities provide enough product or engineering value to justify implementation.</p><p>Conflating those activities can make migrations unnecessarily risky. Updating lifecycle behavior, redesigning navigation, adopting a new visual language, replacing deprecated APIs, refactoring architecture, and introducing new product features in the same release multiplies the number of possible failure interactions.</p><p>Clear boundaries allow compatibility work to remain separate from optional modernization.</p><p>The same principle applies to cross-platform framework upgrades. Updating Flutter, React Native, or another framework because a new platform requires it should not automatically imply redesigning unrelated application architecture at the same time.</p><h3>Measure the Blast Radius</h3><p>None of these principles can guarantee a small migration. Some platform changes are genuinely significant. Apple or Google can change something fundamental enough that substantial product work becomes necessary. A cross-platform framework can introduce a breaking architectural transition. A security requirement can invalidate assumptions across several layers. A business may intentionally redesign important journeys to take advantage of a new platform capability.</p><p>Architecture does not make those changes disappear.</p><p>What it changes is the blast radius.</p><p>There is a major difference between saying that window-management integration needs to change and discovering that dozens of unrelated features depend on global screen assumptions. There is a difference between updating shared handling for system insets and repairing layout independently across many screens. There is a difference between replacing a plugin behind one capability boundary and discovering plugin-specific objects inside domain models throughout the application. There is a difference between migrating one persistence adapter and discovering that database entities are also the objects used by UI, networking, and business logic.</p><p>The number of changed lines is not the only metric. Predictability matters just as much. A well-structured codebase gives engineers a reasonable expectation of where impact should appear.</p><h3>Ask What Happens When an Assumption Expires</h3><p>A useful architecture review question is not whether the system follows every recognized principle. It is what happens when one assumption becomes false.</p><p>What happens if the application no longer has one predictable window size? What happens if a third-party SDK disappears? What happens if an API representation changes? What happens if a cross-platform plugin no longer supports the newest iOS release? What happens if the application must run in a new hardware configuration? What happens if a database schema changes while users already have years of persisted data? What happens if a framework introduces stricter concurrency rules? What happens if a platform changes navigation or lifecycle requirements?</p><p>If every answer starts with searching the entire repository, the architecture is providing useful feedback.</p><p>There is no need to solve every one of those scenarios in advance. That would lead directly to speculative architecture. The important question is whether the system contains enough meaningful boundaries that a future solution has somewhere sensible to live.</p><h3>Do Not Encode the Present as Permanent</h3><p>This may be the most useful definition of future-ready mobile architecture. It is not architecture that knows the future. It is architecture that minimizes the number of places where the present has been mistaken for something permanent.</p><p>Apple and Google will continue to evolve their platforms. Native frameworks will evolve with them. Cross-platform frameworks will update their abstractions. Hardware will create new layouts and interaction models. Distribution requirements will change. Third-party libraries will disappear. New capabilities will become standard and existing assumptions will become legacy behavior.</p><p>None of that can be prevented at application level.</p><p>What can be controlled is how much of the product depends directly on those temporary realities.</p><p>Business concepts can remain separate from platform mechanisms. Platform behavior can live behind understandable boundaries. Shared cross-platform code can represent product behavior without pretending iOS and Android are identical. Design systems can centralize visual decisions. Data contracts can remain separate from domain concepts. Important state can have deliberate ownership. Dependencies can remain replaceable where replacement is realistically valuable. Builds can remain reproducible. Tests can protect behavior. Observability can expose problems that escape testing. Documentation can preserve the reasoning behind important boundaries. Migrations can happen incrementally instead of requiring rewrites.</p><h3>Architecture Should Make Change Proportional</h3><p>The best preparation for the next major mobile platform release does not begin when its first beta becomes available. It begins much earlier in ordinary engineering decisions.</p><p>Every time a platform-specific assumption is prevented from leaking into unrelated code, the next migration becomes slightly smaller. Every time duplicated behavior is brought behind one meaningful boundary, another future change becomes easier to locate. Every time a dependency is made explicit, another hidden relationship disappears. Every time code expresses product intent instead of an implementation accident, another engineer will be able to understand it more quickly later.</p><p>The goal is not to build software that never needs to change. Healthy software changes constantly because its product, users, technologies, and platforms change around it.</p><p>The goal is to make change proportional to the thing that actually changed.</p><p>A new visual system should mostly be a presentation problem. A new lifecycle model should mostly be a platform-integration problem. A different analytics vendor should mostly be an infrastructure problem. A new business rule should mostly be a domain problem. A new backend representation should mostly be a transport and mapping problem. A new database schema should mostly be a persistence problem.</p><p>When those statements remain approximately true as an application grows, architecture is doing useful work.</p><h3>The Real Meaning of Being Ready</h3><p>There is a real engineering idea behind the claim that a well-built application can be surprisingly ready for a major platform release. The application was not ready because its developers predicted Apple’s or Google’s next move. It was ready because fewer assumptions were allowed to become global assumptions.</p><p>Responsibilities were clearer. Unstable dependencies remained closer to the edges. Platform differences were acknowledged without unnecessarily infecting shared logic. Business behavior was represented independently from the technologies currently used to deliver it. Migrations had identifiable entry points.</p><p>That is a much more realistic objective than future-proofing, and it applies whether a mobile application is built with native technologies, Flutter, React Native, Kotlin Multiplatform, or whatever comes next.</p><p>Frameworks will change. Languages may change. Devices certainly will. Good mobile architecture does not attempt to freeze any of them in place. It makes sure that when they move, they do not have to take the entire application with them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a881fa540302" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[iOS 27 and iPhone Duo: Adapting Apps for Resizable and Foldable iPhone Experiences]]></title>
            <link>https://naggelidis.medium.com/ios-27-and-iphone-duo-adapting-apps-for-resizable-and-foldable-iphone-experiences-cc167f9fbf61?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc167f9fbf61</guid>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ios-development]]></category>
            <category><![CDATA[iphone-duo]]></category>
            <category><![CDATA[adaptive-ui]]></category>
            <category><![CDATA[ios-27]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 21 Sep 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-09-21T14:51:01.450Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*93eSfx8RGzZOtG9teHuk_A.png" /></figure><p>iOS 27 changes an assumption that has existed through most of the history of iPhone development. An iPhone application can no longer treat its interface as one predictable phone-sized rectangle. iPhone applications are now fully resizable in environments such as iPhone Mirroring on Mac and when running on iPad, while iPhone Duo adds an outer display, a much larger inner display, Split View multitasking, partial folding, different control placement, and multiple display capabilities. The important change for developers is therefore larger than supporting one new device. An application needs to respond to the space and environment it currently receives instead of deriving its layout from the type, orientation, or dimensions of the physical device.</p><p>Apple introduced iPhone Duo on September 9, 2026. It has a 5.4 inch outer display and a 7.6 inch inner display, and it will ship with iOS 27.1. Existing applications can run on iPhone Duo without being rebuilt for iOS 27 or iOS 27.1, but that does not provide the complete native experience. An application built with the iOS 27 SDK gains the broader iPhone resizability behavior, while building with the iOS 27.1 SDK allows the application to use the entire Duo display and gives developers access to the new foldable-specific APIs.</p><p>The practical migration path is therefore straightforward. First make the application correctly resizable under iOS 27. Then test it with the iOS 27.1 SDK on iPhone Duo. Only after that should Duo-specific APIs be added where the application actually benefits from them. Most applications do not need to become aware of the hinge, both displays, or the physical pose of the device.</p><h3>Start with the requirements introduced by iOS 27</h3><p>Before looking at the foldable device, there are two platform requirements that existing applications should verify. The first is the launch screen. Starting with applications built using the iOS 27 SDK, App Store Connect requires a valid launch screen configuration in Info.plist. Applications that already have one require no migration, but an application without UILaunchStoryboardName, UILaunchStoryboards, UILaunchScreen, or UILaunchScreens will be rejected when uploaded. New SwiftUI projects normally receive the required configuration automatically through Xcode.</p><p>The second requirement concerns UIKit applications. Apps built with the latest SDK must use the scene-based lifecycle. An application that still depends exclusively on the old UIApplication lifecycle without UIScene support will no longer launch. For older UIKit codebases, adopting UIScene and UISceneDelegate is therefore a requirement rather than an optional modernization task. Scenes are also the correct model for the new environment because the screen and geometry associated with an application can change independently from the physical device.</p><p>These two checks should happen before any Duo-specific development. A project that does not satisfy the iOS 27 application lifecycle and launch requirements is not ready for the newer display behavior regardless of how flexible its individual screens are.</p><h3>Stop using the physical screen as the source of layout information</h3><p>One of the most important audits is any use of UIScreen.main for interface layout. UIScreen.main describes the device’s main screen, but that screen is not necessarily the screen or area containing the current application scene. This becomes particularly important with iPhone Mirroring, iPad windowing, external displays, and a device such as iPhone Duo that contains more than one display.</p><p>The replacement depends on what the code is actually trying to discover. If a view needs to know how much space it has, use the dimensions of that view or its container. If code needs characteristics such as display scale, use the relevant trait collection. If information about the display itself is genuinely required, obtain the screen from the window scene associated with the current window. The important rule is that layout should normally be local to the view hierarchy rather than calculated from a global screen object.</p><p>A simple UIKit example illustrates the difference. Code that calculates a card width from UIScreen.main.bounds.width assumes the card is using the complete physical screen. Instead, Auto Layout should normally determine the width from the containing view. If a calculation genuinely needs a dimension, view.bounds.width describes the space actually available to that view and remains valid when the application is resized.</p><pre>// Fragile in a resizable environment<br>let availableWidth = UIScreen.main.bounds.width</pre><pre>// Based on the space actually available to this view<br>let availableWidth = view.bounds.width</pre><p>The same principle applies to values such as display scale. Apple demonstrates replacing UIScreen.main.scale with traitCollection.displayScale when the value belongs to the current interface environment. The goal is not simply to replace one API with another, but to retrieve information from the object that actually owns the environment being described.</p><h3>Do not use device type to choose a layout</h3><p>Checking whether the current interface idiom is phone or pad has historically been a convenient way to choose between compact and expanded interfaces. With iOS 27, Apple explicitly states that user interface idiom is no longer meaningful for layout decisions. An iPhone application running on an iPad or through iPhone Mirroring can remain under the phone idiom while occupying a much larger resizable area.</p><p>The correct question is no longer whether the application is running as an iPhone application. The correct question is how much space the current interface has. Size classes handle the main distinction, while actual container dimensions can be used when a component requires more precise behavior.</p><p>This applies directly to iPhone Duo. Apple recommends focusing on compact and regular size classes rather than creating layouts for individual device poses or dimensions. The outer display provides a compact width environment, while the inner display provides regular width and height. Developers should avoid fixed breakpoints based on the physical dimensions of either display.</p><p>In SwiftUI, a basic layout can respond to horizontalSizeClass without knowing whether it is running on an ordinary iPhone, iPhone Duo, iPad, or another resizable environment.</p><pre>@Environment(\.horizontalSizeClass) private var horizontalSizeClass</pre><pre>var body: some View {<br>    if horizontalSizeClass == .regular {<br>        ExpandedContentView()<br>    } else {<br>        CompactContentView()<br>    }<br>}</pre><p>The important part is not the syntax. The important part is that ExpandedContentView is selected because the application has enough usable space, not because the code discovered a particular hardware model.</p><h3>Stop using orientation as a layout decision</h3><p>Interface orientation has a similar problem. Historically, many applications used portrait and landscape checks as shorthand for narrow and wide layouts. Apple now explicitly advises developers not to use interface orientation for layout calculations in resizable environments.</p><p>For example, iPhone Mirroring reports portrait interface orientation even when the application window has a wide aspect ratio. On iPhone Duo, the relationship between physical orientation and available application space becomes even less useful because the application may occupy the outer display, the complete inner display, one side of Split View, or a vertically reduced area while video is displayed above it.</p><p>A layout that previously asked whether the interface was landscape should usually ask whether its horizontal size class is regular, or inspect the dimensions of its own container when the exact aspect ratio matters. Orientation can still matter to features where physical orientation is part of the feature itself, but it should no longer be a proxy for layout width.</p><h3>Make layouts truly flexible</h3><p>After removing screen, device type, and orientation assumptions, the next task is to make individual screens resize correctly. This is the foundation of both iOS 27 resizability and iPhone Duo compatibility. Apple explicitly advises developers to design across a continuum of available sizes instead of creating fixed layouts for individual Duo poses.</p><p>For UIKit, this normally means relying on Auto Layout, safe area layout guides, stack views, adaptive container view controllers, and constraints that describe relationships rather than screen-specific coordinates. For SwiftUI, the framework already performs much of this work when views are composed naturally, but fixed frames and geometry calculated from global screen dimensions can still make a SwiftUI application nonadaptive.</p><p>Hardcoded values are not inherently wrong. A button can have a minimum height, a readable text column can have a maximum width, and artwork can maintain an aspect ratio. The problem is a number that silently represents one expected screen. A width of 390 points because a specific design element should never grow beyond 390 points is a valid design constraint. A width of 390 points because the developer assumed that every iPhone screen is approximately that wide is a device assumption and should be removed.</p><p>The easiest way to detect these problems is continuous resizing. A screen should remain usable while gradually moving from narrow to wide and from tall to short. If content works only at a collection of predefined simulator sizes, the application is not yet fully adaptive.</p><h3>Use the larger inner display to expose more information where it helps</h3><p>Correct resizing does not require every interface to change dramatically when iPhone Duo opens. A simple screen that already scales well may need no alternative presentation. Where the information hierarchy benefits from additional space, however, the regular width inner display can show more content simultaneously. Apple specifically recommends patterns such as split views and two-column arrangements for this environment.</p><p>NavigationSplitView in SwiftUI and UISplitViewController in UIKit already adapt across Duo configurations. When the device is closed, their columns can collapse into a single navigation flow. On the larger inner display, the columns can appear together or as overlays depending on the available environment. TabView and UITabBarController similarly adapt across different poses.</p><p>This is preferable to maintaining separate outer-display and inner-display versions of the same feature. The information architecture stays the same while the presentation changes according to available space. A list and its selected detail, for example, can appear sequentially in compact width and simultaneously in regular width without requiring two independent navigation models.</p><p>iOS 27.1 also introduces ArrangementView in SwiftUI and UIArrangementViewController in UIKit. These containers are intended for primary and secondary content that should be rearranged according to size classes, aspect ratio, and active division regions. Apple distinguishes this responsibility from navigation. Navigation describes where the user is in the application, while an arrangement controls how related pieces of the current content are positioned.</p><p>These APIs are useful when an application genuinely has primary and secondary content, but they are not required simply because the application runs on iPhone Duo. Existing adaptive containers should remain the first choice when they already describe the interface correctly.</p><h3>Respect safe areas independently on every side</h3><p>Safe areas require particular attention on iPhone Duo because they can be asymmetric. System controls, the camera, the status bar, and the current multitasking configuration can produce different insets on the leading, trailing, top, and bottom sides. Code should therefore never assume that opposite safe area values are equal.</p><p>Foreground content that must remain visible or interactive should normally stay inside the safe area. In SwiftUI this behavior is provided by default unless the application deliberately ignores the safe area. In UIKit, manually positioned content should use safeAreaLayoutGuide or the relevant safe area insets. Background artwork and other noninteractive visual content can extend beyond the safe area when an edge-to-edge design requires it.</p><p>This distinction becomes particularly useful on Duo. A full-width image can continue behind system controls while the text and buttons placed over it remain inside the safe region. This preserves an edge-to-edge visual result without making controls difficult to reach or placing important content underneath hardware and system UI.</p><p>Layout margins can also be asymmetric, so code that manually mirrors leading and trailing values should be reviewed. The system can intentionally provide different margins to make better use of the space surrounding vertical controls.</p><h3>Prefer system navigation and bars</h3><p>iPhone Duo changes the placement of system controls. On several Duo configurations, navigation, toolbar, and tab bar content can move from horizontal bars at the top or bottom of the screen into a vertical region along the side. This preserves vertical space and keeps controls away from the folding region. On the open inner display in portrait, horizontal bars remain appropriate and the system uses them.</p><p>Applications using standard containers receive this adaptation from the system. In SwiftUI, Apple recommends using bars through containers such as NavigationStack, NavigationSplitView, and TabView. In UIKit, UINavigationController and UITabBarController should manage their respective bars. Creating independent UIToolbar, UINavigationBar, or UITabBar instances as custom bars does not provide the same automatic behavior.</p><p>Existing toolbar content should also be reviewed. Vertical bars have limited width, so symbol-based controls fit more naturally than wide custom controls. Apple still recommends providing titles for actions because those titles can be used when an action moves into an overflow menu or another representation. Text-only items and controls that do not make sense vertically can remain in a horizontal representation.</p><p>The system also manages overflow when there is not enough vertical room for every control. The development task is therefore not to reproduce Apple’s vertical bar manually. It is to ensure that actions are expressed through the appropriate system containers, that important actions are prioritized correctly, and that custom toolbar content remains usable in both horizontal and vertical arrangements.</p><h3>Custom bars and edge-to-edge interfaces need additional care</h3><p>Applications with highly customized interfaces have more work because they cannot rely entirely on standard navigation and safe area behavior. iOS 27.1 introduces reserved region APIs for this purpose. SwiftUI exposes ReservedRegion, while UIKit exposes UIViewReservedRegion and APIs for querying reserved regions associated with a view.</p><p>Reserved regions describe parts of the available area that another element occupies or that content should account for. They allow custom UI to use more of the screen without manually encoding the location of system controls or the folding region. This is particularly relevant for custom bars, immersive interfaces, and edge-to-edge layouts where simply keeping everything inside the safe area would waste useful space.</p><p>The important rule is that custom layout should consume information provided by the system. It should not calculate where the hinge, camera, or system bar is expected to appear from known Duo dimensions. That would immediately couple the implementation to one hardware configuration.</p><h3>Treat the fold as layout information, not as a device coordinate</h3><p>When iPhone Duo is partially folded, the curved central area affects how content should be positioned. Apple’s system components automatically move interactive content away from this region when appropriate. Scrollable content can continue through the folding area, while controls and other important foreground elements should generally remain away from it.</p><p>For custom layouts, reserved regions and arrangement APIs provide the appropriate way to respond to this geometry. A division region can describe the area created by the fold and allow content to be arranged around it. The application therefore reacts to a region reported by the layout system instead of trying to determine a hinge position itself.</p><p>This distinction also avoids unnecessary device-specific logic. The layout does not need to ask whether the current hardware is iPhone Duo and then calculate the center of its inner display. It receives the environmental information that matters and responds to it.</p><h3>Do not use the hinge API for ordinary layout</h3><p>iOS 27.1 also provides explicit hinge information. SwiftUI applications can observe it with onHingeChange, while UIKit provides UIHingeInteraction. These APIs report hinge availability, status such as closed, partially open, and fully open, and continuous angle changes.</p><p>Apple makes an important distinction about their intended purpose. Hinge information is appropriate when the physical movement itself drives an interaction or effect. Apple’s example uses hinge angle to control an interactive audio effect. For normal interface layout, Apple recommends the arrangement and region APIs instead.</p><p>This means most applications should not observe hinge angle simply to move buttons away from the fold. The layout system already exposes better abstractions for that problem. Hinge APIs should be introduced only when the physical folding motion is meaningful to the feature being implemented.</p><h3>Split View makes arbitrary resizing part of normal iPhone behavior</h3><p>All applications participate in side-by-side multitasking on iPhone Duo. Two applications can share the open inner display in a 50/50 Split View arrangement, so even an application that normally receives the large regular-width inner display must also function correctly when its available width is reduced.</p><p>The correct response is the same adaptive behavior used elsewhere. A multi-column interface can collapse when the horizontal size class changes. Content should reflow instead of being clipped. Navigation should remain valid. System bars adapt to the side of the portion of the display occupied by the application.</p><p>The same principle applies vertically. iPhone Duo can place Picture in Picture video above an application and resize the application into the remaining area. When the device is partially folded, video can occupy one portion of the display while the application uses another. Apps therefore need to tolerate substantial changes in both width and height rather than treating responsiveness as only a horizontal problem.</p><p>A practical test for a junior developer is to stop thinking in terms of a collection of device screenshots. Start the application in the simulator, resize it continuously, and watch the transitions. Look for clipped labels, buttons leaving the visible area, constraints breaking, unexpected empty regions, views that overlap, and screens that rebuild unnecessarily when their size changes. These problems reveal assumptions that often remain hidden when testing only fixed device presets.</p><h3>Preserve application state when presentation changes</h3><p>Opening the device, closing it, entering Split View, or resizing a mirrored window changes the presentation environment. It does not represent a new business operation. The selected item, entered form data, playback position, navigation destination, and other application state should therefore not be recreated merely because the layout changed.</p><p>This is particularly important when compact and regular interfaces use different containers. If a compact view and an expanded view represent the same feature, they should normally render the same underlying state rather than each maintaining an unrelated copy. Otherwise moving between layouts can cause selections, forms, or navigation to reset.</p><p>For a junior developer, a useful mental model is that size class and geometry describe presentation state. They should decide how information is shown, not what the application’s underlying data currently is. Keeping that boundary clear makes adaptive interfaces considerably easier to reason about.</p><h3>Review UIRequiresFullScreen rather than using it as a compatibility shortcut</h3><p>UIRequiresFullScreen should not be used as a way to avoid making an application adaptive. Apple has been moving applications toward resizable scenes, and for ordinary applications the correct solution is to support dynamic resizing. Apple’s migration guidance for resizable scenes also recommends removing UIRequiresFullScreen when the application is ready to participate fully in resizable environments.</p><p>There are legitimate cases, particularly games, where full-screen behavior is part of the application’s rendering model. iOS 27 continues to provide specific behavior for these applications. On iPhone Duo, however, UIRequiresFullScreen does not prevent the application from changing size when the device itself opens or closes. Developers should therefore treat it as a specialized application capability rather than a method of preserving assumptions about a fixed screen.</p><h3>Multiple windows are supported, but most apps do not need to add them</h3><p>iPhone Duo is the first iPhone that supports multiple instances of an application’s UI. Applications that already support multiple scenes on iPad can also use that capability on Duo. There is one important difference. A new window can be created while using the inner display, but not while the application is on the outer display.</p><p>Applications that request additional scenes therefore need to handle the request failing when another scene cannot currently be created. Apple provides UIWindowSceneActivationAction for actions that request another window, and the system can automatically make that action unavailable when creating another scene is not possible.</p><p>This is feature-specific work. An application does not need to add multiple-window support simply to be compatible with iPhone Duo. If the product has no meaningful reason to open multiple instances of its interface, supporting resizing and the normal single-scene experience is sufficient.</p><h3>Using both displays is also feature-specific</h3><p>iPhone Duo can support experiences that use more than one display at the same time. Apple provides scene accessories for presenting supplementary content alongside the application’s main scene. An example is using the outer display to show information while the primary application interface remains on the inner display.</p><p>This capability should only be adopted when a feature genuinely benefits from a second display. Most applications do not need to create a secondary interface just because the hardware provides one. The baseline compatibility work remains flexible layout, correct scene handling, safe areas, system navigation, and resizing.</p><p>This distinction matters because it keeps the migration proportional. Developers can make an application fully compatible with iPhone Duo without implementing every capability unique to the hardware.</p><h3>Camera applications need a separate audit</h3><p>Applications that directly manage camera capture have additional work because iPhone Duo contains cameras associated with its different displays. Apple provides a virtual front camera that can automatically adapt as the device configuration changes. For many camera features, using that virtual camera is the simplest way to obtain appropriate front-facing behavior.</p><p>Applications that need direct control over individual cameras can access them separately and use AVCaptureDeviceDirectionCoordinator to understand which physical cameras are currently facing toward or away from the user relative to a view. This is necessary because a fixed idea of a permanently front-facing physical camera is less useful on hardware that can open, close, and change which display is facing the user.</p><p>Camera applications should also use the appropriate rotation coordinator so previews and captured output remain correctly oriented when the application moves between displays. Apple’s guidance specifically recommends adopting the rotation coordinator and testing preview aspect ratios and orientation on iPhone Duo.</p><p>Applications that do not directly manage camera capture do not need these APIs. This is another area where Duo compatibility should not be confused with adopting every new device capability.</p><h3>Test system presentations instead of rebuilding them</h3><p>Sheets, popovers, context menus, and alerts adapt to the different Duo configurations when developers use the standard presentation APIs. Sheets can position themselves differently between the outer and inner displays and can move away from the fold when required.</p><p>The correct development task is therefore mainly verification. Open existing sheets and menus in the different simulator configurations and check that custom content inside them still fits. If the application has replaced standard presentations with manually positioned overlays, those custom implementations need a deeper safe area and reserved region audit.</p><p>This follows the same pattern as navigation bars. The more system behavior an application uses, the more adaptation it receives automatically. Highly customized interfaces remain possible, but the application becomes responsible for respecting the same environmental information that the system components already understand.</p><h3>Test with Xcode instead of guessing about the hardware</h3><p>Xcode 27 adds resizable previews and Device Hub support for testing iPhone applications across changing dimensions. Xcode 27.1 adds iPhone Duo simulator support, including the ability to open, close, rotate, and fold the simulated device. At the time of writing, iPhone Duo development support is available through Xcode 27.1 beta.</p><p>A useful validation session should exercise the application continuously rather than checking only one screenshot for each configuration. Test the closed outer display, the open inner display, different orientations, partial folding, Split View on both sides, and vertically reduced layouts. Resize while navigation, forms, sheets, media, and other stateful interfaces are active rather than testing only their initial state.</p><p>Also test larger Dynamic Type settings and longer localized strings while the application is constrained. These are not Duo-specific features, but they often expose the same incorrect assumption, that the interface has more room than it actually does. An interface that adapts correctly should respond to both environmental resizing and content that requires additional space.</p><p>Xcode 27.1 also includes Apple’s App Resizability skill, which can help identify common problems in SwiftUI and UIKit projects. It can assist with migration work, but it does not replace reviewing the resulting interface. Decisions about information hierarchy, custom controls, navigation, and how additional space should be used remain application design decisions.</p><h3>Avoid doing expensive work because the window changed size</h3><p>Resizing can happen repeatedly while a user adjusts a mirrored window, changes multitasking configuration, or physically opens and folds iPhone Duo. Layout updates should therefore remain layout operations. A geometry change should not automatically trigger network requests, recreate application models, reload data, or perform other expensive work unrelated to presentation.</p><p>In SwiftUI, pay attention to state changes driven by geometry because unnecessary state mutation can cause large sections of the hierarchy to be recomputed. In UIKit, avoid invalidating or reconstructing more of the view hierarchy than the size change requires. The application should be able to move smoothly between sizes without treating each change as if the feature had restarted.</p><p>This is another reason to keep data and presentation state separate. When layout logic only decides how existing state should be displayed, continuous resizing becomes much simpler and more predictable.</p><h3>What actually needs to change in an existing app</h3><p>For most applications, the migration does not require a dedicated iPhone Duo architecture. The essential work is to build against the current SDK, verify the launch screen, use the scene-based lifecycle where UIKit requires it, remove screen-dependent layout calculations, replace interface idiom and orientation-based layout decisions with size classes or local geometry, make screens freely resizable, respect asymmetric safe areas, and use adaptive system navigation and presentation components. Those changes form the baseline for iOS 27 and iPhone Duo.</p><p>The next layer applies only to applications with more specialized interfaces. Custom edge-to-edge layouts may need reserved regions. Interfaces with related primary and secondary content may benefit from ArrangementView or UIArrangementViewController. Apps whose features react directly to the physical fold can use hinge APIs. Multiwindow applications need to account for dynamic scene availability. Experiences that genuinely benefit from both displays can adopt scene accessories, and camera applications that directly control capture need to review the new camera behavior.</p><p>That distinction prevents unnecessary complexity. A normal application does not need hinge-angle code, camera direction handling, second-display scenes, or a custom Duo layout to claim compatibility. It needs an interface that responds correctly to the environment the system gives it.</p><h3>A useful way to review an existing codebase</h3><p>For a developer approaching an existing project, the most productive starting point is to search for assumptions rather than for Duo-specific code to add. UIScreen.main used for layout deserves inspection. So do checks against userInterfaceIdiom, interface orientation, device models, fixed screen widths, manually mirrored safe area values, custom navigation bars, fixed-size containers, and UIKit code that has not adopted UIScene. Each result should be reviewed according to what information the code really needs.</p><p>Imagine a product screen containing a list and a detail page. On a traditional compact iPhone interface, selecting an item pushes the detail page. When regular width becomes available, the same feature can use NavigationSplitView or UISplitViewController to keep the list and detail visible together. When Split View reduces the available width again, the system can collapse the interface back to the compact navigation flow. The selected item remains application state throughout the transition. Nothing in that implementation needs to ask whether the current device is iPhone Duo.</p><p>That example captures the broader migration better than a collection of foldable-specific conditions. The application describes what it needs from the available space, system containers adapt where possible, and custom code only handles the cases where the application’s own design requires more control.</p><h3>The goal is not an iPhone Duo version of the app</h3><p>The most maintainable iOS 27 application should contain surprisingly little code that explicitly knows about iPhone Duo. Most of the work belongs in generic adaptivity, scene handling, navigation, safe areas, and flexible layout. The new Duo-specific APIs exist for the parts of an application that genuinely interact with the new hardware capabilities, not as replacements for those foundations.</p><p>That is also why this migration is useful beyond one device generation. iOS 27 makes iPhone application size increasingly dynamic even without iPhone Duo. A window mirrored to a Mac, an iPhone application running on iPad, Split View on Duo, and the inner and outer Duo displays all expose the same architectural mistake when code assumes that device identity determines application geometry.</p><p>The practical target is therefore simple. Build an application that knows the space it currently has, uses the system environment instead of guessing about the hardware, preserves its state when that space changes, and introduces hardware-specific behavior only when the feature actually requires it.</p><p>If that foundation is correct, supporting iPhone Duo stops being a separate version of the application. It becomes another environment that the same application is already designed to handle.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=cc167f9fbf61" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Forgotten Art of UX, Designing for Usefulness from the Start]]></title>
            <link>https://naggelidis.medium.com/the-forgotten-art-of-ux-designing-for-usefulness-from-the-start-1aeb99c9d755?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/1aeb99c9d755</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 14 Sep 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-09-14T14:51:01.384Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CHp31lPKhQwMAng5uzWGGQ.png" /></figure><p>User experience is often discussed too late. A feature is defined, requirements are written, technical constraints are understood, screens are designed and then UX is asked to validate whether everything works well for the user. At that point, many of the decisions that shape the experience have already been made. The stronger approach is the opposite. UX should be involved while the problem is still being defined, before the solution has hardened into screens, flows and implementation tasks.</p><p>This matters because UX is not mainly about improving an interface after the product decision has been made. Its deeper purpose is to help determine whether the proposed product or feature actually serves the person who will use it. The first UX questions should therefore appear during planning. What is the user trying to achieve. Why do they need this feature. What is difficult about the current experience. What knowledge can we reasonably expect them to have. What information do they need from us. What information do we genuinely need from them. What could make the task shorter, clearer or safer.</p><p>These questions can influence the shape of the feature itself. A team may initially imagine that a new capability requires several screens, additional navigation and a detailed form. Looking at the same problem from the user’s perspective may reveal that most of the information already exists, that a decision can be automated, that the action belongs somewhere users already expect to find it or that the problem can be solved without introducing a new flow at all. UX therefore creates value before the first interface exists.</p><p>This is an important distinction because the interface is only the visible layer of the experience. A beautifully designed screen can still represent a poor solution. A perfectly accessible button can still lead to an unnecessary step. A technically correct flow can still force someone to understand terminology that only makes sense inside the organisation. A product can satisfy every platform guideline and still make a simple task unnecessarily difficult.</p><p>The basic test is much simpler. Can the person achieve what they came to achieve, with reasonable effort and a clear understanding of what is happening.</p><p>That question should influence planning, product decisions, design and engineering from the beginning.</p><p>UX input is particularly valuable during early product discussions because it challenges assumptions before they become expensive. Requirements often describe what a system should do, but they do not always describe what the person using the system actually needs. These are related questions, but they are not identical. A requirement may be logically correct and still produce unnecessary steps. A business rule may be valid but exposed to the user in a confusing way. A feature may solve an internal process without solving the user’s problem.</p><p>Bringing UX into the conversation early creates another perspective before those assumptions become architecture, APIs, tickets and completed screens. The goal is not to give UX ownership over every decision. It is to make user impact one of the inputs used to make the decision.</p><p>This is also why UX should not be treated as a phase that happens between product and engineering. Product, design and engineering all create the final experience. A product decision determines what the user has to do. A design decision determines how the task is presented. An engineering decision determines how quickly the application responds, how state is preserved, how failures behave and what happens under conditions that may never appear in a design file. These decisions are different, but users experience them as one product.</p><p>Early collaboration matters because problems become more expensive as the implementation progresses. Changing the wording of a label late in development is usually easy. Discovering that the whole interaction model is wrong is not. That may require redesigning the flow, changing business logic, modifying APIs, rebuilding analytics and retesting a significant part of the feature. Asking UX questions during planning is therefore not only better for users. It can prevent expensive rework.</p><p>Accessibility makes this problem especially visible. Modern platforms provide strong accessibility standards, APIs and validation tools. They help teams support screen readers, dynamic text, sufficient contrast, appropriate touch targets, semantic elements and many other important requirements. These capabilities are essential, but accessibility becomes unnecessarily limited when it is treated primarily as something that needs to be checked near release.</p><p>If a process requires twelve steps when it could reasonably require four, making all twelve screens technically accessible does not address the deeper problem. If the application uses language that users cannot understand, adding perfect accessibility labels does not make the underlying concepts clearer. If important actions are difficult to discover, improving their contrast does not solve the information architecture.</p><p>Accessibility works best when it influences design from the beginning for the same reason that UX does. It asks teams to consider how different people will actually interact with the product before the structure becomes fixed.</p><p>Real users also do not operate software under ideal conditions. They may be distracted, moving, using one hand, working with poor connectivity, using a smaller or older device, increasing system text size or returning to an interrupted task later. They may know very little about the system behind the interface. In some situations they may also be stressed, uncertain or trying to complete something quickly.</p><p>These conditions should influence planning because they change what a good experience looks like. Progress should survive interruption where appropriate. Important actions should be understandable without requiring knowledge from previous screens. Destructive operations should be difficult to trigger accidentally. Forms should avoid requesting information the system already has. The state of an operation should be clear. Error recovery should be designed, not improvised later.</p><p>The unhappy path deserves the same attention as the successful one. Many specifications naturally describe the expected flow. Open the screen, enter valid information, continue and receive confirmation. Actual products spend significant time outside that path. Networks fail, services become unavailable, authentication expires, information is incomplete, users deny permissions, they press back, they leave halfway through or simply make mistakes.</p><p>These are not technical edge cases from the user’s perspective. They are experiences.</p><p>A useful error state should help someone understand what happened, what was preserved and what they can do next. A generic failure message with a Try Again button may technically handle an error while providing almost no useful information. Empty states, loading states, interrupted flows, permission requests and partial completion should therefore be discussed during UX planning rather than added after the happy path is complete.</p><p>Performance belongs in the same conversation. Users do not distinguish between backend latency, network latency, rendering time and architectural decisions. They experience waiting. If an action gives no feedback, they may press it twice. If content constantly moves as data loads, the interface becomes difficult to follow. If an operation appears frozen, the user does not know whether it is still running.</p><p>This means technical performance and perceived performance both affect UX. Some operations genuinely take time, and good design does not hide that fact. It makes the application’s state understandable, responds quickly where possible and gives users enough feedback to know what is happening.</p><p>Language is another area that should be considered early. Organisations naturally develop internal vocabulary for products, processes and account structures. That language may be perfectly understood by the people building the software and completely unfamiliar to the people using it. When internal terminology appears directly in the interface, organisational complexity becomes user complexity.</p><p>Good UX therefore requires more than correct wording. It requires concepts that match the user’s mental model. Labels should help people predict what an action does. Confirmations should remove uncertainty. Errors should explain what matters without exposing irrelevant technical detail. Navigation should be organised around where users expect to find something, rather than around how internal systems happen to be structured.</p><p>The same principle applies to feature complexity. Software teams naturally think about adding capability, but every additional option introduces another decision for the user. Every screen, setting and branch in a flow creates something that needs to be understood. Complex products are sometimes necessary, but there is an important difference between complexity that comes from the real problem and complexity introduced by our solution.</p><p>UX should help identify that difference before unnecessary complexity becomes part of the product.</p><p>This is where early UX involvement has perhaps its greatest value. It can challenge not only how a feature should work, but whether every proposed part of the feature needs to exist. Sometimes the best UX improvement is a better layout. Sometimes it is a shorter flow. Sometimes it is better wording. Sometimes it is removing an action, using a sensible default, reusing information the system already knows or solving the problem before the user ever reaches the screen.</p><p>The implementation stage still matters because designs cannot represent every real condition. Content lengths change. Data can be missing. Device sizes differ. Accessibility settings affect layouts. Requests fail. State changes while the application is open. Engineering therefore continues the UX work rather than simply translating a finished design into code.</p><p>The useful mindset is not that design defines UX and engineering implements it. The entire product lifecycle creates UX.</p><p>This also changes how features should be reviewed. Acceptance criteria are necessary, but they usually verify behaviour in isolated pieces. Users experience a complete journey. A feature can satisfy every criterion and still feel confusing when used from beginning to end.</p><p>One useful review method is to use the feature with as little internal knowledge as possible. Start where a normal user would start. Follow only what the interface communicates. Enter something incorrectly. Interrupt the process. Return later. Go backwards. Try the task under a slower connection or with accessibility settings enabled. The goal is not simply to prove that the implementation behaves according to the specification. It is to discover what knowledge and effort the product expects from the user.</p><p>Success metrics should follow the same principle. Screen views, clicks and time spent in an application can provide useful information, but they do not automatically represent good UX. For many transactional products, longer time spent may mean that users are struggling. A person who enters an application, completes their task correctly in thirty seconds and leaves may have received far more value than someone who spends ten minutes navigating through it.</p><p>Useful UX metrics therefore focus on outcomes. Task completion, abandonment, repeated attempts, error frequency, recovery after failure, time needed to complete important flows and support requests can reveal whether the experience is actually helping users achieve their goals.</p><p>AI now gives teams another useful tool for bringing this kind of thinking earlier into the process. Its value in UX is not limited to generating interfaces or writing copy. Used properly, it can help teams explore the problem before they commit to a solution.</p><p>During planning, AI can act as a structured challenge to assumptions. A team can describe a proposed feature, the target user, known constraints and the intended outcome, then ask for possible friction points, missing scenarios, accessibility risks, confusing terminology or assumptions that should be validated. It can generate alternative user journeys, compare simpler and more complex flows and identify questions that may have been overlooked.</p><p>This does not replace UX research or professional judgement. AI does not know the real user simply because we describe one in a prompt. It can reproduce incorrect assumptions if those assumptions are present in the input. Its value is in expanding the space of questions a team considers, not in declaring what users need.</p><p>It can also help synthesise real UX inputs more effectively. Interview notes, usability findings, support feedback, survey responses and analytics observations can contain recurring patterns that are difficult to spot when they are spread across many sources. AI can help group those patterns, identify repeated problems and turn unstructured feedback into areas worth investigating. The underlying evidence still needs to come from real users and real behaviour, but the cost of working through that evidence can be reduced significantly.</p><p>AI can be useful for scenario generation too. Given a planned flow, it can help teams think through different user conditions, such as limited technical knowledge, large accessibility text, poor connectivity, interrupted sessions, missing data or repeated actions. These generated scenarios can then be reviewed by designers, engineers, product managers and QA before implementation begins.</p><p>That makes AI particularly valuable as an early planning tool. Instead of using it only after a design exists, teams can use it to question the design before it exists.</p><p>AI can also lower the cost of exploring alternatives. A team can compare several versions of a flow, analyse the tradeoffs, generate rough prototypes or draft different information architectures much earlier than before. This makes experimentation cheaper, which should make it easier to discard weak ideas before they become expensive implementations.</p><p>The important limitation is that AI should support evidence, not replace it. A generated persona is not a user interview. A predicted usability problem is not a usability test. A model’s preferred flow is not proof that real users will understand it. The strongest workflow is therefore to use AI to broaden thinking, generate hypotheses, analyse available evidence and accelerate iteration, then validate important assumptions with actual user research, product data and testing.</p><p>Used this way, AI fits naturally into good UX practice because both are most valuable before decisions become difficult to change.</p><p>The core principle remains simple. UX should not be the final check that asks whether a finished feature is acceptable. It should be one of the inputs that helps decide what the feature should become in the first place.</p><p>That means involving UX when the problem is being framed, asking for UX input when requirements are still flexible, considering accessibility and real-world usage before screens are finalised, involving engineering while solutions are still being explored and using tools such as AI to challenge assumptions and expose overlooked scenarios early.</p><p>The purpose is not to add another process around product development. It is to avoid building unnecessary complexity and trying to improve it afterwards.</p><p>A product can satisfy requirements, follow a design system, pass accessibility checks and still fail the person using it. The stronger measure is whether we understood what that person was trying to achieve and shaped the product around helping them achieve it with as little unnecessary effort as possible.</p><p>That is the part of UX worth remembering. It starts before the first screen, continues through every product and engineering decision and ends only when the user has successfully achieved the outcome they came for.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1aeb99c9d755" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Bridging Product and Engineering: Turning Real Problems Into Buildable Solutions]]></title>
            <link>https://naggelidis.medium.com/bridging-product-and-engineering-turning-real-problems-into-buildable-solutions-8ff450e6a131?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/8ff450e6a131</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[engineering-leadership]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[business-analysis]]></category>
            <category><![CDATA[product-management]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 07 Sep 2026 14:51:00 GMT</pubDate>
            <atom:updated>2026-09-07T14:51:00.822Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SNj5XF-v22QGcOErxH_LKQ.png" /></figure><h3>When the Wrong Problem Reaches Implementation</h3><p>A lot of software does not fail because the code was impossible to write. It fails because the wrong problem reached implementation with too much confidence. The team shipped what was requested, but not what was actually needed.</p><p>Recently, I have met several people whose daily work sits somewhere between business reality and technical execution. Their role is not always to build the solution themselves, but to understand the need, clarify the problem, and help translate it into something the people building it can actually use. That reminded me of one of the most important gaps in software delivery. Business problems and technical solutions do not naturally speak the same language.</p><h3>The Gap Between Business Pressure and Engineering Precision</h3><p>This gap exists in almost every product environment. On one side, there are people who understand business pressure. They know what customers complain about, where operations are slow, where money is lost, where reporting is unclear, where compliance matters, or where management expects a better process. On the other side, there are engineers who need precision. They need flows, data, rules, edge cases, dependencies, API contracts, permissions, failure states, technical constraints, and acceptance criteria.</p><p>That is where misunderstandings begin. A stakeholder may say that a process needs to become faster. An engineer needs to understand what faster means. Fewer clicks, less waiting time, fewer manual checks, better automation, simpler navigation, faster system response, fewer approval steps, or something else entirely. A request may sound small, while the implementation may touch permissions, backend logic, UI states, analytics, testing, release planning, and support documentation.</p><p>The problem is not that one side is wrong. The problem is that each side sees a different layer of reality. Business sees outcomes. Engineering sees systems. Product sees user value. Design sees experience. QA sees risks and edge cases. Support sees repeated pain. Management sees cost, timing, and direction. A good solution usually needs all of these perspectives, but someone has to connect them before they turn into separate assumptions.</p><h3>Why Clarity Must Happen Before Development</h3><p>One dangerous moment in a project is when everyone thinks the requirement is clear, but nobody has checked if they actually mean the same thing. The ticket exists. The meeting happened. The decision was written somewhere. The team starts implementation. Then one question changes the understanding of the whole feature. Maybe the rule is different for one user type. Maybe the data is not always available. Maybe the backend cannot support the expected behavior. Maybe the design covers only the happy path. Maybe an exception was obvious to one person, but never mentioned to the team.</p><p>That is why the translation layer between product and engineering matters. It is not only a job title. It can be handled by different people depending on the team, the product, and the situation. Sometimes it is a product manager. Sometimes it is a business analyst. Sometimes it is a tech lead, a senior engineer, a designer, a QA engineer, or a combination of people. The important thing is not who owns the title. The important thing is that the translation actually happens.</p><p>Turning a real problem into a buildable solution means moving from vague need to shared understanding. It means taking a sentence like, we need to improve this process, and breaking it down into what the user is trying to achieve, what is not working today, what success looks like, which users are affected, what data is needed, which systems are involved, what can fail, and how we will know that the solution works after release.</p><h3>The Technical Value of Asking Better Questions</h3><p>This is where technical teams create value before writing code. A senior engineer or technical lead should not only ask, how do we implement this. They should also ask, are we solving the right problem. Sometimes the implementation is clear, but the problem is not. Sometimes the problem is clear, but the proposed solution is too narrow. Sometimes the solution works for the happy path, but fails for real users. Sometimes the best technical contribution is not another abstraction, but one good question at the right time.</p><p>For example, when someone asks for a new button, the first question should not always be where to place the button or which API to call. The better question may be why the button is needed. Is the user missing an action. Is the current flow hidden. Is the process too slow. Is the system missing automation. Is the business trying to reduce support effort. Is the button solving the problem, or is it just adding another manual step to a process that is already too complicated. The answer may still be a button, but now the team understands the reason behind it.</p><h3>How Different Roles See the Same Problem</h3><p>Role-specific examples make this more concrete. A stakeholder may say, we need better visibility. What they may actually mean is that decisions are delayed because important information is hidden across tools, reports, or manual communication. A product manager may translate that into a dashboard, a status indicator, or a notification. An engineer then needs to understand what data exists, where it comes from, how fresh it is, who is allowed to see it, what happens when it is missing, and how expensive it is to calculate or display.</p><p>A designer may hear the same problem and focus on experience. Where should the information appear. How much detail is useful. What should be visible immediately, and what should stay behind an extra action. How should the interface behave when the state is loading, empty, incomplete, or blocked. These questions are not decoration. They affect whether the solution actually reduces confusion or simply adds more information to an already noisy flow.</p><p>A QA engineer may look at the same request and see risk. What happens if the data is wrong. What happens if two systems disagree. What happens if the user has partial permissions. What happens if the feature works for one user type but not another. What happens if the process starts on one device and continues somewhere else. These are not secondary details. They are often where real production problems appear.</p><p>Support and operations can bring another kind of truth. They often know where users struggle repeatedly, which workarounds are common, which errors create confusion, and which questions appear again and again. This feedback can prevent teams from solving a clean theoretical problem while missing the messy real one.</p><p>Engineering brings a different lens. Engineers need to understand not only what should happen, but also how stable, maintainable, and observable the solution will be. Is this a one-time rule or the beginning of a rule system. Is this logic client-side, server-side, or shared. Does it need analytics. Does it need monitoring. Can it fail silently. Can it be rolled back safely. What will happen when the requirement changes in three months.</p><h3>Timing Matters More Than It Looks</h3><p>This collaboration has the most value when it happens early. Not after the feature is already derailed. Not after the estimate has already proven wrong. Not after development has started and every clarification becomes rework. The right time to connect product and engineering is before estimates become commitments, before tickets are split into tasks, before design is treated as final, and before the team starts building from assumptions.</p><p>This is not about blocking delivery with endless analysis. It is about reducing avoidable rework. Fast implementation of unclear requirements often creates the illusion of speed. The team moves quickly at the beginning, but later pays the cost through clarifications, bugs, redesigns, inconsistent behavior, and frustrated users. A little more clarity early can save much more time later.</p><h3>A Practical Framework Before Implementation</h3><p>A practical way to bridge the gap is to use one simple framework before implementation starts. First, clarify the problem. Second, define success. Third, expose assumptions. Fourth, shape the solution. Fifth, validate after release. This does not need to become a heavy process. It is a disciplined way to stop vague requests from becoming expensive code.</p><p>Imagine a rough request like, we need to make this approval process faster. The first step is not to create implementation tasks. The first step is to clarify the problem. Who is waiting too long. Where does the delay happen. Is the friction caused by missing information, manual checks, unclear ownership, slow system response, or unnecessary approval steps. Without this step, faster can mean five different things to five different people.</p><p>Once the problem is clearer, it should become a simple problem statement. For example, users lose time because they need to manually check three different places before approving a request. This gives the team something concrete to solve. Success can then be defined in practical terms, such as fewer manual checks, shorter completion time, fewer support questions, or better visibility into missing data.</p><p>The next step is to expose assumptions and map the flow. What data is needed. Which systems are involved. Which user roles are affected. What happens when data is missing, outdated, or conflicting. What can fail. These questions reveal the real shape of the work before engineering commits to a solution.</p><p>From that understanding, acceptance criteria, test scenarios, and implementation tasks become much stronger. The ticket should describe the chosen solution, the important assumptions, the main states, the edge cases, what is out of scope, and how success will be checked after release. It does not need to be a huge document. It just needs to be clear enough so that the team is not building from guesses.</p><p>Only then should the team compare solution options. The answer may not be a new button. It may be a clearer status, a pre-check, an automated validation, a better error message, or a smaller change in the flow. A good decision compares user value, implementation cost, delivery risk, maintenance cost, and future flexibility, instead of relying on seniority, preference, or whoever sounds most confident.</p><h3>Where AI Helps and Where It Does Not</h3><p>Modern AI tools can support this workflow very well. AI should not be treated as a magic solution, but it can be a strong assistant for reducing ambiguity before implementation. Given a rough request, AI can help generate clarifying questions, possible edge cases, user stories, acceptance criteria, test scenarios, risk areas, and alternative approaches. It can summarize meeting notes, compare options, extract open questions, rewrite technical constraints in business-friendly language, and turn long discussions into a clearer decision record.</p><p>But AI has a hard boundary. It does not own context. It does not know the real business priority unless someone explains it. It does not know operational, legal, technical, or organizational constraints unless they are provided. It can generate possible scenarios, but it cannot decide which ones matter most. It can propose acceptance criteria, but it cannot guarantee that they match the real product expectation. It can suggest architecture, but it cannot fully understand the long-term cost inside a specific codebase.</p><p>So AI should be used as a thinking amplifier, not as the source of truth. It can help ask better questions, but people must answer them. It can help draft requirements, but people must validate them. It can help surface trade-offs, but people must choose based on context. Otherwise, teams may replace unclear human communication with confident but still incomplete generated text.</p><h3>Tools Do Not Create Alignment by Themselves</h3><p>Modern tools in general follow the same rule. Ticketing systems, documentation pages, diagrams, shared boards, design tools, analytics dashboards, observability platforms, and collaboration tools can all help, but none of them creates alignment automatically. A bad ticket in a modern tool is still a bad ticket. A diagram nobody maintains becomes outdated noise. A dashboard without agreed interpretation can create confusion. The tool is never the process by itself. The process is how the team uses the tool to make decisions visible, responsibilities clear, and feedback loops shorter.</p><p>One useful habit is documenting decisions, not only requirements. Requirements describe what should be built. Decisions explain why a direction was chosen. This matters because teams change, memory fades, and context disappears. A short decision note can explain that one option was chosen because of release timing, technical limitation, compliance constraint, design consistency, or migration strategy. It saves future teams from guessing the reason behind old choices.</p><p>Another useful habit is separating problem, solution, and implementation. The problem is what needs to be solved. The solution is the chosen product or technical direction. The implementation is how the team builds it. When these are mixed, discussion becomes messy. Someone may challenge the implementation while another person thinks they are challenging the business goal. Clear separation keeps the conversation healthier.</p><h3>Ownership Before and After Release</h3><p>Ownership also matters. Bridging product and engineering does not mean that one person must understand everything perfectly. That is unrealistic. It means someone needs to make sure the right questions are asked by the right people before the work becomes code. Engineering should not discover basic product rules during implementation. Product should not discover technical limitations only during release testing. QA should not be the first place where important edge cases appear. Support should not be the first place where the team learns that users understood the feature differently.</p><p>After release, the workflow should close the loop. Did users actually use the feature. Did errors increase. Did support questions decrease. Did the flow become faster. Did the technical solution behave as expected. Did edge cases appear in production. Product analytics, crash reporting, logs, customer feedback, support tickets, and operational metrics connect the built solution back to the real problem. A feature is not successful only because it was released. It is successful when it improves the situation it was meant to improve.</p><h3>What This Means for Engineers and Leads</h3><p>Writing good code is still important, but technical value does not stop at implementation. As engineers grow, their impact increasingly comes from understanding the problem earlier, asking sharper questions, explaining trade-offs clearly, and helping the team avoid building the wrong thing correctly. That does not mean every engineer has to become a product manager. It means engineers should understand that implementation is only one part of delivery.</p><p>The healthiest teams are not the ones where business and engineering become the same role. They are the ones where both sides build enough shared language to make better decisions together. Business should not treat engineering as a black box that simply receives requests. Engineering should not treat business context as noise. Product should not be just a messenger between the two. The goal is shared ownership of the outcome.</p><p>Leadership in this context is less about authority and more about clarity. A strong lead reduces ambiguity, brings the right people into the conversation, translates technical risk into business impact, and keeps the connection between the problem and the solution alive until after release.</p><h3>Build the Right Thing for the Right Reason</h3><p>Bridging product and engineering is not a soft topic separate from technical work. It is technical work before the code starts. Every unclear requirement becomes a technical risk. Every hidden assumption becomes a possible bug. Every missing edge case becomes a possible production issue. Every misunderstood business rule becomes code that may work exactly as implemented, but still fail the real problem.</p><p>In the end, building software is not only about translating designs into screens or tickets into code. It is about translating real-world problems into systems that behave correctly, scale reasonably, and remain understandable over time. The real bridge between product and engineering is not a meeting, a ticket, or an AI-generated document. It is shared understanding strong enough to guide decisions, expose what is still unknown, and keep the team focused on the problem that actually needs to be solved.</p><p>So before turning the next request into tasks, stop for a moment and ask the harder questions. What problem are we really solving. Who is affected. What are we assuming. What can fail. How will we know that this worked after release. The teams that ask these questions early are the ones that build with more confidence, less rework, and a clearer connection between effort and value.</p><p>Because the goal is not just to ship software. The goal is to build the right thing, for the right reason, with enough shared understanding that everyone involved can stand behind the result.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8ff450e6a131" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[SwiftUI vs Jetpack Compose: Two Declarative Frameworks, Two Platform Philosophies]]></title>
            <link>https://naggelidis.medium.com/swiftui-vs-jetpack-compose-two-declarative-frameworks-two-platform-philosophies-7ffd177f43c7?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ffd177f43c7</guid>
            <category><![CDATA[swiftui]]></category>
            <category><![CDATA[jetpack-compose]]></category>
            <category><![CDATA[ios-app-development]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[android-app-development]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-08-31T14:51:01.215Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Jcp3JmfzkD1Xdaz1Mj4Q_g.png" /></figure><p>SwiftUI and Jetpack Compose are often compared because they represent the same major shift in mobile UI development. Both move away from manually updating views step by step. Both describe UI based on state. Both encourage smaller components, previews, cleaner composition, and less boilerplate. At first glance, it is easy to say that SwiftUI is Apple’s declarative UI framework and Jetpack Compose is Android’s equivalent.</p><p>That comparison is useful, but only up to a point. The more interesting discussion is not which one is better. It is also not whether one looks cleaner in a small code example. The more useful question is why both platforms moved toward declarative UI, and why the development experience still feels different when you use them in real apps.</p><p>SwiftUI and Compose solve similar problems, but they come from different platform histories. SwiftUI appeared in an ecosystem where UIKit had already shaped iOS development for many years. UIKit gave developers control, maturity, and a very explicit way of building screens. The cost was often boilerplate, complex view controllers, manual UI updates, and the risk of placing too many responsibilities in one object.</p><p>Compose appeared in an Android world shaped by XML layouts, Views, Activities, Fragments, RecyclerViews, adapters, lifecycle complexity, and gradual architectural evolution around ViewModels and reactive state. Traditional Android UI was powerful and flexible, but it also had many moving parts. Compose made Android UI feel more direct, because the interface could be described in Kotlin, closer to the state and logic that drive it.</p><p>So both frameworks are responses to a similar problem, but not to the exact same history. That difference matters. It means that SwiftUI and Compose may look similar in small examples, but they are not the same framework with different syntax. They are two different platform answers to the same broader direction, more declarative, more state-driven, and more composable UI.</p><p>In SwiftUI, a view describes part of the interface through its body. In Compose, a composable function describes part of the interface through Kotlin code. A small SwiftUI example may look like this.</p><pre>struct GreetingView: View {<br>    let name: String</pre><pre>    var body: some View {<br>        Text(&quot;Hello, \(name)&quot;)<br>    }<br>}</pre><p>A small Compose example may look like this.</p><pre>@Composable<br>fun Greeting(name: String) {<br>    Text(text = &quot;Hello, $name&quot;)<br>}</pre><p>These examples make the connection clear. Both describe UI. Both receive data. Both can be composed into larger screens. But real apps are not built from greeting labels. Real apps have loading states, empty states, errors, navigation, accessibility, analytics, permissions, background work, design systems, and features that change over time. That is where the real comparison begins.</p><p>The main shared idea is state-driven UI. Instead of thinking, find the label and update the text, we think, given this state, what should the screen show. If the screen is loading, show loading. If there is an error, show the error. If there is data, show the content. The UI becomes a result of state, not a collection of manual updates.</p><p>This is a healthy direction because it makes screens easier to reason about. When states are explicit, it becomes easier to review the feature, preview different cases, test presentation logic, and understand what happens when data changes. It also makes UI bugs easier to discuss, because the conversation moves from which view did not update, to which state did the screen receive.</p><p>But declarative UI does not remove complexity. It moves complexity. In UIKit or traditional Android Views, complexity often appeared in imperative update code. In SwiftUI and Compose, complexity often appears in state ownership, data flow, side effects, lifecycle, identity, and navigation. The code may look shorter, but the engineering questions remain. Where does state live. Who changes it. Which layer owns business rules. What happens when a request fails. What happens when the screen disappears. What happens when the same state is observed by multiple UI components.</p><p>This is where both frameworks require discipline. SwiftUI has its own state tools and mental model. You may use local state inside a view, pass state through bindings, observe objects, or use newer observation tools depending on the app and deployment target. These tools are useful, but they still require clear decisions. If everything becomes local state, the screen can become hard to control. If everything moves to one large object, the view model can become the new massive view controller.</p><p>Compose has a similar challenge with different names. It has remember, rememberSaveable, state holders, ViewModels, state hoisting, and recomposition. A composable can own small local UI state, but larger screen state is often better exposed from a ViewModel or another state holder. The common direction is state going down and events going up. The UI receives state, displays it, and sends user actions back to the owner of that state.</p><p>A simplified Compose example could look like this.</p><pre>@Composable<br>fun ProfileScreen(<br>    state: ProfileUiState,<br>    onRetry: () -&gt; Unit<br>) {<br>    when (state) {<br>        is ProfileUiState.Loading -&gt; CircularProgressIndicator()<br>        is ProfileUiState.Error -&gt; ErrorView(<br>            message = state.message,<br>            onRetry = onRetry<br>        )<br>        is ProfileUiState.Success -&gt; ProfileContent(state.profile)<br>    }<br>}</pre><p>The important part is not the code itself. The important part is the responsibility. The composable does not decide how retry works. It does not know whether the data comes from network, cache, database, or a mock source. It displays the current state and sends the user action back to the owner of that state. This is simple, but it is also one of the most important ideas in modern UI architecture.</p><p>The same idea applies to SwiftUI. A view should not become the place where networking, business decisions, formatting rules, navigation policy, analytics, and side effects all live together. The view should display state and communicate intent. The rest of the app should decide what that intent means. This is not about following a pattern for the sake of the pattern. It is about keeping the feature understandable after many changes.</p><p>Recomposition in Compose and body recalculation in SwiftUI are also easy to misunderstand. A beginner may think the framework is constantly redrawing everything in a wasteful way. An experienced engineer understands that the framework has its own update mechanism, identity rules, and optimization model. But the developer still has responsibility. The risk is not recomposition itself. The risk is doing unstable, expensive, or side-effect-heavy work as part of UI declaration.</p><p>This is one of the most important lessons in declarative UI. The UI declaration should describe what the screen looks like for a given state. It should not become a random place to start requests, write data, track analytics, or execute work just because the function is being called. Both SwiftUI and Compose have specific mechanisms for side effects, lifecycle-aware work, and reacting to state changes. The details are different, but the principle is the same. Side effects need boundaries.</p><p>In Compose, developers may use tools like LaunchedEffect or DisposableEffect for specific side-effect scenarios. In SwiftUI, developers may use tools like task, onAppear, onDisappear, or other mechanisms depending on the situation. The names are not the most important part. The important part is understanding that declarative UI code can run more often than someone expects, and that not every piece of work belongs directly inside the UI declaration.</p><p>This is where short examples can be misleading. A small demo makes declarative UI look almost effortless. But real apps need to handle cancellation, retries, duplicate requests, lifecycle transitions, background and foreground changes, and user actions happening faster than expected. If those things are not designed carefully, the UI may still look modern, but the behavior will be fragile.</p><p>Modifiers are another area where SwiftUI and Compose look similar but should not be treated as identical. In SwiftUI, modifiers are a central way to transform or configure views. You add padding, background, frame, gestures, accessibility, and many other behaviors through chained calls. In Compose, Modifier plays a similar role. It can define size, padding, background, click behavior, layout behavior, and accessibility semantics.</p><p>The similarity helps engineers move between the two worlds faster. But details matter. Modifier order can affect behavior. Layout rules are different. The rendering systems are different. Interaction and accessibility APIs are different. A SwiftUI modifier chain and a Compose modifier chain may look similar in style, but they belong to different engines.</p><p>The same is true for layout. SwiftUI has stacks, lists, grids, spacers, frames, alignments, and layout tools shaped by Apple platform conventions. Compose has Row, Column, Box, LazyColumn, LazyRow, modifiers, constraints, and adaptive layout tools shaped by Android needs. Both frameworks want UI composition to feel natural, but each platform thinks differently about space, density, navigation, device variety, and system behavior.</p><p>This becomes clearer when design systems enter the discussion. SwiftUI naturally lives inside Apple’s design language. It works with Apple platform conventions, system controls, navigation patterns, typography, gestures, accessibility, and the Human Interface Guidelines. Compose naturally lives inside Android’s design world, where Material Design and Material 3 play a major role.</p><p>This does not mean every SwiftUI app must look identical, or every Compose app must look like a default Material sample. It means that platform feel matters. A good iOS app should feel at home on iOS. A good Android app should feel at home on Android. Declarative UI does not remove platform identity.</p><p>This point is important for mobile teams. Sharing concepts across platforms is useful. Copying the same UI behavior blindly is not. Users do not care that the architecture looks symmetrical across iOS and Android. They care that the app feels natural on their device.</p><p>Navigation is another area where the two frameworks expose different philosophies and different pain points. In UIKit, navigation was often explicit through navigation controllers, coordinators, segues in older projects, and manual presentation. In SwiftUI, navigation is more declarative, but larger apps still need clear navigation decisions. If views directly decide too much about routing, the app can become hard to maintain. If navigation is abstracted too aggressively, the app can become hard to follow.</p><p>In Android, navigation has its own long history through Activities, Fragments, the Navigation component, back stack behavior, deep links, and system back handling. Compose changes how screens are built, but it does not erase Android navigation concepts. A Compose app still needs to respect Android back behavior, lifecycle, destinations, and deep linking expectations.</p><p>So the navigation question is not only how to move from one screen to another. The real question is where route decisions live, how deep links are handled, how back behavior works, and how much navigation knowledge should be inside the UI layer. Both SwiftUI and Compose can make simple navigation look easy. Both still need architecture when the app becomes large.</p><p>Interoperability is one of the most practical similarities. SwiftUI and UIKit can coexist. Compose and traditional Android Views can coexist. This matters because most serious apps are not rewritten from scratch. They evolve.</p><p>A team may introduce SwiftUI in a new iOS feature while keeping older UIKit flows. An Android team may introduce Compose in a new screen while keeping existing View-based screens. In both cases, the responsible migration question is not how do we replace everything. The better question is where does the new framework create enough value with acceptable risk.</p><p>This is where mature engineering decisions differ from trend adoption. A stable screen that rarely changes may not need a rewrite. A new feature with clear state and fast UI iteration may be a good candidate. A reusable component may be a safe starting point. A complex, business-critical flow may need more planning before migration.</p><p>The framework is only one part of the decision. The team’s knowledge, the app’s architecture, the release pressure, the testing strategy, and the cost of mistakes also matter. A new framework can improve development speed, but only when the team has enough shared understanding to use it consistently.</p><p>Previews are one of the strongest practical benefits in both ecosystems. SwiftUI previews helped iOS engineers think faster about UI states. Compose previews offer similar value for Android. A good preview is not only a visual shortcut. It is a way to make states visible earlier.</p><p>A useful preview shows more than the happy path. It shows loading, error, empty, long text, dark mode, different screen sizes, and accessibility-relevant cases. This helps developers, designers, QA, and product people discuss the real behavior of the screen before the whole app flow is ready.</p><p>But previews also have limits. A preview does not prove that navigation works correctly. It does not prove that the API contract is correct. It does not prove that accessibility is complete. It does not prove that the screen behaves well under real lifecycle conditions. Previews improve feedback, but they do not replace testing.</p><p>Testing follows the same pattern. SwiftUI and Compose make some UI states easier to isolate because the UI can be described from state. This can improve snapshot testing, component testing, and UI review. But real quality still depends on clear boundaries. If business logic is inside the view, testing remains hard. If state is explicit and logic is separated, testing becomes easier regardless of the framework.</p><p>Performance is another area where simple comparisons are usually not useful. Both SwiftUI and Compose can perform well. Both can also perform poorly if used carelessly. Declarative UI does not mean developers can ignore rendering cost, state updates, identity, list behavior, image loading, animations, or unnecessary work during UI updates.</p><p>The practical rule is simple. Do not judge performance from small demos. Judge it from real screens, real data, real devices, and real user flows. A framework can provide the right tools, but teams still need profiling, measurement, and discipline. When a screen feels slow, the answer is rarely that declarative UI is bad. The answer is usually somewhere in state changes, layout cost, image handling, list rendering, unnecessary work, or poor separation of responsibilities.</p><p>AI-assisted development also changes the practical learning curve, especially now that both ecosystems are moving toward stronger tooling support. An engineer can use AI tools to generate first drafts, explain unfamiliar APIs, create preview states, refactor repetitive UI, or compare platform concepts faster than before. This can make learning Compose easier for an iOS engineer, and learning SwiftUI easier for an Android engineer.</p><p>But AI does not remove the need to understand the framework. It can generate a composable or a SwiftUI view. It can suggest a modifier. It can create a preview. But it cannot reliably decide the architecture for your product. It does not automatically know where state should live, how side effects should be handled, whether the screen respects platform conventions, or whether the result will remain maintainable after many changes.</p><p>So AI is useful as acceleration, not as authority. It helps with the first draft. The engineer still owns the final decision.</p><p>The deeper comparison between SwiftUI and Compose is really a comparison between platform philosophies. SwiftUI feels strongly connected to Apple’s integrated ecosystem. It is designed for Apple platforms, Apple tools, Apple design conventions, and Apple’s gradual movement toward a more unified way of building interfaces across iOS, macOS, watchOS, tvOS, and visionOS. Its strength is that it fits deeply into the Apple world. Its challenge is that real iOS apps still often need to coexist with UIKit, older patterns, and platform-specific behavior that does not disappear overnight.</p><p>Compose feels strongly connected to Android’s need for modern, flexible, Kotlin-first UI development. It gives Android teams a more direct way to build adaptive, state-driven interfaces while reducing the old split between XML and Kotlin. Its strength is that it modernizes Android UI in a way that fits Kotlin and the Jetpack ecosystem. Its challenge is that Android still carries lifecycle complexity, device variety, back behavior, interoperability with Views, and the need to respect Material and Android conventions.</p><p>Neither philosophy is wrong. They reflect different ecosystems. That is why trying to declare a universal winner is usually not useful. A framework can be excellent inside its ecosystem and still feel strange to someone coming from the other side.</p><p>For a mobile engineer, the value is not to choose a winner. The value is to understand the trade-offs. SwiftUI can teach Android engineers a lot about Apple’s approach to state, simplicity, and ecosystem integration. Compose can teach iOS engineers a lot about Kotlin-first UI, explicit state flow, Android architecture, and how a platform can move away from XML-based UI toward composable functions.</p><p>The common lesson is that declarative UI is not only a UI topic. It affects architecture, testing, design systems, migration strategy, team communication, performance, and product evolution. When the UI is a function of state, the quality of the state model becomes critical. When screens are composed from smaller pieces, component boundaries become critical. When the framework updates the UI automatically, side effects and lifecycle become critical.</p><p>That is why SwiftUI vs Compose is not the best final question. A better question is this. What does each framework teach us about building maintainable mobile apps.</p><p>SwiftUI teaches us that iOS development can move beyond imperative view updates while keeping strong platform identity. Compose teaches us that Android UI can become more concise, state-driven, and Kotlin-native without pretending that Android’s platform realities do not exist. Both teach us that modern UI code can look simple while still requiring serious engineering judgment.</p><p>For teams, the healthiest mindset is balance. Use declarative UI to make screens clearer. Use state-driven rendering to make behavior more predictable. Use previews to shorten feedback. Use architecture boundaries to keep features maintainable. Use platform conventions to respect users. Use AI tools to move faster, but keep human judgment in control.</p><p>In the end, SwiftUI and Jetpack Compose are not just two frameworks with similar syntax. They are two expressions of the same broader direction in mobile development. UI is becoming more declarative, more state-driven, more composable, and more integrated with platform tooling.</p><p>But the platforms remain different.</p><p>And that difference is not a problem. It is the reason mobile engineering is still interesting. The goal is not to make iOS and Android identical. The goal is to understand both well enough to build products that feel right, scale technically, and keep evolving without becoming harder to maintain with every new feature.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ffd177f43c7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What the Anti-AI Backlash Among Young People Is Trying to Tell Us]]></title>
            <link>https://naggelidis.medium.com/what-the-anti-ai-backlash-among-young-people-is-trying-to-tell-us-78f23991a94c?source=rss-801582defdbf------2</link>
            <guid isPermaLink="false">https://medium.com/p/78f23991a94c</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[human-behavior]]></category>
            <category><![CDATA[critical-thinking]]></category>
            <dc:creator><![CDATA[Nikos Aggelidis]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 14:51:01 GMT</pubDate>
            <atom:updated>2026-08-24T14:51:01.273Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yBFAwseIwAezeYzRgHZ03Q.png" /></figure><p>The other day, while listening to one of the conversations Gerasimos Tsiamalos has recently started hosting on his channel, <a href="https://www.youtube.com/watch?v=2VuV0HyBLbM">this one with Nikos Savvopoulos about business, web design and AI</a>, I heard the term “anti-AI movement”. I found the format interesting in itself, as these conversations open up practical discussions around technology, business and some of the broader changes happening around them. But that particular term stayed with me and made me curious enough to look a little deeper into what an anti-AI movement actually means, and whether there is really one taking shape.</p><p>What I found was more interesting than a simple movement for or against AI. There is no single organized anti-AI movement among young people, and certainly no broad rejection of the technology. In fact, many of the same people expressing concerns about AI are already using it regularly. The tension is precisely there, heavy adoption on one side, and growing skepticism about its effects on the other.</p><p>A 2026 Gallup study found that 51 percent of Gen Z respondents in the United States were using generative AI at least weekly. At the same time, excitement about AI had fallen to 22 percent, while anger had risen to 31 percent. Curiosity remained high, but optimism did not. Even among daily AI users, enthusiasm had declined compared with the previous year. People can use a technology frequently while becoming increasingly uncomfortable with what it may be doing to them and to the world around them.</p><p>We have also seen this tension become visible in universities. During the 2026 graduation season in the United States, students at several institutions openly reacted against commencement speakers who presented AI as an inevitable and largely positive part of their future. These reactions were connected to concerns about employment, education and the sense that young people were being told to embrace a technology that could also reshape the opportunities waiting for them after graduation.</p><p>At the same time, Common Sense Media reported in June 2026 that 86 percent of children between 9 and 17 had already used some form of AI, with almost a quarter using it every day. One in five AI users said it would be difficult to go a month without it. Among daily users, that figure rose even higher. What we are seeing is therefore more interesting than rejection. It is heavy adoption combined with growing doubt.</p><p>That contradiction is what makes the subject worth exploring. The useful question is not whether these young people are right or wrong about AI, or whether the rest of us should join some kind of anti-AI movement. It is what their discomfort may be revealing about our own relationship with the technology, and what we can learn from it to use AI more practically without quietly giving away abilities that remain valuable.</p><h3>This is not really a story about rejecting technology</h3><p>The easiest explanation is that young people are simply afraid of change. It is also probably the least convincing one. The generation expressing many of these concerns is not unfamiliar with digital technology. It grew up surrounded by it. Many teenagers encountered generative AI before workplaces, governments and educational institutions had even decided what responsible use should look like.</p><p>Their concerns are also more specific than a general fear of technology. Some worry about what happens to learning when the answer appears before the thinking. Others worry about jobs that may change before they have a chance to enter them. There are concerns about misinformation, synthetic content, privacy, creative ownership, surveillance and the increasing difficulty of knowing whether something online represents another person’s actual work.</p><p>There is also a more subtle concern underneath many of these arguments, agency. A teenager may be told not to use AI to complete an assignment, while simultaneously hearing that learning to use AI is essential for their future. A university may warn students about academic integrity while integrating AI throughout its own operations. A graduate may spend years developing professional skills and then hear that many of the entry level activities through which those skills were traditionally learned could soon be automated.</p><p>The mixed reaction should not be surprising. The message surrounding AI is frequently that it is inevitable. The question coming back is whether inevitability automatically makes every possible use desirable. That is not only a question for teenagers. It is becoming one of the most useful questions anyone can ask about AI.</p><h3>The real dividing line is not AI use, it is AI dependence</h3><p>Discussion about AI often becomes unnecessarily binary. Use AI or reject it. Embrace the future or fall behind. Automate everything possible or deliberately stay manual. None of these positions is particularly useful for everyday life. A better distinction is between using AI and depending on AI.</p><p>Using AI means deliberately giving a tool part of a task because doing so improves the result, reduces unnecessary work or expands what we are capable of doing. Depending on AI means gradually losing the ability, confidence or willingness to perform the underlying activity without it. Those two situations can look almost identical from the outside.</p><p>Imagine two people using AI to understand a difficult subject. The first reads the material, develops an initial interpretation, identifies what is unclear and asks AI to explain or challenge those specific points. The second sends the entire material to an AI system and asks what it says. Both used AI, but cognitively they did something very different. The first person used AI to extend a process that had already started. The second allowed AI to start the process on their behalf.</p><p>That difference matters because efficiency, performance and capability are not the same thing. AI can make someone perform a task better today without necessarily making that person better at the task tomorrow.</p><h3>Humans have always outsourced thinking</h3><p>There is nothing new about moving parts of our mental work into tools or the environment around us. Writing allows us to store information outside our memory. Calculators remove the need to perform every calculation mentally. Calendars remember appointments. GPS remembers routes. Search engines make enormous amounts of information accessible without requiring us to memorize it. Much of this is clearly beneficial. Human progress depends partly on not having to rebuild every piece of knowledge from scratch.</p><p>So the useful argument cannot be that outsourcing thinking is inherently bad. The real question is what we outsource. Few people would argue that remembering every phone number is a cognitive ability worth protecting. Being able to reason through conflicting evidence is different. We probably do not need to preserve the ability to calculate a complicated percentage manually every time. We probably do want to preserve enough understanding to recognize when the resulting number makes no sense.</p><p>The distinction is between offloading information or mechanical execution, and offloading the judgment required to understand what we are doing. Generative AI makes this boundary unusually important because it can operate on both sides of it. It can handle repetitive work, but it can also generate the interpretation. It can calculate, but it can also recommend the decision. It can improve a sentence, but it can also decide what should be said. It can explain a subject, but it can also decide which explanation becomes our starting point.</p><p>This is one of the important differences between generative AI and many earlier digital tools. It does not only help us complete a process. It can enter before the process has properly started.</p><h3>Sometimes the difficult part is the valuable part</h3><p>Modern work has trained us to see friction as a problem. If something takes ten minutes and technology can reduce it to one minute, the improvement appears obvious. Often it is. Nobody needs to manually perform repetitive administrative work simply because previous generations had to do it.</p><p>But not all friction is waste. Some friction is where learning happens. Trying to remember something strengthens retrieval. Writing a first version forces loosely connected thoughts into an argument. Solving a problem before seeing the answer exposes what we actually understand. Reading difficult material develops comprehension. Making a bad attempt gives us something concrete to compare with a better one.</p><p>AI can remove much of this friction almost instantly. Whether that is beneficial depends on why the friction existed. A randomized controlled study published in 2025 found that undergraduate students who used ChatGPT as an unrestricted study aid performed worse on a surprise knowledge retention test 45 days later than students who studied using traditional methods. The AI-assisted group scored 57.5 percent, compared with 68.5 percent for the traditional group. The researchers connected the result to cognitive offloading and the reduction of effort that can support durable learning.</p><p>It would be a mistake to turn that result into a claim that AI harms learning. Research also points in the opposite direction. The OECD’s 2026 Digital Education Outlook concludes that generative AI can support learning when it is used with a clear educational purpose. The distinction it makes is important, completing a task successfully with AI does not automatically mean that learning occurred. General purpose AI can improve immediate performance while allowing some of the mental activity required for skill development to be skipped.</p><p>This gives us a much more useful conclusion than either “AI makes us smarter” or “AI makes us lazy”. The question is not whether AI makes something easier. Sometimes easier is exactly what we want. The better question is whether the difficulty being removed was pointless friction or useful practice.</p><h3>The first attempt is becoming more valuable, not less</h3><p>One practical habit can protect a surprising amount of human capability, try first when the thinking itself matters. Before asking AI to solve an important problem, spend some time understanding the problem. Before requesting ideas, generate a few. Before asking for a summary of something you need to understand deeply, read enough of the original material to establish the context. Before asking AI to write something important, decide what you actually want to say. Before requesting a recommendation, form an initial opinion.</p><p>This does not need to become an ideological rule. There is no benefit in wasting thirty minutes struggling with a trivial task merely to prove independence from a machine. The purpose of the first attempt is not suffering. It is establishing a reference point.</p><p>Once you have formed an initial view, you can compare it with the AI output. You can notice disagreements. You can ask more precise questions. You can recognize when the system interpreted the problem differently from you. Most importantly, you have something independent against which the answer can be evaluated. Without that reference point, AI’s answer easily becomes the reference point.</p><p>This matters because the first plausible explanation we encounter has influence. Once an AI system frames a problem in a particular way, we may spend the rest of the interaction improving its frame rather than asking whether the frame itself was appropriate. The danger is therefore not only that AI may give us the wrong answer. A more subtle problem is that it may define the question before we have decided what the question should be.</p><h3>Assistance can become authority without us noticing</h3><p>This becomes more important as AI improves. Poor AI output is relatively easy to question. Excellent AI output creates a different problem. It is fluent, well structured, immediate and often delivered without the visible uncertainty that we associate with difficult human reasoning. That makes confidence easy to mistake for reliability.</p><p>A 2025 study by researchers from Microsoft Research and Carnegie Mellon University surveyed 319 knowledge workers and collected 936 examples of AI-assisted work. Higher confidence in generative AI was associated with less critical-thinking effort, while greater confidence in one’s own ability was associated with more critical engagement. The researchers also found that AI did not simply eliminate thinking. It changed where that thinking happened, toward activities such as verifying information, integrating responses and overseeing the task.</p><p>That distinction matters. AI does not necessarily create a future where people stop thinking. It may create one where the location of thinking changes. Instead of spending most of our effort producing the first answer, we may increasingly spend it judging, correcting and integrating answers produced by machines.</p><p>That can be an improvement, but only if the person has enough underlying knowledge to perform that judgment. Otherwise human oversight becomes ceremonial. Someone reads the output, it appears reasonable, and they approve it without being capable of detecting the mistakes that meaningful oversight was supposed to catch. Having a human in the loop is not the same as having meaningful human control.</p><h3>AI is often more valuable after thinking than before it</h3><p>This suggests a better role for AI in many cognitive tasks. Instead of always asking it to produce the first answer, use it to improve an answer or understanding that already exists. Ask it to find weaknesses in your reasoning. Ask which assumptions you may have missed. Give it your explanation and ask what remains unclear. Ask it to construct the strongest argument against your conclusion. Use it to compare alternatives you have already identified. Ask what evidence would prove your current position wrong.</p><p>The difference sounds small, but it changes the relationship. AI stops being the place where thinking begins and becomes something thinking interacts with. This is also one of the easiest ways to turn AI from an answer machine into a learning tool. Asking for the answer tends to close a problem. Asking for criticism, alternatives or counterarguments tends to open it again.</p><p>For many tasks, that is where AI becomes most valuable, not when it saves us from thinking, but when it makes our own thinking harder to defend without improving it.</p><h3>We should automate tasks, not responsibility</h3><p>AI can perform more actions every year, but responsibility does not automatically move with the action. Someone can use AI to draft an email, analyse information, produce code, prepare a presentation, compare contracts, generate a financial model or recommend a decision. If the result matters, a human still needs to understand what was produced well enough to decide whether it should be used.</p><p>A useful rule is simple, do not delegate beyond your ability to evaluate. The rule becomes more important as consequences increase. For a low-stakes task, imperfect AI output may be perfectly acceptable. If AI suggests five dinner ideas and two are terrible, very little has been lost. The same tolerance makes less sense when an output affects money, employment, security, education, customers, legal obligations or another person’s rights.</p><p>This also means being able to defend the work we put forward. If AI helped produce an analysis, recommendation, design, piece of code or written argument, we should still be able to explain why the result makes sense, what assumptions it relies on and why we chose to accept it. Agreeing with an AI-generated answer simply because it looks convincing is not meaningful review. If we cannot explain the reasoning behind something we present as our own work, we have probably delegated too much of the task.</p><p>The higher the consequence, the stronger the human review should become. This is not because humans are always more accurate than machines. We are not. Human judgment has its own biases, blind spots and failures. The point is that responsibility requires more than producing an answer. It requires understanding context, uncertainty, tradeoffs and who carries the cost when the answer is wrong.</p><p>There is also a trap here. As AI becomes more reliable, we may become less likely to check it precisely because checking usually confirms that it was right. That sounds efficient until the rare mistake is also the important one. The long-term skill is therefore not permanent distrust. It is calibrated trust, knowing what deserves verification and how much verification the situation requires.</p><h3>Verification is becoming a core skill</h3><p>One of the stranger effects of generative AI is that producing information has become extremely cheap while verifying information remains relatively expensive. AI can generate ten explanations, dozens of claims and a polished argument in seconds. Checking whether the important parts are correct still takes work.</p><p>That changes where human effort becomes valuable. Producing a plausible answer is becoming less scarce. Determining whether that answer deserves trust is becoming more important.</p><p>Young people are already experiencing this tension themselves. Research published by Common Sense Media in August 2026 found that 70 percent of US teens surveyed were using AI for schoolwork, and nearly two-thirds of those users were using it in ways that offloaded part of the critical-thinking process. The broader findings also showed something more nuanced, teenagers were using AI both to obtain answers and for activities such as brainstorming and checking their own work.</p><p>The same person can therefore experience both sides of AI. It can help them understand something, and it can make it easier to avoid understanding it. AI literacy cannot mean simply knowing how to use an AI system. It must also mean knowing when not to trust one.</p><p>That includes checking important factual claims, distinguishing evidence from confident wording, finding original sources, recognizing uncertainty, noticing when important context is missing and knowing when a question requires genuine expertise. Better prompting does not remove this responsibility. A perfectly written prompt can still produce a wrong answer.</p><h3>The skills AI saves us from using may be the skills we later need to supervise it</h3><p>The more work we delegate to AI, the more important evaluation becomes. But evaluation itself often depends on experience gained by doing the work that has now been delegated.</p><p>A person who has written many arguments is better positioned to recognize a weak one. Someone who has solved many problems develops intuition for when an answer looks wrong. Someone who has researched a subject repeatedly learns which sources deserve trust. Someone who has built things themselves understands where failures are likely to hide.</p><p>If AI removes too much of that practice early, we can eventually arrive at a strange situation. People are expected to supervise work they never learned to perform.</p><p>This is one reason the problem of beginner work deserves more attention.</p><h3>We should be careful about removing the bottom of the skill ladder</h3><p>Many tasks that AI can automate are also tasks through which beginners traditionally learn. A junior employee may start with simple research, routine analysis, basic drafts, small implementation tasks or repetitive checks. To an experienced professional, these tasks can look like obvious candidates for automation. To the beginner, the same tasks may be repetitions through which judgment develops.</p><p>Entry level work has always had two functions. It produces useful work for an organization, and it trains the person who will later perform more difficult work. AI can reduce the need for the first function without eliminating the need for the second.</p><p>This issue is starting to appear more clearly in discussions about the future of work. Research and policy analysis increasingly point toward the possibility that AI may change not only individual jobs, but also the career pathways through which workers build skills and move toward more advanced roles. Many of the routine activities traditionally given to junior workers are also among the tasks AI is increasingly able to perform. Current labour-market evidence does not justify claiming that AI has broadly eliminated entry-level employment, but the long-term training problem is serious enough to consider before those pathways disappear.</p><p>This creates a paradox. AI can reduce the amount of beginner-level production work while increasing the value of expert-level judgment. We therefore need another way to build the expertise in between.</p><p>The solution is not to preserve inefficient work forever. It is to distinguish production from training. A task may no longer be necessary for producing an output while remaining useful for developing the person who will eventually be responsible for that output. If automation removes the practice, the practice needs to be intentionally recreated somewhere else.</p><h3>Productivity incentives and human incentives are not always identical</h3><p>There is another reason to approach AI adoption deliberately. The incentives of the organizations providing and deploying AI are not always identical to the incentives of the individual using it.</p><p>An AI company naturally benefits when people find more reasons to use AI. An employer benefits when the same amount of work can be produced with less time or fewer resources. A school may benefit when administration becomes more efficient. An individual benefits when a task becomes easier. These interests often align, but not always.</p><p>An organization can capture an immediate productivity gain while an individual absorbs a long-term loss of practice. A company may reasonably automate a task because it no longer needs people to perform it, while the profession still needs some way for beginners to learn the judgment that used to develop through that task.</p><p>This does not require assuming bad intentions from anyone. It is simply an incentive mismatch. Efficiency is easy to measure. Skill erosion is slower and harder to see. Hours saved appear immediately. The ability someone failed to develop may not become visible for years.</p><p>That is why individuals, schools and organizations should not rely only on short-term productivity when evaluating whether an AI use is beneficial. The question should also be what capability remains after the efficiency gain.</p><h3>AI can improve individual work while making collective output more similar</h3><p>The same tension appears in creativity. AI can genuinely help people produce better work. A 2024 experiment published in Science Advances found that people given access to generative AI ideas produced short stories that were evaluated as more creative, better written and more enjoyable, with particularly strong benefits for participants who were initially less creative.</p><p>But there was another result. The AI-assisted stories became more similar to one another. Individual performance improved while collective variety declined.</p><p>A later study analysing thousands of college admissions essays found a similar pattern. As more essays were added to the sample, human-written essays continued introducing new ideas at a higher rate than AI-generated essays. This matters well beyond creative writing.</p><p>If millions of people ask similar systems what to write, how to present an idea, which arguments to make and which alternatives to consider, AI can improve the average output while also pulling outputs toward a common centre. The risk is not necessarily that everything becomes bad. It may be that everything becomes reasonably good in increasingly similar ways.</p><p>That makes original experience, unusual judgment, domain knowledge, personal taste and the willingness to disagree with the obvious answer more valuable, not less. AI can give us more ideas. We should be careful not to let it decide what the range of possible ideas looks like.</p><h3>Human value may move toward what AI makes scarce</h3><p>There is another consequence worth considering. When something becomes abundant, value often moves toward what has become scarce.</p><p>Digital photography made images almost free to produce, but did not eliminate the appeal of film. Streaming made music instantly available, while live performance retained a different kind of value. Mass production made handmade objects less economically necessary, yet the knowledge that a person actually made something can itself become meaningful.</p><p>Generative AI may create a similar shift for intellectual and creative work. If polished text, competent illustrations, acceptable music and professional-looking presentations become nearly unlimited, technical polish alone becomes less impressive. The scarce element may increasingly be the judgment behind the work, the experience that shaped it, the unusual decision, the risk somebody chose to take, or simply confidence that another person actually meant what was communicated.</p><p>This does not mean human-created work will always be better or that AI-assisted work somehow lacks value. It means efficiency is not the only source of value. Sometimes effort, intention and authorship are part of what makes an outcome meaningful.</p><h3>Keep some human-only repetitions</h3><p>All of this leads to a practice that may feel increasingly unusual. Sometimes do the task without AI. Write something from a blank page. Solve a problem yourself. Read the original material rather than only its summary. Brainstorm before requesting twenty suggestions. Navigate somewhere occasionally without immediately depending on guidance. Make some decisions without first asking a model what it would choose.</p><p>Not because manual work is morally superior, but because capabilities that are never exercised become harder to access when we need them.</p><p>We already accept this principle elsewhere. Athletes do not outsource training because machines can produce more force. Musicians still practise even though software can reproduce notes perfectly. Pilots train for situations that automated systems normally handle because the existence of automation does not remove the need for capability when automation fails. Cognitive skills deserve similar consideration.</p><p>This does not mean maintaining every obsolete skill. Nobody needs to preserve every task technology has replaced. The point is to preserve the capabilities underneath the task that still matter.</p><p>We may no longer need to remember every fact, but we need to know what information matters. We may not need to produce every first draft manually, but we need to know what we want to communicate. We may not need to calculate every result ourselves, but we need enough understanding to recognize an impossible result. We may not need to generate every option independently, but we should remain capable of producing an option the model did not give us.</p><p>The goal is not maximum AI usage. The goal is maximum useful capability, with AI included.</p><h3>Convenience can hide a gradual loss of agency</h3><p>Many earlier digital technologies were introduced through the same argument, convenience. Social platforms made communication easier. Smartphones put many tools into one device. Recommendation systems removed much of the effort of searching. Notifications made information immediate. GPS removed much of the work of navigation.</p><p>Each individual convenience looked rational. The cumulative effect became more complicated. Over time, people discovered that a product can be extremely useful while also changing behaviour in ways they never consciously chose. Convenience can become habit, habit can become expectation, and expectation can eventually make the alternative feel unnecessarily difficult.</p><p>AI deserves a more deliberate adoption cycle. Before introducing it into another part of life, it is worth asking what problem it is actually solving. If the answer is clear, use it. If the answer is simply that AI can be added there, that is not much of a reason.</p><p>The ability of technology to perform an activity should not automatically create an obligation to delegate that activity.</p><h3>The best AI use should leave the human stronger</h3><p>Perhaps the most practical principle in the entire discussion is also the simplest. After repeatedly using AI for a task, what happens to your own ability to perform that task?</p><p>Sometimes the answer will be positive. You understand the subject better. You see more alternatives. You catch mistakes earlier. You communicate more clearly. You have more time for higher-value work. You attempt things that previously required knowledge or resources you did not have. That is augmentation.</p><p>Sometimes the answer will be less comfortable. You struggle to begin without the tool. You accept its answers more quickly. You remember less. You stop checking sources. You become less confident in your own judgment. Tasks that once triggered thought become reflexive requests to a chatbot. That is dependence beginning to form.</p><p>There is no universal boundary between the two. The correct balance for writing will not be the same as the balance for accounting, studying, programming, planning a holiday or answering routine messages.</p><p>But there is a useful test. What part of this task am I trying to remove. Is that part merely consuming time, or is it developing a capability I still want. If AI gives me a convincing but wrong answer, can I recognize it. Am I using the system because it improves the outcome, or simply because asking it has become automatic.</p><p>For trivial tasks, these questions are unnecessary. Nobody needs a philosophical framework before asking AI to reformat text. For tasks involving learning, judgment, creativity or important decisions, they are worth asking.</p><p>This is a practical form of control over our own thinking. We can use increasingly capable systems without automatically allowing those systems to determine which mental activities remain ours.</p><h3>Knowing when not to use AI may become part of AI literacy</h3><p>Most discussions about AI literacy focus on capability. Learn how the models work, write better prompts, understand their limitations, verify their output, use the right tool for the task. All of that matters.</p><p>But mature AI literacy probably includes one additional ability, recognizing when using AI would make the task worse.</p><p>Sometimes worse means less accurate. Sometimes it means less private. Sometimes it means unnecessarily complicated. Sometimes it means losing useful practice. Sometimes the task is valuable precisely because a person needs to think through it themselves.</p><p>As AI becomes easier to use, the technical skill required to invoke it will become less distinctive. Almost everyone will be able to ask a capable system for an answer.</p><p>The harder skill will be deciding whether that answer should be requested in the first place, what part of the problem should remain human, and when the machine’s involvement should stop.</p><p>Restraint is not rejection. It is part of competent tool use.</p><h3>The backlash may be more useful than the hype</h3><p>It is easy to dismiss resistance to new technology as fear. It is equally easy to turn every concern into evidence that the technology should be rejected. Neither response helps much.</p><p>The evidence points toward something more complicated. Young people are using AI extensively while also becoming more skeptical about its effects. Research into learning, professional work and creativity tells a similarly mixed story. AI can improve performance, make difficult capabilities more accessible and remove large amounts of unnecessary work. It can also remove cognitive effort that had a purpose, make weak reasoning look convincing, reduce opportunities for practice and push different people toward increasingly similar answers.</p><p>That tension may actually be healthier than either blind enthusiasm or complete rejection.</p><p>The lesson is not that we should use less AI simply because some young people are uncomfortable with it. It is that adoption should remain a choice rather than becoming a reflex.</p><p>We should remove pointless work without removing the work that develops skill. We should offload information without automatically offloading judgment. We should use AI to expand thinking without always letting it establish the first thought. We should automate execution without outsourcing responsibility. We should take productivity gains while considering how future expertise will be created. We should benefit from generated ideas without allowing the same systems to narrow the range of ideas we consider.</p><p>AI is likely to become more capable, more accessible and more deeply integrated into everyday life. That makes these distinctions more important, not less.</p><p>The valuable skill will not simply be knowing how to use AI. That knowledge will become increasingly common.</p><p>The valuable skill will be knowing what to give it, what to keep for yourself, when to trust it, when to challenge it, and why.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=78f23991a94c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>