<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Miro Ma</title>
    <description>The latest articles on DEV Community by Miro Ma (@ma_dev).</description>
    <link>https://dev.to/ma_dev</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F3975681%2F4c8d5f89-3154-4039-a26b-685bd5081e80.jpg</url>
      <title>DEV Community: Miro Ma</title>
      <link>https://dev.to/ma_dev</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/ma_dev"/>
    <language>en</language>
    <item>
      <title>How to SSH Into Windows 11 From Your Phone (and Browse Files With SFTP)</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Thu, 12 Nov 2026 17:15:04 +0000</pubDate>
      <link>https://dev.to/ma_dev/how-to-ssh-into-windows-11-from-your-phone-and-browse-files-with-sftp-3073</link>
      <guid>https://dev.to/ma_dev/how-to-ssh-into-windows-11-from-your-phone-and-browse-files-with-sftp-3073</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Version requirement:&lt;/strong&gt; NimoteCode &lt;strong&gt;2.3.0 or later&lt;/strong&gt; (this guide uses 2.3.0 as the minimum version for the Windows SSH/SFTP workflow; verify availability against the release notes). The primary target is &lt;strong&gt;Windows 11&lt;/strong&gt;. Similar instructions might apply to Windows 10 or Windows Server, but untested combinations are not guaranteed.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;You don't need Remote Desktop to access your Windows development machine from your phone. SSH and SFTP are often enough.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I recently worked on getting Windows 11 remote development working properly from my phone. The idea was simple: browse files, edit code, and run PowerShell commands without sitting in front of my PC.&lt;/p&gt;

&lt;p&gt;The setup turned out to be fairly straightforward. The annoying part was debugging it when Windows said port 22 was allowed, but every connection still timed out.&lt;/p&gt;

&lt;p&gt;Here's how to set everything up, including the problems I ran into.&lt;/p&gt;

&lt;h2&gt;
  
  
  What we're setting up
&lt;/h2&gt;

&lt;p&gt;The setup looks like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Android / iPhone
       |
       | SSH (TCP 22)
       |
       v
Windows 11 PC
       |
       +-- OpenSSH Server
       +-- SFTP file access
       +-- PowerShell terminal
       +-- Local projects
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;SSH gives us a remote shell. SFTP runs over the same SSH connection and lets us browse and transfer files.&lt;/p&gt;

&lt;p&gt;We'll use:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A Windows 11 computer&lt;/li&gt;
&lt;li&gt;A phone connected to the same local network&lt;/li&gt;
&lt;li&gt;Windows OpenSSH Server&lt;/li&gt;
&lt;li&gt;An SSH/SFTP client on the phone&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For the mobile client, I'll use &lt;strong&gt;NimoteCode 2.3.0+&lt;/strong&gt;, a mobile IDE I've been building for Android and iOS. Other SSH/SFTP clients can use the same Windows configuration.&lt;/p&gt;

&lt;p&gt;No Windows Remote Desktop, WSL, or additional Windows host application is required for the basic setup.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Enable OpenSSH Server on Windows 11
&lt;/h2&gt;

&lt;p&gt;First, open &lt;strong&gt;PowerShell as Administrator&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Check whether OpenSSH Server is installed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;WindowsCapability&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Online&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;
    &lt;span class="nc"&gt;Where&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Object&lt;/span&gt; &lt;span class="nc"&gt;Name&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;like&lt;/span&gt; &lt;span class="s1"&gt;'OpenSSH*'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Look for:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;OpenSSH.Server~~~~0.0.1.0
State : Installed
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If the server is not installed, run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Add&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;WindowsCapability&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Online&lt;/span&gt; &lt;span class="sb"&gt;`
    -Name OpenSSH.Server~~~~0.0.1.0
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Alternatively, you can install it from Windows Settings under Optional Features.&lt;/p&gt;

&lt;p&gt;Now start the SSH service:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Start&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Service&lt;/span&gt; &lt;span class="n"&gt;sshd&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Make it start automatically after reboot:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Set&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Service&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Name&lt;/span&gt; &lt;span class="n"&gt;sshd&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;StartupType&lt;/span&gt; &lt;span class="nc"&gt;Automatic&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Verify the service:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Service&lt;/span&gt; &lt;span class="n"&gt;sshd&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You should see:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Status   Name
------   ----
Running  sshd
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;That's the first part done.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Check whether Windows is listening on port 22
&lt;/h2&gt;

&lt;p&gt;Installing OpenSSH doesn't help if the SSH service isn't actually listening.&lt;/p&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetTCPConnection&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;LocalPort&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;State&lt;/span&gt; &lt;span class="nc"&gt;Listen&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A typical result looks like:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;LocalAddress LocalPort State
------------ --------- -----
0.0.0.0      22        Listen
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;code&gt;0.0.0.0&lt;/code&gt; means the service is listening on all IPv4 interfaces.&lt;/p&gt;

&lt;p&gt;If there's no output, check the SSH service again. Also inspect:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;C:\ProgramData\ssh\sshd_config
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Look for custom &lt;code&gt;Port&lt;/code&gt; or &lt;code&gt;ListenAddress&lt;/code&gt; settings that may prevent the expected connection.&lt;/p&gt;

&lt;p&gt;After changing the SSH configuration, validate it with &lt;code&gt;sshd -t&lt;/code&gt; and restart the service.&lt;/p&gt;

&lt;p&gt;Before testing from the phone, check localhost:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Test&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetConnection&lt;/span&gt; &lt;span class="mf"&gt;127.0&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mf"&gt;0.1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Port&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important line is:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;TcpTestSucceeded : True
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If this fails, fix the local SSH service before troubleshooting the phone or router.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Check the Windows Firewall
&lt;/h2&gt;

&lt;p&gt;This is where I spent more time than expected.&lt;/p&gt;

&lt;p&gt;I had several rules allowing TCP port 22, including rules created during earlier SSH and WSL experiments.&lt;/p&gt;

&lt;p&gt;At first glance, everything looked fine. But multiple firewall rules don't prove that a remote connection will work.&lt;/p&gt;

&lt;p&gt;Check the OpenSSH rule:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetFirewallRule&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Name&lt;/span&gt; &lt;span class="s2"&gt;"OpenSSH-Server-In-TCP"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;
    &lt;span class="nc"&gt;Select&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Object&lt;/span&gt; &lt;span class="nc"&gt;DisplayName&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Enabled&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Profile&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You might see:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;DisplayName               Enabled Action Profile
-----------               ------- ------ -------
OpenSSH SSH Server (sshd) True    Allow  Private
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Notice &lt;code&gt;Private&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;That rule applies to the Private network profile. If your active connection is classified as Public, it may not apply.&lt;/p&gt;

&lt;p&gt;Check your network:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetConnectionProfile&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;
    &lt;span class="nc"&gt;Select&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Object&lt;/span&gt; &lt;span class="nc"&gt;InterfaceAlias&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;NetworkCategory&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If this is your trusted home or office LAN, you can configure the network as Private through Windows Settings.&lt;/p&gt;

&lt;p&gt;For a temporary diagnostic test, you can change the SSH rule to all profiles:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Set&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetFirewallRule&lt;/span&gt; &lt;span class="sb"&gt;`
    -Name "OpenSSH-Server-In-TCP" `&lt;/span&gt;
    &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Profile&lt;/span&gt; &lt;span class="nc"&gt;Any&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Don't leave SSH unnecessarily exposed on untrusted networks. Once you identify the issue, restrict the rule to the intended network profile and, where practical, trusted remote IP ranges.&lt;/p&gt;

&lt;p&gt;Also, don't keep adding duplicate firewall rules just because connections time out. Check the existing rules first.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Find your Windows IP address
&lt;/h2&gt;

&lt;p&gt;Run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;ipconfig&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Find the IPv4 address of the network adapter you're actually using.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Wireless LAN adapter Wi-Fi:

IPv4 Address . . . . . : 192.168.1.100
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Your phone should connect to that LAN address, not &lt;code&gt;127.0.0.1&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Be careful if your PC has WSL2, Docker, Hyper-V, or VPN adapters. They can introduce extra IP addresses that aren't the right destination for your phone.&lt;/p&gt;

&lt;p&gt;From another Windows machine, you can test:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Test&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetConnection&lt;/span&gt; &lt;span class="mf"&gt;192.168&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mf"&gt;1.100&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Port&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Replace the address with your PC's actual IP.&lt;/p&gt;

&lt;p&gt;If localhost works but this test fails, check firewall profile matching, network isolation, security software, and whether you're connecting to the correct adapter.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Connect from Android or iPhone
&lt;/h2&gt;

&lt;p&gt;Now for the phone.&lt;/p&gt;

&lt;p&gt;I'm using &lt;a href="https://nimotecode.com/" rel="noopener noreferrer"&gt;NimoteCode&lt;/a&gt;, which supports Windows remote workspaces starting with version &lt;strong&gt;2.3.0&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F45bo476s86vcjrohrnd8.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F45bo476s86vcjrohrnd8.png" alt="nimotecode-win11" width="799" height="412"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Create an SSH workspace or connection with the following values:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Setting&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Connection name&lt;/td&gt;
&lt;td&gt;Windows 11 Dev PC&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Host&lt;/td&gt;
&lt;td&gt;192.168.1.100&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Port&lt;/td&gt;
&lt;td&gt;22&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Username&lt;/td&gt;
&lt;td&gt;Your Windows account username&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Authentication&lt;/td&gt;
&lt;td&gt;Password or SSH key&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Use your Windows account password, not your Windows Hello PIN. If you're using a Microsoft account, confirm the username recognized by OpenSSH.&lt;/p&gt;

&lt;p&gt;For a new connection, verify the SSH host-key fingerprint against the Windows machine before trusting it.&lt;/p&gt;

&lt;p&gt;Once connected, you can use the remote workspace to browse Windows files through SFTP, open and edit supported project files, and run PowerShell commands through the SSH terminal.&lt;/p&gt;

&lt;p&gt;For example, the remote terminal can run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Location&lt;/span&gt;
&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;ChildItem&lt;/span&gt;
&lt;span class="n"&gt;git&lt;/span&gt; &lt;span class="n"&gt;status&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Git commands require Git to be installed and available on the Windows host.&lt;/p&gt;

&lt;p&gt;A quick note about paths: Windows uses paths such as &lt;code&gt;C:\Users\YourName\Projects&lt;/code&gt;. SFTP presents paths through the server's remote filesystem interface, so the representation may differ from a local Windows file picker.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. SSH works, but SFTP doesn't?
&lt;/h2&gt;

&lt;p&gt;SSH and SFTP are related, but they aren't the same operation.&lt;/p&gt;

&lt;p&gt;An SSH terminal can work while the SFTP subsystem is incorrectly configured.&lt;/p&gt;

&lt;p&gt;Check your SSH server configuration:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;C:\ProgramData\ssh\sshd_config
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Look for the SFTP subsystem declaration.&lt;/p&gt;

&lt;p&gt;A typical Windows OpenSSH configuration uses:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Subsystem sftp sftp-server.exe
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If your configuration uses a different valid SFTP subsystem, don't blindly replace it.&lt;/p&gt;

&lt;p&gt;After making any changes, validate the configuration and restart SSH:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;sshd&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;
&lt;span class="nc"&gt;Restart&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Service&lt;/span&gt; &lt;span class="n"&gt;sshd&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also check SFTP independently from another machine:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;sftp username@192.168.1.100
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If this fails while normal SSH succeeds, investigate the SFTP subsystem, authentication, directory permissions, and server logs.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. What if port 22 still times out?
&lt;/h2&gt;

&lt;p&gt;Here's the troubleshooting order I'd recommend.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Symptom&lt;/th&gt;
&lt;th&gt;What to check&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Localhost port 22 fails&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;sshd&lt;/code&gt; service and listener&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Localhost works, phone times out&lt;/td&gt;
&lt;td&gt;Firewall, LAN IP, client isolation&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Connection refused&lt;/td&gt;
&lt;td&gt;Listener, port, firewall or network rejection&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Permission denied&lt;/td&gt;
&lt;td&gt;Windows username and authentication&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SSH works, SFTP fails&lt;/td&gt;
&lt;td&gt;SFTP subsystem and permissions&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Works on Wi-Fi but not cellular&lt;/td&gt;
&lt;td&gt;No public route or remote-access tunnel&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The most useful diagnostic commands are:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Service&lt;/span&gt; &lt;span class="n"&gt;sshd&lt;/span&gt;

&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetTCPConnection&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;LocalPort&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;State&lt;/span&gt; &lt;span class="nc"&gt;Listen&lt;/span&gt;

&lt;span class="nc"&gt;Test&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetConnection&lt;/span&gt; &lt;span class="mf"&gt;127.0&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="mf"&gt;0.1&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Port&lt;/span&gt; &lt;span class="mi"&gt;22&lt;/span&gt;

&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetConnectionProfile&lt;/span&gt;

&lt;span class="nc"&gt;Get&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;NetFirewallRule&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Name&lt;/span&gt; &lt;span class="s2"&gt;"OpenSSH-Server-In-TCP"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;
    &lt;span class="nc"&gt;Select&lt;/span&gt;&lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="nc"&gt;Object&lt;/span&gt; &lt;span class="nc"&gt;DisplayName&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Enabled&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Action&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;Profile&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;One more thing: &lt;code&gt;ping&lt;/code&gt; doesn't test TCP port 22. Use an actual TCP connectivity test instead.&lt;/p&gt;

&lt;p&gt;If you want to connect from outside your home network, a Windows Firewall rule alone isn't enough. You'll need a secure network path to the machine.&lt;/p&gt;

&lt;p&gt;I'd recommend a VPN or trusted private networking solution rather than exposing an SSH service directly to the public internet.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. What about WSL2?
&lt;/h2&gt;

&lt;p&gt;If you already use WSL2, you can keep Windows and Linux SSH access separate.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Windows OpenSSH: TCP 22
WSL2 SSH:        TCP 2222
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Your phone can then use different SSH connection profiles.&lt;/p&gt;

&lt;p&gt;But don't assume changing the WSL SSH port automatically makes it reachable through the Windows host's port 2222. Depending on your WSL networking mode, you may need additional forwarding or firewall configuration.&lt;/p&gt;

&lt;p&gt;For basic Windows SFTP and PowerShell access, WSL2 isn't necessary at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I wanted this working
&lt;/h2&gt;

&lt;p&gt;A phone isn't going to replace my full desktop development environment.&lt;/p&gt;

&lt;p&gt;But there are plenty of small tasks where opening a laptop feels unnecessary:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Checking a project or configuration file&lt;/li&gt;
&lt;li&gt;Editing a script&lt;/li&gt;
&lt;li&gt;Running a quick PowerShell command&lt;/li&gt;
&lt;li&gt;Reviewing a Git change&lt;/li&gt;
&lt;li&gt;Inspecting logs while away from the desk&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That's the kind of workflow I'm trying to improve with NimoteCode.&lt;/p&gt;

&lt;p&gt;The goal isn't to squeeze a full desktop onto a six-inch screen. It's to keep the useful parts of a development environment accessible when you're away from the keyboard.&lt;/p&gt;

&lt;p&gt;If you're using Windows 11 as your main development machine, SSH and SFTP are a good starting point.&lt;/p&gt;

&lt;p&gt;And if you're debugging a timeout despite having opened port 22, check the actual SSH listener and network profile before adding yet another firewall rule.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Useful links&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://nimotecode.com/" rel="noopener noreferrer"&gt;NimoteCode — Android &amp;amp; iOS mobile IDE&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://nimotecode.com/releases/2.3.0" rel="noopener noreferrer"&gt;NimoteCode 2.3.0 Release Notes&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://learn.microsoft.com/en-us/windows-server/administration/openssh/openssh_install_firstuse" rel="noopener noreferrer"&gt;Microsoft — Get started with OpenSSH for Windows&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;I'm building NimoteCode and working on making remote development from phones and tablets less awkward. If you've tried SSH/SFTP from your phone, I'd be interested to hear what still gets in your way.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>windows</category>
      <category>ssh</category>
      <category>tutorial</category>
      <category>productivity</category>
    </item>
    <item>
      <title>ARM64 Performance Tested: Can a Mobile Processor Handle Everyday Linux Development?</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Wed, 04 Nov 2026 07:33:10 +0000</pubDate>
      <link>https://dev.to/ma_dev/arm64-performance-tested-can-a-mobile-processor-handle-everyday-linux-development-29a3</link>
      <guid>https://dev.to/ma_dev/arm64-performance-tested-can-a-mobile-processor-handle-everyday-linux-development-29a3</guid>
      <description>&lt;p&gt;In the past few years, the performance improvement of ARM processors on the mobile side has been quite obvious.&lt;/p&gt;

&lt;p&gt;Today's mobile phone SoCs not only have multiple high-performance cores, but also considerable memory bandwidth and integer computing capabilities. But for developers, running scores are not always the most important indicator.&lt;/p&gt;

&lt;p&gt;A more practical question is: &lt;strong&gt;if a complete Linux development toolchain is placed in an ARM64 environment, how much real development work can it handle?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;For example, how long does it take for GCC to compile a real project? Can eight cores effectively shorten build times? Does a mobile processor’s high scores in CPU benchmarks mean that the actual development experience is good enough?&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;In order to answer these questions, I used my old mobile phone OnePlus Ace5 to install NimoteCode in the local linux environment and conducted several sets of tests, including CoreMark, SQLite source code compilation, and multi-file parallel construction.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The purpose is that I want to verify that, regardless of the compatibility issues of the Linux environment deployed on the mobile phone, can Android phones actually be used for development if they are installed with Linux? Is the performance up to standard or not?&lt;/p&gt;

&lt;p&gt;The actual test results were more interesting than I expected.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Test environment: Local linux deployed by NimoteCode, using built-in Ubuntu
&lt;/h2&gt;

&lt;p&gt;This test uses Ubuntu 24.04.4 LTS, running in an ARM64 container environment.&lt;/p&gt;

&lt;p&gt;The hardware configuration is as follows:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Item&lt;/th&gt;
&lt;th&gt;Configuration&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Operating system&lt;/td&gt;
&lt;td&gt;Ubuntu 24.04.4 LTS&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Architecture&lt;/td&gt;
&lt;td&gt;ARM64 / AArch64&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU&lt;/td&gt;
&lt;td&gt;8 cores&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Core configuration&lt;/td&gt;
&lt;td&gt;5 × Cortex-A720 + 1 × Cortex-A725 + 2 × Cortex-A520&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Memory&lt;/td&gt;
&lt;td&gt;10 GiB&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Compiler&lt;/td&gt;
&lt;td&gt;GCC 13.3.0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Build tool&lt;/td&gt;
&lt;td&gt;GNU Make&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CPU benchmark&lt;/td&gt;
&lt;td&gt;CoreMark v1.01&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Compilation test&lt;/td&gt;
&lt;td&gt;SQLite 3.54.1&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;This is a typical ARM heterogeneous multicore configuration: high-performance cores for compute-intensive work and energy-efficient cores for low-power tasks.&lt;/p&gt;

&lt;p&gt;There are some limitations to the test environment. The container blocks some CPU frequency and system hardware information, and the running frequency cannot be accurately obtained through the regular sysfs interface.&lt;/p&gt;

&lt;p&gt;An indirect estimate of about 2.34 GHz was obtained using a dependent addition chain, but since instruction latency and actual scheduling behavior cannot be fully confirmed, this value is not used as a basis for formal performance analysis.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It should be noted that this data comes from the PRoot environment of NimoteCode on the real Android machine. Therefore, it reflects the computing and compilation capabilities of the current ARM64 test environment and cannot be directly regarded as the actual test results of Android Local Linux.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Therefore, it reflects the computing and compilation capabilities of the current ARM64 test environment and cannot be directly regarded as the actual test results of Android Local Linux.&lt;/p&gt;

&lt;p&gt;For instructions on installing and setting up Local Linux in NimoteCode, see &lt;a href="https://nimotecode.com/docs/local-linux" rel="noopener noreferrer"&gt;https://nimotecode.com/docs/local-linux&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fof2lbfhi8gpjva16arxy.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fof2lbfhi8gpjva16arxy.png" alt="local linux deploy" width="800" height="537"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The actual test directly allows deepseek-flash to perform environment deployment and actual testing.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F480u14dtybw2b0oyy0q7.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F480u14dtybw2b0oyy0q7.png" alt="deepseek-flash run benchmark" width="799" height="430"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  2. CoreMark: Single-core is about 23,400, multi-core is over 144,000
&lt;/h2&gt;

&lt;p&gt;First test the basic computing power of the CPU.&lt;/p&gt;

&lt;p&gt;CoreMark is a processor benchmark test provided by EEMBC that involves workloads such as integer operations, linked list operations, matrix calculations, and state machines.&lt;/p&gt;

&lt;p&gt;Unlike some benchmarking tools that focus on graphics performance, CoreMark focuses more on the performance of the processor when performing general computing tasks.&lt;/p&gt;

&lt;p&gt;This test resulted in:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Test&lt;/th&gt;
&lt;th&gt;First run&lt;/th&gt;
&lt;th&gt;Second run&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Single-core CoreMark&lt;/td&gt;
&lt;td&gt;23,103&lt;/td&gt;
&lt;td&gt;23,764&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8-thread CoreMark&lt;/td&gt;
&lt;td&gt;143,087&lt;/td&gt;
&lt;td&gt;145,375&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The single-core score is about 23,400, and the 8-thread total score is about 144,200.&lt;/p&gt;



&lt;p&gt;What's worth noting here is the multi-threaded scalability.&lt;/p&gt;

&lt;p&gt;Instead of the ideal 8x improvement, 8 CPU cores resulted in about a 6.15x increase in throughput.&lt;/p&gt;

&lt;p&gt;This is not surprising.&lt;/p&gt;

&lt;p&gt;On the one hand, this processor adopts a heterogeneous architecture, and there are performance differences between Cortex-A520 and large cores; on the other hand, multi-threaded tasks may also be affected by frequency allocation, memory access, scheduling and power consumption limitations.&lt;/p&gt;

&lt;p&gt;However, for a mobile processor with only 8 physical cores, an expansion ratio of more than 6 times at least shows that under the current test load, parallel computing can indeed effectively utilize multiple cores.&lt;/p&gt;

&lt;p&gt;Of course, CoreMark primarily represents throughput capabilities for a specific computing workload. It doesn't directly answer how efficiently a GCC, Git, or Python project actually runs.&lt;/p&gt;

&lt;p&gt;Therefore, the next test is more meaningful.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. SQLite compilation: real projects deserve more attention than running scores
&lt;/h2&gt;

&lt;p&gt;In order to avoid testing only synthetic loads, the amalgamation source code of SQLite 3.54.1 was selected for compilation this time.&lt;/p&gt;

&lt;p&gt;SQLite is a very mature embedded database project, and its amalgamation version consolidates a large amount of implementation code into a single C source file.&lt;/p&gt;

&lt;p&gt;The source code used this time is about 271,131 lines, which can bring practical lexical analysis, syntax analysis, optimization and code generation work to the compiler.&lt;/p&gt;

&lt;p&gt;Test GCC's &lt;code&gt;-O0&lt;/code&gt; and &lt;code&gt;-O2&lt;/code&gt; optimization levels separately.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Build configuration&lt;/th&gt;
&lt;th&gt;Time&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;GCC &lt;code&gt;-O0&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;7.6 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GCC &lt;code&gt;-O2&lt;/code&gt;, first run&lt;/td&gt;
&lt;td&gt;34.0 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GCC &lt;code&gt;-O2&lt;/code&gt;, second run&lt;/td&gt;
&lt;td&gt;35.0 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The most interesting thing is the difference between &lt;code&gt;-O0&lt;/code&gt; and &lt;code&gt;-O2&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;When optimization is not turned on, compilation only takes about 7.6 seconds; after turning on &lt;code&gt;-O2&lt;/code&gt;, the time increases to about 34–35 seconds.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Optimized compilation takes approximately 4.5 times longer than non-optimized compilation.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;This is not just a matter of CPU speed.&lt;/p&gt;

&lt;p&gt;GCC will perform a more complex optimization process under &lt;code&gt;-O2&lt;/code&gt;, which requires additional analysis of code structure, control flow and data dependencies, and generates more efficient machine code.&lt;/p&gt;

&lt;p&gt;Large single-file compilations also place significant pressure on caches, memory accesses, and compiler internal data structures.&lt;/p&gt;

&lt;p&gt;This also explains why the processor performs well in basic CPU benchmarks, but still takes considerable time when faced with heavier optimization compilation tasks.&lt;/p&gt;

&lt;p&gt;This result is of great reference value for daily development.&lt;/p&gt;

&lt;p&gt;Assuming that the developer is maintaining a small C tool, fixing a piece of business logic, or modifying the compilation configuration, non-optimizing builds usually provide a shorter feedback cycle.&lt;/p&gt;

&lt;p&gt;And when the task becomes a complete optimized build of a large code base, the wait time can increase significantly.&lt;/p&gt;

&lt;p&gt;This is also a practical issue that needs to be considered in the mobile development environment: *&lt;em&gt;Not all code tasks require desktop-level computing power, but different tasks have very different requirements for local computing resources. *&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Parallel compilation: How much benefit can 8 cores bring?
&lt;/h2&gt;

&lt;p&gt;Single-file SQLite compilation mainly tests a single compilation process and cannot fully reflect the advantages of multi-core.&lt;/p&gt;

&lt;p&gt;Therefore, another set of tests was also conducted.&lt;/p&gt;

&lt;p&gt;Construct a test load of approximately 75,001 lines of C code, split it into independent compilation units, and measure serial and parallel build times with GNU Make.&lt;/p&gt;

&lt;p&gt;The result is as follows:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Build method&lt;/th&gt;
&lt;th&gt;Time&lt;/th&gt;
&lt;th&gt;Relative performance&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Serial compilation&lt;/td&gt;
&lt;td&gt;9.98 seconds&lt;/td&gt;
&lt;td&gt;1.00×&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8 parallel jobs&lt;/td&gt;
&lt;td&gt;1.60 seconds&lt;/td&gt;
&lt;td&gt;6.24×&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;From nearly 10 seconds to 1.6 seconds, the difference is noticeable.&lt;/p&gt;

&lt;p&gt;This result is also relatively close to the previous CoreMark multi-core expansion ratio.&lt;/p&gt;

&lt;p&gt;However, this does not mean that all projects can obtain more than 6 times speedup using &lt;code&gt;make -j8&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Real projects also contain header file dependencies, linking, generated code, file system operations, and build steps that cannot be parallelized.&lt;/p&gt;

&lt;p&gt;Some projects may even experience diminishing returns as they add parallel tasks due to memory pressure, I/O contention, and thermal constraints.&lt;/p&gt;

&lt;p&gt;In addition, the synthetic code load used this time cannot completely replace large-scale real projects such as LLVM and Chromium.&lt;/p&gt;

&lt;p&gt;But at least it can be confirmed: ARM64 multi-core has obvious parallel construction benefits for tasks that can be split into multiple independent compilation units. **&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Why can’t CPU running scores directly represent Linux development experience?
&lt;/h2&gt;

&lt;p&gt;At this point, a very important phenomenon can actually be observed.&lt;/p&gt;

&lt;p&gt;The performance of the same set of ARM64 hardware in different tests varies greatly.&lt;/p&gt;

&lt;p&gt;CoreMark demonstrates considerable integer computing capabilities, and multi-thread expansion is also ideal; however, the optimized compilation of SQLite still takes tens of seconds.&lt;/p&gt;

&lt;p&gt;The reason is not complicated: development workloads are far more complex than single-CPU benchmarks.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Compile C/C++ projects&lt;/strong&gt;, mainly involving compiler calculations, memory access, process scheduling, and file reading and writing.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Running Git&lt;/strong&gt;, in addition to calculating hashes, may also traverse files, read metadata, and frequently access the storage system.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Installing software dependencies&lt;/strong&gt; will mix network requests, decompression, verification, script execution and small file operations.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Running a Python or Node.js toolchain&lt;/strong&gt;, in turn involves interpreter or runtime startup, module loading, dependency resolution, and extensive file system access.&lt;/p&gt;

&lt;p&gt;Therefore, a CPU with a high CoreMark score does not necessarily prove that its development experience is good.&lt;/p&gt;

&lt;p&gt;Especially when running a Linux user-mode environment on Android, additional considerations need to be made about the operating mechanism.&lt;/p&gt;

&lt;p&gt;For example PRoot.&lt;/p&gt;

&lt;p&gt;PRoot can provide a Linux user-mode file system environment without obtaining Android root permissions, but it is not a virtual machine or a native Linux kernel.&lt;/p&gt;

&lt;p&gt;It needs to handle process execution and some system call related operations. These additional overheads may have an impact on tasks that frequently access the file system and create processes.&lt;/p&gt;

&lt;p&gt;This brings up a question worthy of separate measurement:&lt;/p&gt;

&lt;p&gt;How much difference will the performance of the same piece of C code differ when executed in the Android native environment and the PRoot Ubuntu environment?&lt;/p&gt;

&lt;p&gt;The answer cannot be given based on the previous CoreMark and SQLite data alone.&lt;/p&gt;

&lt;p&gt;To answer this question, we need to measure the performance of native and PRoot environments using comparable compiler configurations on the same Android device.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. What is the real value of Linux development on mobile devices?
&lt;/h2&gt;

&lt;p&gt;After completing these sets of tests, I feel that the actual workflow is more worthy of attention in the mobile development environment than pursuing a certain CPU score.&lt;/p&gt;

&lt;p&gt;Mobile devices don't need to take on all desktop development tasks.&lt;/p&gt;

&lt;p&gt;But if it can already run a complete compiler, interpreter and basic Linux tool chain, then many lightweight development operations that originally relied on computers could theoretically be completed locally.&lt;/p&gt;

&lt;p&gt;For example:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;  Temporarily modify a piece of code, compile and verify the results.&lt;/li&gt;
&lt;li&gt;  View and manage changes in your local Git repository.&lt;/li&gt;
&lt;li&gt;  Run scripts, process text, or debug small tools.&lt;/li&gt;
&lt;li&gt;  Complete some development work without a remote server connection.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is also the direction I have been focusing on when developing NimoteCode.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;NimoteCode is a mobile IDE for Android and iOS. It initially focused on SSH remote development, and later gradually added Android Local Linux.&lt;/strong&gt;&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;It provides an Ubuntu user-mode environment through PRoot on supported Android devices, without requiring root permissions or additional installation of independent terminal applications.&lt;/p&gt;

&lt;p&gt;Rather than simply providing a Linux shell, NimoteCode connects local Linux workspaces to existing file browsers, editors, terminals, Git, and AI-assisted development processes. The tool chain still needs to be installed according to project needs, and there are compatibility limitations for some debugging and system-level functions.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This design is not to package the phone into a high-performance workstation, but to allow developers to complete some truly useful work on the mobile device.&lt;/p&gt;

&lt;p&gt;Of course, whether it is easy to use also depends on factors such as file operations, compilation time, keyboard interaction, process stability, and Android background life cycle.&lt;/p&gt;

&lt;p&gt;None of this can be proven by just one CPU benchmark.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Conclusion at this stage: ARM64 already has practical development capabilities, but the boundaries need to be measured.
&lt;/h2&gt;

&lt;p&gt;Looking back on this test, several results are worthy of attention.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Metric&lt;/th&gt;
&lt;th&gt;Result&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Single-core CoreMark&lt;/td&gt;
&lt;td&gt;About 23,400&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8-thread CoreMark&lt;/td&gt;
&lt;td&gt;About 144,200&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Multicore scaling ratio&lt;/td&gt;
&lt;td&gt;About 6.15×&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SQLite &lt;code&gt;-O0&lt;/code&gt; build&lt;/td&gt;
&lt;td&gt;7.6 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;SQLite &lt;code&gt;-O2&lt;/code&gt; build&lt;/td&gt;
&lt;td&gt;34–35 seconds&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Parallel multi-file build speed-up&lt;/td&gt;
&lt;td&gt;About 6.24×&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These data at least show that in this ARM64 Ubuntu container environment, GCC can complete the compilation of real C projects of a certain scale, and multi-core can also bring obvious performance gains to independent compilation tasks.&lt;/p&gt;

&lt;p&gt;But they don't directly prove Android PRoot's performance, nor are they sufficient to tell which generation of Intel or AMD desktop CPUs the processor is equivalent to.&lt;/p&gt;

&lt;p&gt;There are several limitations to the test: CoreMark needs to further verify the complete operating parameters; there is no x86 comparison under the same conditions; long-term continuous load testing has not yet been conducted; Git, APT, small file I/O and Android PRoot overhead are not included in this data.&lt;/p&gt;

&lt;p&gt;A more worthwhile follow-up test is to compare the real build times of the native running environment, Termux and PRoot Ubuntu on the same Android device, and observe the performance changes under sustained load.&lt;/p&gt;

&lt;p&gt;From a practical development perspective, I am increasingly inclined to understand mobile Linux this way:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It doesn't necessarily need to replace a computer, but it should keep developers from having to go back to the computer for every simple code change, compile verification, and Git operation.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;For lightweight tasks, local execution reduces reliance on the network and remote servers; for larger builds, a workstation or server with a stronger SSH connection still makes more sense.&lt;/p&gt;

&lt;p&gt;There is no conflict between the two ways of working.&lt;/p&gt;

&lt;p&gt;Perhaps the real direction worth exploring for mobile IDEs in the future is not to simply copy desktop IDEs, but to allow local Linux, remote development and AI tool chains to be naturally connected in the same workflow.&lt;/p&gt;

&lt;p&gt;This is more worthy of continuous verification than simply discussing the running scores of mobile phone processors.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Tests and References&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;  CoreMark： &lt;a href="https://www.eembc.org/coremark/" rel="noopener noreferrer"&gt;https://www.eembc.org/coremark/&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;  SQLite 3.54.1 source code： &lt;a href="https://www.sqlite.org/download.html" rel="noopener noreferrer"&gt;https://www.sqlite.org/download.html&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;  NimoteCode Android Local Linux doc:  &lt;a href="https://nimotecode.com/docs/local-linux" rel="noopener noreferrer"&gt;https://nimotecode.com/docs/local-linux&lt;/a&gt;
&lt;/li&gt;
&lt;li&gt;  NimoteCode offical website： &lt;a href="https://nimotecode.com/" rel="noopener noreferrer"&gt;https://nimotecode.com&lt;/a&gt;
&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzlqupwf0ze9j0soxffgm.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fzlqupwf0ze9j0soxffgm.png" alt="NimoteCode" width="800" height="395"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;*The test data is based on the Local Linux:Ubuntu environment deployed by NimoteCode described in this article. Results are not representative of performance on other devices and do not constitute a performance guarantee for the Android PRoot environment. *&lt;/p&gt;

</description>
      <category>hardware</category>
      <category>linux</category>
      <category>performance</category>
      <category>softwaredevelopment</category>
    </item>
    <item>
      <title>I Got Tired of Making App Store Screenshots, So I Built an Open-Source Tool</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Tue, 03 Nov 2026 01:23:27 +0000</pubDate>
      <link>https://dev.to/ma_dev/i-got-tired-of-making-app-store-screenshots-so-i-built-an-open-source-tool-3h4p</link>
      <guid>https://dev.to/ma_dev/i-got-tired-of-making-app-store-screenshots-so-i-built-an-open-source-tool-3h4p</guid>
      <description>&lt;p&gt;Shipping an app is fun. Preparing the App Store screenshots? Not so much.&lt;/p&gt;

&lt;p&gt;You finish building a feature, fix the last few bugs, and finally get your release ready. Then you open App Store Connect or Google Play Console and remember there's still another job to do: create a complete set of promotional screenshots.&lt;/p&gt;

&lt;p&gt;Different device sizes. Different layouts. Titles and subtitles. Multiple languages. And every time you change something, you potentially have to export everything again.&lt;/p&gt;

&lt;p&gt;I've been working on &lt;a href="https://nimotecode.com" rel="noopener noreferrer"&gt;NimoteCode&lt;/a&gt;, a mobile IDE for Android and iOS, and this became one of those repetitive tasks I really didn't want to keep doing manually.&lt;/p&gt;

&lt;p&gt;So I built &lt;strong&gt;NimoteShot&lt;/strong&gt;, a free, open-source screenshot generator for App Store and Google Play listings.&lt;/p&gt;

&lt;p&gt;GitHub: &lt;a href="https://github.com/mobiledevloperlab/nimoteshot" rel="noopener noreferrer"&gt;https://github.com/mobiledevloperlab/nimoteshot&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The idea is straightforward: use AI to understand real app screenshots and help write the marketing copy, but keep the actual image generation deterministic, editable, and local.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvbg4ezay8xoxfi41xrvt.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fvbg4ezay8xoxfi41xrvt.png" alt="NimoteShot screenshot editor" width="800" height="453"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem isn't taking screenshots
&lt;/h2&gt;

&lt;p&gt;Taking a screenshot is easy.&lt;/p&gt;

&lt;p&gt;Turning that screenshot into something suitable for an app listing is where the work starts.&lt;/p&gt;

&lt;p&gt;A typical workflow looks something like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Capture the app on a real device or emulator.&lt;/li&gt;
&lt;li&gt;Import the screenshot into a design tool.&lt;/li&gt;
&lt;li&gt;Choose a background, device frame, and typography.&lt;/li&gt;
&lt;li&gt;Write a short headline that explains the feature.&lt;/li&gt;
&lt;li&gt;Adjust everything for different screen dimensions.&lt;/li&gt;
&lt;li&gt;Translate the text and repeat the layout work.&lt;/li&gt;
&lt;li&gt;Export the assets and check that they meet store requirements.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;It's manageable for one release. It gets frustrating when you're maintaining multiple languages and shipping updates frequently.&lt;/p&gt;

&lt;p&gt;I looked at this as a developer rather than a designer: most of the process follows a repeatable set of rules.&lt;/p&gt;

&lt;p&gt;The parts that need judgment are understanding what a screen does, deciding which features matter, and writing good copy.&lt;/p&gt;

&lt;p&gt;The rest should be something software can handle.&lt;/p&gt;

&lt;h2&gt;
  
  
  What NimoteShot does
&lt;/h2&gt;

&lt;p&gt;NimoteShot takes real screenshots of your app and turns them into promotional images for iPhone, iPad, and Android listings.&lt;/p&gt;

&lt;p&gt;You can give it your app name, a short description or website, and your original screenshots.&lt;/p&gt;

&lt;p&gt;A vision-capable AI model can analyze the visible interface and draft headlines, subtitles, and a design direction.&lt;/p&gt;

&lt;p&gt;You can then review everything in a browser-based editor, change the text or layout, and export the finished images.&lt;/p&gt;

&lt;p&gt;Here's an example using NimoteCode.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Original app screenshot:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjed5ihe1xhc5vfk28xap.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjed5ihe1xhc5vfk28xap.png" alt="Original NimoteCode app screenshot" width="800" height="1738"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Generated promotional screenshot:&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjdku429zw1o4vxdpm1rw.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjdku429zw1o4vxdpm1rw.png" alt="NimoteCode promotional screenshot generated with NimoteShot" width="800" height="1738"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The important detail is that the actual app interface remains the source material.&lt;/p&gt;

&lt;p&gt;I didn't want an image model inventing buttons, changing code in the editor, or producing a beautiful-looking interface that doesn't exist in the app.&lt;/p&gt;

&lt;p&gt;AI should help explain the product, not fabricate it.&lt;/p&gt;

&lt;h2&gt;
  
  
  AI for decisions, local code for rendering
&lt;/h2&gt;

&lt;p&gt;This is probably the most important design decision in NimoteShot.&lt;/p&gt;

&lt;p&gt;I separated the process into two responsibilities.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;AI handles interpretation and copywriting.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A vision model examines the screenshots and product context, then helps draft the feature descriptions and visual direction.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The local rendering engine handles the final images.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It applies the selected templates, typography, backgrounds, layouts, and output dimensions.&lt;/p&gt;

&lt;p&gt;That separation makes a surprisingly big difference.&lt;/p&gt;

&lt;p&gt;Imagine you've generated six promotional screenshots and notice that the headline on the third one is too long.&lt;/p&gt;

&lt;p&gt;With a fully generative approach, you might need to ask the model to generate that image again, potentially changing other visual details in the process.&lt;/p&gt;

&lt;p&gt;With NimoteShot, you edit the headline directly.&lt;/p&gt;

&lt;p&gt;The affected preview is rendered locally. No additional AI request is needed.&lt;/p&gt;

&lt;p&gt;You can also adjust the colors, templates, and order of the screens without rerunning the entire analysis.&lt;/p&gt;

&lt;p&gt;I wanted something closer to an editable design tool than a one-click AI image generator.&lt;/p&gt;

&lt;h2&gt;
  
  
  Localization shouldn't mean rebuilding everything
&lt;/h2&gt;

&lt;p&gt;Another part I wanted to improve was localization.&lt;/p&gt;

&lt;p&gt;NimoteShot currently supports &lt;strong&gt;17 output languages&lt;/strong&gt;, including English, Chinese, Japanese, Korean, Spanish, French, German, Portuguese, Hindi, Arabic, and others.&lt;/p&gt;

&lt;p&gt;Each language can have its own editable copy.&lt;/p&gt;

&lt;p&gt;That matters because localization is not simply replacing one string with another.&lt;/p&gt;

&lt;p&gt;A short English headline might become much longer in German. Chinese and Japanese have different typography requirements. Arabic and Hebrew need appropriate text shaping.&lt;/p&gt;

&lt;p&gt;NimoteShot uses bundled fonts selected according to character coverage, with complex-script shaping support where the required dependencies are available.&lt;/p&gt;

&lt;p&gt;The goal is to keep the workflow consistent across languages while still allowing developers to review and refine every translation.&lt;/p&gt;

&lt;p&gt;AI-generated text is a starting point, not something that should go straight into production without review.&lt;br&gt;
&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiawzhrvblr65au6d9qnr.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fiawzhrvblr65au6d9qnr.png" alt="NimoteShot product build a full store set in four steps" width="800" height="569"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  You can use it without AI
&lt;/h2&gt;

&lt;p&gt;Although NimoteShot has AI in its name, I didn't want an API key to be mandatory.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftyhbg0bd7x2uoelaote5.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ftyhbg0bd7x2uoelaote5.png" alt="NimoteShot product preview and refine workflow" width="800" height="613"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;There's a manual design mode that works without a model.&lt;/p&gt;

&lt;p&gt;You can upload your screenshots, select a design, edit the text, preview the result, and export the images locally.&lt;/p&gt;

&lt;p&gt;If you want AI assistance, you can configure a supported vision-capable provider.&lt;/p&gt;

&lt;p&gt;The project supports several provider integrations, including DeepSeek, Qwen, Gemini, Claude, OpenAI-compatible APIs, Ollama, and others, subject to the capabilities of the selected model.&lt;/p&gt;

&lt;p&gt;The software itself is free and open source. Cloud model providers may charge for their API usage.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fegm5duv72scvk61qnxgf.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fegm5duv72scvk61qnxgf.png" alt="NimoteCode screenshots result" width="800" height="849"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;One privacy distinction is worth making: rendering and exporting happen locally, but AI screenshot analysis sends the selected captures and product context to the configured model provider. If you need to keep everything local, use manual design or a compatible locally hosted model.&lt;/p&gt;
&lt;h2&gt;
  
  
  Getting started
&lt;/h2&gt;

&lt;p&gt;NimoteShot runs on Windows, macOS, and Linux, with Python 3.11 or newer.&lt;/p&gt;

&lt;p&gt;Clone the repository:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git clone https://github.com/mobiledevloperlab/nimoteshot.git
&lt;span class="nb"&gt;cd &lt;/span&gt;nimoteshot
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On macOS or Linux:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;./install.sh
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;On Windows, run this in PowerShell:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight powershell"&gt;&lt;code&gt;&lt;span class="n"&gt;powershell&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-ExecutionPolicy&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nx"&gt;Bypass&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="nt"&gt;-File&lt;/span&gt;&lt;span class="w"&gt; &lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;\install.ps1&lt;/span&gt;&lt;span class="w"&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The installer creates a Python virtual environment, installs dependencies, and starts the local web studio.&lt;/p&gt;

&lt;p&gt;By default, the interface is available at:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;http://127.0.0.1:8765
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Use the URL printed by the installer if it chooses another port.&lt;/p&gt;

&lt;p&gt;From there, the workflow is:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Enter your app's name and product description.&lt;/li&gt;
&lt;li&gt;Upload your real screenshots.&lt;/li&gt;
&lt;li&gt;Select the target devices and languages.&lt;/li&gt;
&lt;li&gt;Choose AI-assisted generation or manual design.&lt;/li&gt;
&lt;li&gt;Review and edit the previews.&lt;/li&gt;
&lt;li&gt;Export the PNG files or download a ZIP package.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The exported assets include the selected device resolutions, and the task configuration can be kept for later edits.&lt;/p&gt;

&lt;p&gt;For developers who prefer automation, there's also a CLI.&lt;/p&gt;

&lt;p&gt;For example, after configuring a compatible provider:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;.venv/bin/python scripts/nimoteshot.py generate &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--brand&lt;/span&gt; &lt;span class="s2"&gt;"My App"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--description&lt;/span&gt; &lt;span class="s2"&gt;"A mobile editor with SSH, Git and terminal tools"&lt;/span&gt; &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--provider&lt;/span&gt; qwen &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--style&lt;/span&gt; editorial &lt;span class="se"&gt;\&lt;/span&gt;
  &lt;span class="nt"&gt;--locales&lt;/span&gt; zh-CN,fr-FR,ja-JP
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I like having both options: a visual workflow when I want to refine the design and a command-line workflow when I want something more repeatable.&lt;/p&gt;

&lt;h2&gt;
  
  
  A few implementation details
&lt;/h2&gt;

&lt;p&gt;NimoteShot is built with Python and includes a local web editor, AI-provider integrations, and an image-rendering pipeline.&lt;/p&gt;

&lt;p&gt;Some of the less visible features are the ones I find most useful:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Incremental previews:&lt;/strong&gt; Editing one screen doesn't require regenerating every other screen.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stale-response protection:&lt;/strong&gt; Older preview results are prevented from replacing newer edits.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Editable configurations:&lt;/strong&gt; You can return to a saved task rather than starting over.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Multi-resolution exports:&lt;/strong&gt; The renderer produces PNGs for supported device and orientation targets.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Source traceability:&lt;/strong&gt; Original captures are archived with a SHA-256 source manifest.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These aren't particularly flashy features, but they make the difference between a demo and a tool that's practical to use during a release.&lt;/p&gt;

&lt;p&gt;The current project also includes automated tests covering editing, previews, language switching, and exports.&lt;/p&gt;

&lt;h2&gt;
  
  
  What it doesn't try to do
&lt;/h2&gt;

&lt;p&gt;NimoteShot isn't intended to replace a professional designer or make every creative decision automatically.&lt;/p&gt;

&lt;p&gt;You still need to choose which features deserve attention, review the generated copy, and check the exported images before submitting them to the stores.&lt;/p&gt;

&lt;p&gt;It also doesn't guarantee that every possible Apple or Google Play listing requirement will remain unchanged. Store specifications evolve, so the final submission should always be reviewed against the current requirements.&lt;/p&gt;

&lt;p&gt;What it does try to eliminate is the repetitive work between having real screenshots and preparing usable promotional assets.&lt;/p&gt;

&lt;p&gt;And for me, that's already valuable.&lt;/p&gt;

&lt;h2&gt;
  
  
  Open source, and I'd love feedback
&lt;/h2&gt;

&lt;p&gt;NimoteShot is available on GitHub under &lt;strong&gt;AGPL-3.0-or-later&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;It's still a growing project, and I'd particularly appreciate feedback from developers who publish apps in multiple languages or maintain both Android and iOS releases.&lt;/p&gt;

&lt;p&gt;I'm interested in hearing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Which part of preparing store screenshots takes you the most time?&lt;/li&gt;
&lt;li&gt;Would you rather use a browser editor or automate screenshot generation through a CLI?&lt;/li&gt;
&lt;li&gt;What would make this useful enough to include in your release workflow?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you want to try it, here's the repository:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;&lt;a href="https://github.com/mobiledevloperlab/nimoteshot" rel="noopener noreferrer"&gt;NimoteShot on GitHub&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Issues, bug reports, design suggestions, and pull requests are welcome.&lt;/p&gt;

&lt;p&gt;And if the project saves you some time before your next app release, that's exactly why I built it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxin7ruhnwhl3uhvb4add.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fxin7ruhnwhl3uhvb4add.png" alt="nimoteshot github promotion" width="800" height="480"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;p&gt;&lt;em&gt;Built while working on &lt;a href="https://nimotecode.com" rel="noopener noreferrer"&gt;NimoteCode&lt;/a&gt;, my mobile development IDE. The screenshots in this post come from the open-source NimoteShot repository and its NimoteCode demo.&lt;/em&gt;&lt;/p&gt;

</description>
    </item>
    <item>
      <title>I Compared 7 Mobile Coding Tools — Here's Why I'm Building NimoteCode</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Sun, 18 Oct 2026 17:58:07 +0000</pubDate>
      <link>https://dev.to/ma_dev/i-compared-7-mobile-coding-tools-heres-why-im-building-nimotecode-39hn</link>
      <guid>https://dev.to/ma_dev/i-compared-7-mobile-coding-tools-heres-why-im-building-nimotecode-39hn</guid>
      <description>&lt;p&gt;I've been working on &lt;strong&gt;NimoteCode&lt;/strong&gt;, a mobile IDE for Android and iOS, for the past few months.&lt;/p&gt;

&lt;p&gt;One thing I've noticed: mobile development tools are getting better, especially with AI coding agents like Claude Code and Codex.&lt;/p&gt;

&lt;p&gt;But most mobile workflows still revolve around one thing: &lt;strong&gt;connecting to another machine and controlling what's running there.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I wanted to explore a different approach.&lt;/p&gt;

&lt;h2&gt;
  
  
  The Current Mobile Coding Landscape
&lt;/h2&gt;

&lt;p&gt;I recently compared seven mobile development tools:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Main Focus&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Termius&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;SSH and server management&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Blink Shell&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;SSH, Mosh, and remote coding&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Redock&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Mobile terminal for remote AI agents&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Orca&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Desktop AI agent environment with mobile access&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;ServerCC&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Remote coding-agent workflows&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Moshi&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Agent-aware SSH/Mosh terminal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;NimoteCode&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Integrated mobile development workspace&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;These tools solve different problems, and each has its strengths.&lt;/p&gt;

&lt;p&gt;But I kept coming back to the same question:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What if your phone or tablet could be a real development workspace, not just a remote terminal?&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What I'm Building with NimoteCode
&lt;/h2&gt;

&lt;p&gt;NimoteCode is built with Flutter and Rust, with the goal of bringing familiar IDE workflows to mobile devices.&lt;/p&gt;

&lt;p&gt;Here's what's already available:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Code Editor&lt;/strong&gt; — Edit source code directly on your phone, with Monaco on tablets.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SSH &amp;amp; Terminal&lt;/strong&gt; — Work with remote development environments.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Git Integration&lt;/strong&gt; — Review changes, inspect diffs, manage branches, and resolve conflicts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AI Coding Agents&lt;/strong&gt; — Built-in AI Agent and support for external agents through ACP.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Android Local Linux&lt;/strong&gt; — Run a Linux development environment directly on Android without root.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mobile &amp;amp; Tablet UI&lt;/strong&gt; — Dedicated layouts for portrait and landscape workflows.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The important part isn't any single feature.&lt;/p&gt;

&lt;p&gt;It's being able to switch between your editor, terminal, Git changes, and AI agent without constantly jumping between different apps.&lt;/p&gt;

&lt;p&gt;Some advanced features require Pro or additional host configuration, and certain workflows have platform-specific limitations.&lt;/p&gt;

&lt;h2&gt;
  
  
  Local Development on Android Is Especially Interesting
&lt;/h2&gt;

&lt;p&gt;One feature I've been experimenting with is running Linux locally on Android.&lt;/p&gt;

&lt;p&gt;Instead of always connecting to a remote machine, you can use a local Linux environment and install development tools inside it.&lt;/p&gt;

&lt;p&gt;No root required.&lt;/p&gt;

&lt;p&gt;Of course, it won't replace a powerful desktop workstation for every project. But for scripting, smaller projects, terminal workflows, and experimentation, I think there's a lot of potential.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I've Learned
&lt;/h2&gt;

&lt;p&gt;After comparing these tools, I don't think there's one perfect mobile development solution.&lt;/p&gt;

&lt;p&gt;If you primarily manage servers, Termius or Blink might be exactly what you need.&lt;/p&gt;

&lt;p&gt;If your workflow revolves around controlling AI agents on another machine, Redock, Moshi, ServerCC, and Orca have interesting approaches.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;NimoteCode is my attempt to bring more of the actual IDE experience onto the mobile device.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;It's still evolving, and there's plenty to improve.&lt;/p&gt;

&lt;p&gt;I've published a more detailed, evidence-linked comparison here:&lt;/p&gt;

&lt;p&gt;👉 &lt;strong&gt;&lt;a href="https://nimotecode.com/compare/mobile-ai-development-tools" rel="noopener noreferrer"&gt;Compare 7 Mobile Development Tools&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;You can also explore NimoteCode here:&lt;/p&gt;

&lt;p&gt;🌐 &lt;strong&gt;&lt;a href="https://nimotecode.com" rel="noopener noreferrer"&gt;NimoteCode Official Website&lt;/a&gt;&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Available for Android and iOS.&lt;/p&gt;

&lt;h2&gt;
  
  
  &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo00qjfw6yz80uuey9uid.webp" alt=" " width="800" height="450"&gt;
&lt;/h2&gt;

&lt;p&gt;I'm curious how other developers feel about mobile coding.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Would you actually write and edit code on your phone or tablet, or do you prefer using mobile devices only to control remote AI agents?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I'd love to hear what your ideal mobile development setup looks like.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>productivity</category>
      <category>agents</category>
    </item>
    <item>
      <title>Why the Same AI Model Can Feel Completely Different Across Coding Agents</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Tue, 08 Sep 2026 10:35:14 +0000</pubDate>
      <link>https://dev.to/ma_dev/why-the-same-ai-model-can-feel-completely-different-across-coding-agents-3p5n</link>
      <guid>https://dev.to/ma_dev/why-the-same-ai-model-can-feel-completely-different-across-coding-agents-3p5n</guid>
      <description>&lt;p&gt;A while ago, I tried building my own coding agent.&lt;/p&gt;

&lt;p&gt;My goal was not to compete with Claude Code or other mature coding agents. I simply wanted to reach what I personally considered a level where the agent was reliable enough to handle real development tasks.&lt;/p&gt;

&lt;p&gt;After a lot of work, it eventually reached the point where it could complete many ordinary tasks.&lt;/p&gt;

&lt;p&gt;Then I started running benchmarks.&lt;/p&gt;

&lt;p&gt;That was when I realized that getting an agent to &lt;em&gt;work&lt;/em&gt; and getting an agent to work &lt;em&gt;reliably&lt;/em&gt; are two very different problems.&lt;/p&gt;

&lt;p&gt;The deeper I went, the more convinced I became of one idea:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;The model determines the capability ceiling of an agent, but the runtime determines how much of that capability is actually realized.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Eventually, I started thinking about agents in another way:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;An agent is a bounded optimization process.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Here is how I arrived at that conclusion.&lt;/p&gt;




&lt;h2&gt;
  
  
  1. From a Phrase-Driven Loop to a Task-Driven Runtime
&lt;/h2&gt;

&lt;p&gt;My first implementation was relatively simple.&lt;/p&gt;

&lt;p&gt;Conceptually, the loop looked something like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Model says what it wants to do
        ↓
Runtime executes it
        ↓
Model sees the result
        ↓
Runtime follows the next instruction
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;I think of this as a &lt;strong&gt;phrase-driven&lt;/strong&gt; agent.&lt;/p&gt;

&lt;p&gt;The runtime is largely following what the model says from one turn to the next.&lt;/p&gt;

&lt;p&gt;This can work surprisingly well for simple tasks.&lt;/p&gt;

&lt;p&gt;But anyone who has used LLMs extensively has probably seen the failure modes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;the model drifts away from the original task,&lt;/li&gt;
&lt;li&gt;repeats something it has already done,&lt;/li&gt;
&lt;li&gt;forgets earlier state,&lt;/li&gt;
&lt;li&gt;believes an operation succeeded when it did not,&lt;/li&gt;
&lt;li&gt;or declares completion too early.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;I later changed the architecture toward something more &lt;strong&gt;task-driven&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;What is the current task state?
        ↓
What is still missing?
        ↓
Execute the next step
        ↓
Verify the result
        ↓
Update task state
        ↓
Continue
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The important difference is that the runtime no longer advances purely because the model produced another instruction.&lt;/p&gt;

&lt;p&gt;It advances according to the &lt;strong&gt;state of the task&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That change noticeably improved stability.&lt;/p&gt;

&lt;p&gt;But it also made me realize how much engineering sits between an LLM and a reliable coding agent.&lt;/p&gt;

&lt;p&gt;Eventually, I stopped trying to build the whole thing myself.&lt;/p&gt;

&lt;p&gt;Not because the model was incapable of writing code, but because the runtime itself had become a serious systems-engineering problem.&lt;/p&gt;




&lt;h2&gt;
  
  
  2. What Building With AI Taught Me About Software Engineering
&lt;/h2&gt;

&lt;p&gt;Modern coding models make it possible for an individual developer to build things that would previously have required far more time or a larger team.&lt;/p&gt;

&lt;p&gt;If your objective is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Get something running first.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;AI is extremely effective.&lt;/p&gt;

&lt;p&gt;A website, a prototype, a demo application, or an early version of a product can often be built much faster than before.&lt;/p&gt;

&lt;p&gt;But the situation changes when the goal becomes:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Stable, production-ready, and maintainable for years.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The larger the codebase becomes, the more important architecture, constraints, review and verification become.&lt;/p&gt;

&lt;p&gt;AI continues to help, but raw code generation stops being the main bottleneck.&lt;/p&gt;

&lt;p&gt;I repeatedly ran into three problems.&lt;/p&gt;

&lt;h3&gt;
  
  
  2.1 AI Can Generate Technical Debt Extremely Quickly
&lt;/h3&gt;

&lt;p&gt;AI is very good at solving the immediate problem in front of it.&lt;/p&gt;

&lt;p&gt;A bug appears here:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Add another condition.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A state mismatch appears somewhere else:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Add a fallback.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Another integration breaks:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Add a compatibility path.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Each individual change can look reasonable.&lt;/p&gt;

&lt;p&gt;But after dozens of iterations, the accumulated result can look very different:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;duplicated logic,&lt;/li&gt;
&lt;li&gt;temporary state that became permanent,&lt;/li&gt;
&lt;li&gt;overlapping compatibility layers,&lt;/li&gt;
&lt;li&gt;excessive fallbacks,&lt;/li&gt;
&lt;li&gt;abstractions wrapping other abstractions,&lt;/li&gt;
&lt;li&gt;and code whose original design intent is increasingly difficult to recover.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This happens partly because understanding a large repository is still a retrieval problem.&lt;/p&gt;

&lt;p&gt;An agent normally sees only a subset of the codebase at any particular moment. It searches, reads files, follows symbols, retrieves additional context and progressively constructs a picture of the system.&lt;/p&gt;

&lt;p&gt;That picture is necessarily incomplete.&lt;/p&gt;

&lt;p&gt;Without deliberate refactoring and architectural control, local fixes accumulate.&lt;/p&gt;

&lt;p&gt;One of the strongest lessons I took away from this was:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;AI dramatically increases the speed of code generation, but if architecture, review and refactoring do not keep pace, it can generate technical debt at roughly the same speed.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h3&gt;
  
  
  2.2 Your Ability to Evaluate the Result Still Matters
&lt;/h3&gt;

&lt;p&gt;This became increasingly obvious as my project became more complex.&lt;/p&gt;

&lt;p&gt;Suppose the problem requires knowledge beyond your own current ability.&lt;/p&gt;

&lt;p&gt;The AI produces a solution.&lt;/p&gt;

&lt;p&gt;Now you still have to answer:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Is the architecture actually reasonable?&lt;/li&gt;
&lt;li&gt;Did it really fix the bug?&lt;/li&gt;
&lt;li&gt;Did it merely work around the bug?&lt;/li&gt;
&lt;li&gt;Is the test meaningful?&lt;/li&gt;
&lt;li&gt;Is the system now more fragile?&lt;/li&gt;
&lt;li&gt;Is there a better abstraction?&lt;/li&gt;
&lt;li&gt;What should be done next?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If you cannot evaluate those questions, development becomes increasingly difficult.&lt;/p&gt;

&lt;p&gt;A common response is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“Just use a stronger coding model.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;I spent thousands of RMB experimenting with different frontier models.&lt;/p&gt;

&lt;p&gt;There were absolutely differences between them.&lt;/p&gt;

&lt;p&gt;Some planned better. Some followed instructions more reliably. Some handled large refactors better. Some were more consistent with tools.&lt;/p&gt;

&lt;p&gt;But none of them eliminated the fundamental problem:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;The complexity of the project you can safely build is still influenced by your ability to understand and evaluate what is being built.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;A stronger model expands that boundary.&lt;/p&gt;

&lt;p&gt;It does not make evaluation unnecessary.&lt;/p&gt;

&lt;h3&gt;
  
  
  2.3 Complex Software Depends More on Constraints Than Cleverness
&lt;/h3&gt;

&lt;p&gt;Large systems usually do not remain reliable because one function is exceptionally intelligent.&lt;/p&gt;

&lt;p&gt;They remain reliable because they have structure:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;clear module boundaries,&lt;/li&gt;
&lt;li&gt;stable interfaces,&lt;/li&gt;
&lt;li&gt;explicit state transitions,&lt;/li&gt;
&lt;li&gt;controlled dependencies,&lt;/li&gt;
&lt;li&gt;type constraints,&lt;/li&gt;
&lt;li&gt;tests,&lt;/li&gt;
&lt;li&gt;invariants,&lt;/li&gt;
&lt;li&gt;and layers that compose in relatively predictable ways.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If the entire architecture is continuously delegated to AI without strong constraints, something interesting happens.&lt;/p&gt;

&lt;p&gt;In one context, the model may conclude that architecture A is best.&lt;/p&gt;

&lt;p&gt;Later, with a slightly different context, architecture B appears more attractive.&lt;/p&gt;

&lt;p&gt;Several iterations later, architecture C gets introduced to solve problems created by the previous two.&lt;/p&gt;

&lt;p&gt;Add incomplete context, model variation and occasional hallucination, and architectural drift becomes easy.&lt;/p&gt;

&lt;p&gt;This is why I increasingly think the important question is not:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“How much code can the model generate?”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;but:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;“How tightly can we constrain the system so that generated changes remain coherent?”&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;




&lt;h2&gt;
  
  
  3. Why the Same Model Behaves So Differently Across Agents
&lt;/h2&gt;

&lt;p&gt;This was the question that became much more interesting to me after building an agent myself.&lt;/p&gt;

&lt;p&gt;People often assume that if two products use the same underlying model, their coding ability should be roughly equivalent.&lt;/p&gt;

&lt;p&gt;For example:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Same Claude model
or
Same GPT model
or
Same Gemini model
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;So perhaps the only meaningful differences are the UI and a few extra tools.&lt;/p&gt;

&lt;p&gt;In practice, that is nowhere near the whole story.&lt;/p&gt;

&lt;p&gt;While testing my own Rust-based agent runtime, I encountered problems in almost every part of the execution pipeline.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.1 Tool Calling
&lt;/h3&gt;

&lt;p&gt;Tool calling sounds straightforward until you build it.&lt;/p&gt;

&lt;p&gt;You have to deal with things such as:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;argument parsing failures,&lt;/li&gt;
&lt;li&gt;schema differences,&lt;/li&gt;
&lt;li&gt;provider-specific behavior,&lt;/li&gt;
&lt;li&gt;inconsistent tool outputs,&lt;/li&gt;
&lt;li&gt;malformed responses,&lt;/li&gt;
&lt;li&gt;partial execution,&lt;/li&gt;
&lt;li&gt;retries,&lt;/li&gt;
&lt;li&gt;and determining whether a tool actually succeeded.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;If the runtime records a failed operation as successful, the model starts reasoning from a false state.&lt;/p&gt;

&lt;p&gt;Everything after that can be wrong.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.2 Task State
&lt;/h3&gt;

&lt;p&gt;A coding agent may contain conceptual stages such as:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Planning
    ↓
Execution
    ↓
Verification
    ↓
Completion
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If one transition is incorrect, the agent can stop even though obvious work remains.&lt;/p&gt;

&lt;p&gt;Or it can continue executing after the task is already complete.&lt;/p&gt;

&lt;p&gt;The model itself may be perfectly capable of performing the next step.&lt;/p&gt;

&lt;p&gt;The runtime simply never gives it the opportunity.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.3 Repeated Execution and Infinite Loops
&lt;/h3&gt;

&lt;p&gt;If previous actions are not represented correctly in state, an agent may:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;read the same file repeatedly,&lt;/li&gt;
&lt;li&gt;apply the same modification repeatedly,&lt;/li&gt;
&lt;li&gt;rediscover the same plan,&lt;/li&gt;
&lt;li&gt;retry an impossible action,&lt;/li&gt;
&lt;li&gt;or cycle between two states.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Loop detection sounds like a small runtime detail.&lt;/p&gt;

&lt;p&gt;During long tasks, it becomes essential.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.4 Completion Detection
&lt;/h3&gt;

&lt;p&gt;When exactly is an agent finished?&lt;/p&gt;

&lt;p&gt;If the completion condition is too permissive:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Model: Looks good. Done.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;the task may stop before the code is actually working.&lt;/p&gt;

&lt;p&gt;If it is too strict, the opposite happens.&lt;/p&gt;

&lt;p&gt;The build passes, tests pass and the requested change is complete, but the runtime continues looking for more work.&lt;/p&gt;

&lt;p&gt;Reliable stopping conditions are surprisingly difficult.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.5 Context Pollution
&lt;/h3&gt;

&lt;p&gt;Long-running coding tasks generate enormous amounts of information:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;terminal output,&lt;/li&gt;
&lt;li&gt;compiler errors,&lt;/li&gt;
&lt;li&gt;logs,&lt;/li&gt;
&lt;li&gt;tool results,&lt;/li&gt;
&lt;li&gt;plans,&lt;/li&gt;
&lt;li&gt;failed attempts,&lt;/li&gt;
&lt;li&gt;code,&lt;/li&gt;
&lt;li&gt;diffs,&lt;/li&gt;
&lt;li&gt;previous messages.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Keeping everything is not a solution.&lt;/p&gt;

&lt;p&gt;Even very large context windows are finite, and more context does not automatically mean better context.&lt;/p&gt;

&lt;p&gt;Eventually, irrelevant information starts competing with important information.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.6 Error Recovery
&lt;/h3&gt;

&lt;p&gt;Suppose:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;the model stream disconnects,&lt;/li&gt;
&lt;li&gt;a provider returns an error,&lt;/li&gt;
&lt;li&gt;a tool fails,&lt;/li&gt;
&lt;li&gt;a file write partially succeeds,&lt;/li&gt;
&lt;li&gt;or the environment changes unexpectedly.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What should happen?&lt;/p&gt;

&lt;p&gt;Should the agent:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;retry?&lt;/li&gt;
&lt;li&gt;continue from the existing task state?&lt;/li&gt;
&lt;li&gt;roll back?&lt;/li&gt;
&lt;li&gt;re-plan?&lt;/li&gt;
&lt;li&gt;retrieve the environment again?&lt;/li&gt;
&lt;li&gt;restart the entire task?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each strategy has trade-offs.&lt;/p&gt;

&lt;p&gt;And every recovery strategy changes the information available to the next model call.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.7 Retrieval Changes Intelligence
&lt;/h3&gt;

&lt;p&gt;Consider two coding agents using exactly the same model.&lt;/p&gt;

&lt;p&gt;Agent A can:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;read precise file ranges,&lt;/li&gt;
&lt;li&gt;search symbols,&lt;/li&gt;
&lt;li&gt;inspect references,&lt;/li&gt;
&lt;li&gt;retrieve repository structure,&lt;/li&gt;
&lt;li&gt;make targeted edits,&lt;/li&gt;
&lt;li&gt;inspect diffs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Agent B has only a few coarse tools and sometimes returns inconsistent results.&lt;/p&gt;

&lt;p&gt;On paper, both agents have the same “brain.”&lt;/p&gt;

&lt;p&gt;In practice, they are reasoning about different worlds.&lt;/p&gt;

&lt;p&gt;The difference becomes even clearer with code retrieval.&lt;/p&gt;

&lt;p&gt;One agent may effectively rely on:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;grep&lt;/span&gt; &lt;span class="nt"&gt;-R&lt;/span&gt; &lt;span class="s2"&gt;"something"&lt;/span&gt; &lt;span class="nb"&gt;.&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Another might combine:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;repository maps,&lt;/li&gt;
&lt;li&gt;symbol indexes,&lt;/li&gt;
&lt;li&gt;reference graphs,&lt;/li&gt;
&lt;li&gt;LSP information,&lt;/li&gt;
&lt;li&gt;semantic retrieval,&lt;/li&gt;
&lt;li&gt;dependency relationships.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The second agent can often place the same code inside a much more accurate structural context.&lt;/p&gt;

&lt;p&gt;The underlying model has not changed.&lt;/p&gt;

&lt;p&gt;The evidence provided to it has.&lt;/p&gt;

&lt;p&gt;And that changes its reasoning.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.8 Small Differences Compound Over Long Tasks
&lt;/h3&gt;

&lt;p&gt;This is probably one of the most important observations I made.&lt;/p&gt;

&lt;p&gt;Imagine two agents starting from the same model and the same task.&lt;/p&gt;

&lt;p&gt;Agent A retrieves slightly better information during step one.&lt;/p&gt;

&lt;p&gt;That means its decision during step two is slightly better.&lt;/p&gt;

&lt;p&gt;That changes which file it reads during step three.&lt;/p&gt;

&lt;p&gt;That changes what it edits during step four.&lt;/p&gt;

&lt;p&gt;That produces a different compiler result during step five.&lt;/p&gt;

&lt;p&gt;Now the two agents are operating from different states.&lt;/p&gt;

&lt;p&gt;Run this loop for dozens of iterations and the trajectories can diverge dramatically.&lt;/p&gt;

&lt;p&gt;So the phenomenon:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“This model feels amazing inside Agent A but strangely stupid inside Agent B.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;is not surprising at all.&lt;/p&gt;

&lt;p&gt;The model may be identical.&lt;/p&gt;

&lt;p&gt;The execution trajectory is not.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.9 Context Engineering
&lt;/h3&gt;

&lt;p&gt;After experimenting with this problem, context engineering became one of the areas I consider most important in agent design.&lt;/p&gt;

&lt;p&gt;A long-running agent must simultaneously make the model remember important things and prevent the context from becoming polluted.&lt;/p&gt;

&lt;p&gt;That requires constant decisions:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;What should remain permanently?&lt;/p&gt;

&lt;p&gt;Which history is no longer relevant?&lt;/p&gt;

&lt;p&gt;What can be compressed into one sentence?&lt;/p&gt;

&lt;p&gt;Should failed reasoning remain in context?&lt;/p&gt;

&lt;p&gt;Should a tool result be stored verbatim or summarized?&lt;/p&gt;

&lt;p&gt;Which pieces of code should stay available?&lt;/p&gt;

&lt;p&gt;Which ones should be retrieved again when necessary?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Every decision changes future model behavior.&lt;/p&gt;

&lt;p&gt;Again, small differences accumulate.&lt;/p&gt;

&lt;p&gt;Over a task containing dozens or hundreds of interactions, context policy can significantly change the final result.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.10 Verification Changes Everything
&lt;/h3&gt;

&lt;p&gt;There is a huge difference between an agent that stops after:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“I believe the issue is fixed.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;and one whose loop looks more like:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Modify
   ↓
Inspect diff
   ↓
Build
   ↓
Run tests
   ↓
Inspect failures
   ↓
Fix again
   ↓
Verify
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The second agent may appear significantly more intelligent.&lt;/p&gt;

&lt;p&gt;But part of that apparent intelligence comes from the runtime forcing the model to collect evidence.&lt;/p&gt;

&lt;p&gt;This applies to many other runtime components as well:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;search budgets,&lt;/li&gt;
&lt;li&gt;task-state management,&lt;/li&gt;
&lt;li&gt;tool design,&lt;/li&gt;
&lt;li&gt;loop detection,&lt;/li&gt;
&lt;li&gt;permission systems,&lt;/li&gt;
&lt;li&gt;recovery policies,&lt;/li&gt;
&lt;li&gt;model-specific prompts,&lt;/li&gt;
&lt;li&gt;verification requirements.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The visible “intelligence” of an agent is an emergent result of the whole system.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. An Agent Is a Bounded Optimization Process
&lt;/h2&gt;

&lt;p&gt;This eventually led me to a mental model that I now find useful.&lt;/p&gt;

&lt;p&gt;At every step, an agent is effectively trying to choose a better next action based on the state it currently understands.&lt;/p&gt;

&lt;p&gt;It might decide to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;search the repository
read another file
inspect a symbol
call a tool
modify some code
run the compiler
execute tests
collect more evidence
stop
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;But the agent never has perfect knowledge of the environment.&lt;/p&gt;

&lt;p&gt;Its repository view is incomplete.&lt;/p&gt;

&lt;p&gt;Tool results may contain noise.&lt;/p&gt;

&lt;p&gt;Context is limited.&lt;/p&gt;

&lt;p&gt;Search costs time and tokens.&lt;/p&gt;

&lt;p&gt;Execution has side effects.&lt;/p&gt;

&lt;p&gt;And the current state may itself contain incorrect assumptions.&lt;/p&gt;

&lt;p&gt;So the agent is not solving a fully observable global optimization problem.&lt;/p&gt;

&lt;p&gt;It is repeatedly making &lt;strong&gt;local decisions with incomplete information under constraints&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;That is what I mean by:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Agent = bounded optimization.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Once you look at agents this way, many runtime features start to look different.&lt;/p&gt;

&lt;p&gt;A &lt;strong&gt;search budget&lt;/strong&gt; is not merely an implementation detail.&lt;/p&gt;

&lt;p&gt;It defines how much evidence the optimizer is allowed to gather.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Loop detection&lt;/strong&gt; prevents the optimization process from getting trapped in cycles.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Verification&lt;/strong&gt; changes the effective objective from:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;produce a plausible answer
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;to something closer to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;produce an answer that survives external evidence
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Context management&lt;/strong&gt; determines which approximation of the current state the optimizer gets to see.&lt;/p&gt;

&lt;p&gt;And &lt;strong&gt;stopping conditions&lt;/strong&gt; define when the optimization process is considered sufficiently converged.&lt;/p&gt;

&lt;p&gt;Seen from this perspective, much of agent engineering is really about defining the boundaries of that optimization process.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Stronger Reasoning Does Not Automatically Mean Better Convergence
&lt;/h2&gt;

&lt;p&gt;There is another interesting consequence.&lt;/p&gt;

&lt;p&gt;A more capable reasoning model does not automatically produce a more reliable agent.&lt;/p&gt;

&lt;p&gt;Without appropriate constraints, a stronger model may:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;search more,&lt;/li&gt;
&lt;li&gt;explore more branches,&lt;/li&gt;
&lt;li&gt;call more tools,&lt;/li&gt;
&lt;li&gt;generate more hypotheses,&lt;/li&gt;
&lt;li&gt;and continue reasoning for longer.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That can be extremely useful.&lt;/p&gt;

&lt;p&gt;But without search budgets, stage boundaries, loop detection and stopping conditions, it can also make convergence harder.&lt;/p&gt;

&lt;p&gt;In other words:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Better exploration is useful only if the system can eventually turn exploration into convergence.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This is why agent engineering cannot be reduced to simply inserting a stronger model into an existing loop.&lt;/p&gt;

&lt;p&gt;A stronger model gives the agent a larger and potentially better search space.&lt;/p&gt;

&lt;p&gt;The runtime still has to guide that search toward a useful result.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. The Agent Is the Whole System
&lt;/h2&gt;

&lt;p&gt;After building one myself, I no longer think of a coding agent as simply:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;“An LLM with tools.”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;The actual product is closer to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Model
+ Context Engineering
+ Retrieval
+ Tools
+ Task State
+ Execution Loop
+ Verification
+ Error Recovery
+ Permissions
+ Model Adaptation
+ Stopping Conditions
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;All of these components shape the model's future observations and actions.&lt;/p&gt;

&lt;p&gt;Together, they determine whether the system eventually reaches a useful result.&lt;/p&gt;

&lt;p&gt;So my current summary is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;The model determines the capability ceiling. The runtime determines how much of that capability can be realized reliably.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Or, from the optimization perspective:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;The model provides the intelligence to search the solution space. Agent engineering defines the boundaries that make that search converge.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;That is why the exact same model can feel dramatically different depending on the agent around it.&lt;/p&gt;

&lt;p&gt;The brain matters.&lt;/p&gt;

&lt;p&gt;But so does the rest of the system.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>agents</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>How to Use Android as a Remote IDE with Tailscale + NimoteCode: Free SSH Access to Mac &amp; Linux Over the Public Internet</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Fri, 04 Sep 2026 08:39:35 +0000</pubDate>
      <link>https://dev.to/ma_dev/how-to-use-android-as-a-remote-ide-with-tailscale-and-nimotecode-free-ssh-access-to-mac-and-linux-47el</link>
      <guid>https://dev.to/ma_dev/how-to-use-android-as-a-remote-ide-with-tailscale-and-nimotecode-free-ssh-access-to-mac-and-linux-47el</guid>
      <description>&lt;p&gt;This short guide shows how to connect NimoteCode on Android to a Mac or Linux machine through Tailscale and SSH. You do not need a public IP address or router port forwarding.&lt;/p&gt;

&lt;h2&gt;
  
  
  macOS: install Tailscale from the command line
&lt;/h2&gt;

&lt;p&gt;First, check whether Homebrew is installed:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;brew &lt;span class="nt"&gt;--version&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;If Homebrew is not installed, install it first:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;/bin/bash &lt;span class="nt"&gt;-c&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="si"&gt;$(&lt;/span&gt;curl &lt;span class="nt"&gt;-fsSL&lt;/span&gt; https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh&lt;span class="si"&gt;)&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Install Tailscale:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;brew &lt;span class="nb"&gt;install&lt;/span&gt; &lt;span class="nt"&gt;--cask&lt;/span&gt; tailscale
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Launch Tailscale:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;open &lt;span class="nt"&gt;-a&lt;/span&gt; Tailscale
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The first launch opens a sign-in page. Sign in with your Tailscale account, then find this Mac's Tailscale IPv4 address:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;tailscale ip &lt;span class="nt"&gt;-4&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You will usually see an address similar to:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;100.80.12.34
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Confirm the connection status:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;tailscale status
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  macOS: enable SSH
&lt;/h2&gt;

&lt;p&gt;Enable Remote Login:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;sudo &lt;/span&gt;systemsetup &lt;span class="nt"&gt;-setremotelogin&lt;/span&gt; on
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Confirm that it is enabled:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;sudo &lt;/span&gt;systemsetup &lt;span class="nt"&gt;-getremotelogin&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The output should be:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Remote Login: On
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;You can also test SSH locally. Replace &lt;code&gt;your_username&lt;/code&gt; with your macOS username:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;ssh your_username@localhost
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  Linux: command line only
&lt;/h2&gt;

&lt;p&gt;Linux does not need a GUI. Install the Tailscale client and service once, then let it run in the background. For Ubuntu or Debian, run:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;curl &lt;span class="nt"&gt;-fsSL&lt;/span&gt; https://tailscale.com/install.sh | sh
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Start Tailscale and sign in:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;sudo &lt;/span&gt;tailscale up
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The command shows a sign-in URL; open it in a browser to authorize the device. Then check the Tailscale IP and status:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;tailscale ip &lt;span class="nt"&gt;-4&lt;/span&gt;
tailscale status
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Linux servers are a particularly good fit for this workflow: &lt;strong&gt;install once → run in the background → usually no further attention required&lt;/strong&gt;. In NimoteCode, use that &lt;code&gt;100.x.x.x&lt;/code&gt; address, port &lt;code&gt;22&lt;/code&gt;, your Linux username, and your password or SSH key.&lt;/p&gt;

&lt;h2&gt;
  
  
  Android: install Tailscale and connect NimoteCode
&lt;/h2&gt;

&lt;p&gt;Search Google Play for &lt;strong&gt;Tailscale&lt;/strong&gt;, install it, and then:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Open Tailscale.&lt;/li&gt;
&lt;li&gt;Sign in with the same account used on your Mac.&lt;/li&gt;
&lt;li&gt;Turn on the connection.&lt;/li&gt;
&lt;li&gt;Confirm that your Mac appears in the device list.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Next, open NimoteCode on Android and create a new SSH connection:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Host: 100.x.x.x
Port: 22
Username: your macOS username
Auth: Password or SSH Key
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Replace &lt;code&gt;100.x.x.x&lt;/code&gt; with the address returned by &lt;code&gt;tailscale ip -4&lt;/code&gt; on the Mac.&lt;/p&gt;

&lt;p&gt;Finally, turn off Wi-Fi on your phone and test once over &lt;strong&gt;4G/5G&lt;/strong&gt;. If NimoteCode can still connect to the Mac over SSH, you have successfully set up:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Android phone → Tailscale → home or office Mac → SSH&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Use your Tailscale connection in NimoteCode
&lt;/h2&gt;

&lt;p&gt;Tailscale gives your Android device and Mac or Linux machine a private network path. NimoteCode turns that private SSH connection into a complete mobile development workspace.&lt;/p&gt;

&lt;p&gt;After creating the connection in NimoteCode, you can:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Open the remote project root and browse it with Explorer instead of memorising paths.&lt;/li&gt;
&lt;li&gt;Edit source files directly on the Mac or Linux machine from your phone or tablet.&lt;/li&gt;
&lt;li&gt;Run tests, builds, Git commands and diagnostics in the integrated SSH terminal.&lt;/li&gt;
&lt;li&gt;Review Git diffs, branches and commits before you ship a change.&lt;/li&gt;
&lt;li&gt;Use AI Chat and Agent alongside the remote project, terminal output and code context.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is the difference between having remote access and being able to complete real development work away from your desk. Tailscale handles the secure private route; NimoteCode keeps the files, editor, terminal, Git review and AI assistance in one place.&lt;/p&gt;

&lt;h2&gt;
  
  
  What this setup gives you
&lt;/h2&gt;

&lt;p&gt;With Tailscale and NimoteCode, you can securely work from Android even when your devices are on different networks—without exposing SSH directly to the public internet or configuring router port forwarding.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>ssh</category>
      <category>productivity</category>
    </item>
    <item>
      <title>Can an AI Agent Really Code From a Phone?</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Sun, 30 Aug 2026 13:58:04 +0000</pubDate>
      <link>https://dev.to/ma_dev/can-an-ai-agent-really-code-from-a-phone-4n26</link>
      <guid>https://dev.to/ma_dev/can-an-ai-agent-really-code-from-a-phone-4n26</guid>
      <description>&lt;p&gt;This is a real AI Agent demo inside NimoteCode.&lt;br&gt;
Starting from an almost empty workspace, the AI Agent plans the task, creates and edits code, runs commands, verifies the result, and finally commits the changes.&lt;br&gt;
Everything happens directly inside NimoteCode — a mobile SSH IDE built for developers.&lt;br&gt;
✅ Long-running AI coding tasks&lt;br&gt;
✅ SSH remote development&lt;br&gt;
✅ Terminal + Git + Code Editor&lt;br&gt;
✅ Automatic verification and code commits&lt;br&gt;
NimoteCode is available now on Google Play, with the App Store version coming soon.&lt;br&gt;
Search NimoteCode and start coding anywhere.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>productivity</category>
      <category>mobile</category>
    </item>
    <item>
      <title>Agent Design is Bounded Optimization, Not Intelligence</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Sun, 05 Jul 2026 23:16:43 +0000</pubDate>
      <link>https://dev.to/ma_dev/agent-design-is-bounded-optimization-not-intelligence-hbl</link>
      <guid>https://dev.to/ma_dev/agent-design-is-bounded-optimization-not-intelligence-hbl</guid>
      <description>&lt;h2&gt;
  
  
  🧠 Introduction
&lt;/h2&gt;

&lt;p&gt;AI agents are often described as intelligent systems.&lt;/p&gt;

&lt;p&gt;However, after building and iterating multiple agent systems, a different pattern becomes clear:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;An agent is not intelligence.&lt;br&gt;
It is a &lt;strong&gt;bounded optimization process operating over partial information&lt;/strong&gt;.&lt;/p&gt;
&lt;/blockquote&gt;




&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwngbkhhz559meirje06y.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwngbkhhz559meirje06y.jpg" alt="agentdesc" width="799" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Formal View of an Agent
&lt;/h2&gt;

&lt;p&gt;We can define an agent policy as:&lt;/p&gt;

&lt;p&gt;π∗=argπmax​E[R(τ)]&lt;/p&gt;

&lt;p&gt;Where:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;( \pi ): policy (decision function)&lt;/li&gt;
&lt;li&gt;( \tau ): trajectory (sequence of actions + observations)&lt;/li&gt;
&lt;li&gt;( R ): reward function&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;At each step, the agent selects:&lt;/p&gt;

&lt;p&gt;at​=argamax​E[Q(st​,a)]&lt;/p&gt;




&lt;h2&gt;
  
  
  2. The Real-World Constraint
&lt;/h2&gt;

&lt;p&gt;In real systems, the assumptions above break:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;State ( s_t ) is partially observable&lt;/li&gt;
&lt;li&gt;Rewards are sparse and delayed&lt;/li&gt;
&lt;li&gt;Tool outputs are stochastic and noisy&lt;/li&gt;
&lt;li&gt;Environment is non-stationary&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So the agent is not solving global optimization.&lt;/p&gt;

&lt;p&gt;Instead, it performs:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;local greedy optimization over incomplete state&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;




&lt;h2&gt;
  
  
  3. Why Agents Fail: Looping Behavior
&lt;/h2&gt;

&lt;p&gt;A key failure pattern emerges in practice:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;repeated file reads&lt;/li&gt;
&lt;li&gt;redundant tool calls&lt;/li&gt;
&lt;li&gt;over-exploration of same context&lt;/li&gt;
&lt;li&gt;non-terminating reasoning loops&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Why does this happen?&lt;/p&gt;

&lt;p&gt;Because locally:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;every action still has positive expected utility&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;So from the agent’s perspective:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;continuing to explore is always “reasonable”&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This leads to optimization loops.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. The Missing Dimension: Termination
&lt;/h2&gt;

&lt;p&gt;Most agent designs focus on:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;reasoning capability&lt;/li&gt;
&lt;li&gt;tool usage&lt;/li&gt;
&lt;li&gt;planning quality&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But ignore a critical axis:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;When should the agent stop?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Without termination control, the system degenerates into:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;infinite exploration&lt;/li&gt;
&lt;li&gt;tool loops&lt;/li&gt;
&lt;li&gt;unstable execution trajectories&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  5. Agent Design Space
&lt;/h2&gt;

&lt;p&gt;Agent behavior is fundamentally a trade-off between:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Exploration&lt;/strong&gt; (gathering information)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Exploitation&lt;/strong&gt; (executing actions)&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Termination&lt;/strong&gt; (converging output)&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;We can think of this as a constrained optimization system rather than pure reasoning.&lt;/p&gt;




&lt;h2&gt;
  
  
  6. Bounded Optimization Perspective
&lt;/h2&gt;

&lt;p&gt;A more accurate formulation is:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Intelligence = optimization&lt;br&gt;
Agent = bounded optimization&lt;br&gt;
Engineering = defining the bounds of optimization&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;These bounds include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;exploration budgets per module&lt;/li&gt;
&lt;li&gt;loop detection mechanisms&lt;/li&gt;
&lt;li&gt;phase separation (analysis → planning → execution)&lt;/li&gt;
&lt;li&gt;early stopping heuristics&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  7. Key Insight
&lt;/h2&gt;

&lt;p&gt;An important observation from practice:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Improving reasoning alone often increases instability.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Because stronger reasoning tends to:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;increase exploration depth&lt;/li&gt;
&lt;li&gt;increase tool invocation frequency&lt;/li&gt;
&lt;li&gt;delay convergence&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Without proper constraints, this leads to worse system behavior.&lt;/p&gt;




&lt;h2&gt;
  
  
  🧩 Conclusion
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft1vhllmio53eh8gtqawi.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Ft1vhllmio53eh8gtqawi.png" alt="agent optimization" width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;An agent is not a system that “thinks better”.&lt;/p&gt;

&lt;p&gt;It is a system that:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;optimizes under constraints and knows when to stop optimizing&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>systemdesign</category>
      <category>productivity</category>
    </item>
    <item>
      <title>I built a mobile IDE with ~90% AI-generated code — but it still took me 6 months</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Sat, 20 Jun 2026 13:55:31 +0000</pubDate>
      <link>https://dev.to/ma_dev/i-built-a-mobile-ide-with-90-ai-generated-code-but-it-still-took-me-6-months-2p7</link>
      <guid>https://dev.to/ma_dev/i-built-a-mobile-ide-with-90-ai-generated-code-but-it-still-took-me-6-months-2p7</guid>
      <description>&lt;p&gt;I recently shipped a mobile IDE on Google Play.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;~90% of the code was generated with AI tools. I handled architecture, product decisions, testing, and iteration.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;From the outside, this sounds like it should be fast.&lt;/p&gt;

&lt;p&gt;But in reality, it still took around &lt;strong&gt;6 months of continuous work&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ozb6ii7pxbz0sgh2nmt.PNG" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4ozb6ii7pxbz0sgh2nmt.PNG" alt="NimoteCode P1" width="800" height="500"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  What AI actually helped with
&lt;/h2&gt;

&lt;p&gt;AI significantly accelerated:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;boilerplate code&lt;/li&gt;
&lt;li&gt;UI implementation&lt;/li&gt;
&lt;li&gt;feature scaffolding&lt;/li&gt;
&lt;li&gt;refactoring suggestions&lt;/li&gt;
&lt;li&gt;debugging assistance&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It reduced the time spent on writing code line by line.&lt;/p&gt;




&lt;h2&gt;
  
  
  But what still took time
&lt;/h2&gt;

&lt;p&gt;Even with heavy AI usage, a large amount of time was still spent on:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;system design and architecture decisions&lt;/li&gt;
&lt;li&gt;ensuring correctness across features&lt;/li&gt;
&lt;li&gt;testing UI behavior across edge cases&lt;/li&gt;
&lt;li&gt;fixing inconsistent AI-generated logic&lt;/li&gt;
&lt;li&gt;integrating complex workflows (SSH, Git, remote execution)&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  The key reality
&lt;/h2&gt;

&lt;p&gt;For complex applications, AI doesn’t remove the hard parts of development.&lt;/p&gt;

&lt;p&gt;It shifts the workload.&lt;/p&gt;

&lt;p&gt;Instead of writing code, you spend more time:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;validating outputs&lt;/li&gt;
&lt;li&gt;correcting assumptions&lt;/li&gt;
&lt;li&gt;defining constraints clearly&lt;/li&gt;
&lt;li&gt;repeatedly testing real-world behavior&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  What I learned
&lt;/h2&gt;

&lt;p&gt;AI today is extremely good at &lt;strong&gt;speeding up implementation&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;But it is still far from replacing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;system-level thinking&lt;/li&gt;
&lt;li&gt;product decisions&lt;/li&gt;
&lt;li&gt;correctness guarantees&lt;/li&gt;
&lt;li&gt;end-to-end testing&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;In practice, it feels less like “AI builds software for you”&lt;br&gt;
and more like &lt;strong&gt;AI increases your throughput as a developer&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  The app
&lt;/h2&gt;

&lt;p&gt;The result of this process is a mobile IDE:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;SSH remote development environments&lt;/li&gt;
&lt;li&gt;Git workflow support&lt;/li&gt;
&lt;li&gt;mobile code editing&lt;/li&gt;
&lt;li&gt;AI-assisted coding features&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It’s now live on Google Play:&lt;br&gt;
&lt;a href="https://play.google.com/store/apps/details?id=com.nimote.nimotecode&amp;amp;pcampaignid=web_share" rel="noopener noreferrer"&gt;https://play.google.com/store/apps/details?id=com.nimote.nimotecode&amp;amp;pcampaignid=web_share&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0hawzi0zl1bye4ut36cv.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F0hawzi0zl1bye4ut36cv.png" alt="NimoteCOde Google Play Store screenshot" width="800" height="386"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Final thought
&lt;/h2&gt;

&lt;p&gt;AI didn’t reduce the need for developers.&lt;/p&gt;

&lt;p&gt;It changed what developers spend time on.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>showdev</category>
      <category>indiehackers</category>
    </item>
    <item>
      <title>Is Local Heavy Compilation Dead? The Rise of 2026 AI-Agentic Mobile IDEs 🚀</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Fri, 12 Jun 2026 07:38:33 +0000</pubDate>
      <link>https://dev.to/ma_dev/is-local-heavy-compilation-dead-the-rise-of-2026-ai-agentic-mobile-ides-16pp</link>
      <guid>https://dev.to/ma_dev/is-local-heavy-compilation-dead-the-rise-of-2026-ai-agentic-mobile-ides-16pp</guid>
      <description>&lt;p&gt;Let’s be honest: until recently, the phrase &lt;strong&gt;"Mobile IDE"&lt;/strong&gt; felt like a bad joke. &lt;/p&gt;

&lt;p&gt;Who in their right mind would want to squint at a tiny tablet screen, fighting with heavy Gradle or Xcode compilations that turn an iPad into a literal frying pan? We all agreed: &lt;em&gt;Real developers need heavy local hardware.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;But it’s &lt;strong&gt;2026&lt;/strong&gt;, and the paradigm has completely broken. &lt;/p&gt;

&lt;p&gt;Mobile IDEs are no longer just "code editors on a tablet"—they have evolved into the ultimate &lt;strong&gt;"Thin-Client Windows" powered by autonomous AI Agents and Full-Stack Cloud Containers.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F1rzx2jb1wouiztriaq43.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2F1rzx2jb1wouiztriaq43.png" alt="Mobile IDE NimoteCode" width="799" height="452"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  🛠️ The 2026 Shift: Three Core Pillars
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. From "Copilot Chat" to "Agentic Engineering"
&lt;/h3&gt;

&lt;p&gt;In 2024, we had chat windows for code autocompletion. In 2026, we have &lt;strong&gt;Autonomous AI Agents&lt;/strong&gt;. &lt;br&gt;
Modern Mobile IDEs feature background agents that scan your entire repository, read error logs, write tests, and deploy fixes inside cloud sandboxes without constant developer typing.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. Multi-Modal "Visual Edits" (Goodbye, heavy typing!)
&lt;/h3&gt;

&lt;p&gt;Typing code on a touchscreen sucks. The solution? &lt;strong&gt;Direct UI Manipulation.&lt;/strong&gt;&lt;br&gt;
You can now directly tap or drag a UI component on your tablet preview. The AI Agent instantly maps that visual component to the underlying declarative code (SwiftUI, Jetpack Compose, or Flutter) and modifies it in real time. &lt;/p&gt;

&lt;h3&gt;
  
  
  3. 100% Cloud-Native + WASM Previews
&lt;/h3&gt;

&lt;p&gt;Local hardware constraints are neutralized. Heavy compilation, bundling, and dependency matching are completely offloaded to ultra-fast, ephemeral cloud containers. Your mobile device is just a low-latency rendering engine running WebAssembly.&lt;/p&gt;




&lt;h2&gt;
  
  
  📊 Paradigm Shift: 2024 vs 2026 Mobile Development
&lt;/h2&gt;

&lt;p&gt;To understand how drastically this changes our daily workflow, here is a quick breakdown:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimension&lt;/th&gt;
&lt;th&gt;2024 (Traditional Dev)&lt;/th&gt;
&lt;th&gt;2026 (Agentic &amp;amp; Cloud-Native)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;AI's Primary Role&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Simple autocomplete &amp;amp; chat&lt;/td&gt;
&lt;td&gt;Autonomous engineering &amp;amp; self-healing bugs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Core Interaction&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Heavy keyboard typing / Ext. Monitor&lt;/td&gt;
&lt;td&gt;Natural language + Multimodal Visual Edits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Compilation&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Battery-draining local hardware&lt;/td&gt;
&lt;td&gt;100% offloaded to scalable Cloud Containers&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Barrier to Entry&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Pro-code mastery required&lt;/td&gt;
&lt;td&gt;Hybrid (Low-Code/AI-Generated architecture)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;




&lt;h2&gt;
  
  
  🔥 Is Local Compilation Dead?
&lt;/h2&gt;

&lt;p&gt;We are moving away from the "Bring Your Own Heavy Laptop" era. When the cloud handles 99% of the heavy lifting and AI handles the syntax, a high-bandwidth network and a portable screen are all you need.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What do you think?&lt;/strong&gt; Are you still refusing to code without your multi-monitor desktop setup, or have you already used an iPad/folding screen to fix a critical production bug on the go? &lt;/p&gt;

&lt;p&gt;Let's argue in the comments below! 👇&lt;/p&gt;

</description>
      <category>ai</category>
      <category>programming</category>
      <category>mobile</category>
      <category>development</category>
    </item>
    <item>
      <title>Maybe the real limitation isn’t AI coding… 🤖
but the fact that developers still expect 100% deterministic control over every line of code.
That mindset might be the real bottleneck
Or are we just not ready for non-deterministic workflows yet? 👀
Thoughts？</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Fri, 12 Jun 2026 03:44:18 +0000</pubDate>
      <link>https://dev.to/ma_dev/maybe-the-real-limitation-isnt-ai-coding-but-the-fact-that-developers-still-expect-100-3bi2</link>
      <guid>https://dev.to/ma_dev/maybe-the-real-limitation-isnt-ai-coding-but-the-fact-that-developers-still-expect-100-3bi2</guid>
      <description></description>
    </item>
    <item>
      <title>SSH + mobile coding is still broken — so I built my own IDE</title>
      <dc:creator>Miro Ma</dc:creator>
      <pubDate>Thu, 11 Jun 2026 15:17:34 +0000</pubDate>
      <link>https://dev.to/ma_dev/mobile-coding-tools-dont-work-for-real-development-so-i-built-my-own-ide-3goo</link>
      <guid>https://dev.to/ma_dev/mobile-coding-tools-dont-work-for-real-development-so-i-built-my-own-ide-3goo</guid>
      <description>&lt;p&gt;&lt;strong&gt;I’ve tried a lot of mobile coding tools—SSH apps, code editors, cloud IDEs.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Most of them feel useful… but incomplete.&lt;/p&gt;

&lt;p&gt;They either:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;only edit code&lt;/li&gt;
&lt;li&gt;or only provide a terminal&lt;/li&gt;
&lt;li&gt;or feel like a desktop tool squeezed into a phone&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But real dev work isn’t just “writing code”.&lt;/p&gt;

&lt;p&gt;It’s:&lt;/p&gt;

&lt;p&gt;SSH + files + terminal + git — all together.&lt;/p&gt;




&lt;p&gt;So I started building a mobile-first IDE called &lt;strong&gt;NimoteCode&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The idea is simple:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;A workspace should include everything — not separate apps.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;ul&gt;
&lt;li&gt;Local &amp;amp; SSH workspaces&lt;/li&gt;
&lt;li&gt;Integrated terminal&lt;/li&gt;
&lt;li&gt;Code + project structure in one place&lt;/li&gt;
&lt;li&gt;Mobile-first UX (not desktop copy)&lt;/li&gt;
&lt;/ul&gt;




&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fko1cyiuqp56lsitwhonb.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fko1cyiuqp56lsitwhonb.png" alt="NimoteCode P1" width="799" height="449"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fguioczic5h99zwp88lzj.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fguioczic5h99zwp88lzj.png" alt="NimoteCode P2" width="800" height="449"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Forvh43fttewk8hu5vc4i.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Forvh43fttewk8hu5vc4i.png" alt="NimoteCode P3" width="800" height="447"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Still early, but it’s currently in testing phase on Google Play.&lt;/p&gt;

&lt;p&gt;If you want to try it or give feedback, you can join the testing program here:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;🚀 Try NimoteCode (Closed Beta)&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;NimoteCode is currently in closed testing on Google Play.&lt;/p&gt;

&lt;p&gt;If you’re interested in mobile development workflows (SSH, coding, terminal, and workspace-based development), you’re welcome to try it and share feedback.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Join the tester group&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://groups.google.com/g/nimotecode-testers" rel="noopener noreferrer"&gt;https://groups.google.com/g/nimotecode-testers&lt;/a&gt;&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Wait for access to activate&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;It usually takes a few minutes after joining.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Install via Google Play&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://play.google.com/store/apps/details?id=com.nimote.nimotecode" rel="noopener noreferrer"&gt;https://play.google.com/store/apps/details?id=com.nimote.nimotecode&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;⚠️ Notes&lt;br&gt;
Please use the same Google account for both Google Groups and Google Play&lt;br&gt;
If the app doesn’t show up immediately, wait a bit and refresh&lt;br&gt;
This is still early — expect rough edges&lt;/p&gt;

&lt;p&gt;Feedback from real usage (especially SSH + mobile workflows) would be very valuable.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;👉 Do you think mobile development is actually usable today, or still fundamentally fragmented?&lt;/strong&gt;&lt;/p&gt;

</description>
      <category>mobile</category>
      <category>productivity</category>
      <category>devops</category>
      <category>flutter</category>
    </item>
  </channel>
</rss>
