Why our phone apps are native, not a web view
Our phone apps go native in November 2026, because a web view is weak at the keyboard, gestures, sheets, haptics and push. The web app stays.
Contents
We're building two phone apps for Shuriken, one for iPhone and one for Android, both native and both from scratch. They're due in November 2026. Wrapping the web app in a shell would have been faster, and on 22 October we decided against it.
If you're weighing native against web for your own developer tool, the reasoning may help. It isn't "native good, web bad".
What the web app does well#
The Shuriken web app lives at app.shuriken.sh. It's the same app you use on your computer, in a browser. On a phone you can add it to your home screen and it opens like an app. From it you get every chat, the queue, Changes and voice, following the agents on your computers and servers. More in Your agents on your phone, from the browser and on the phone page.
A web app is good at three things we care about:
- One deploy and every phone, tablet and borrowed laptop has the new version, with no store review and no "please update".
- There's nothing to install. You open a link and you're in, which suits a first look and someone else's machine.
- Browsers never count toward your linked devices, so it works on Free without using up a slot.
None of that goes away. The web app stays when the native apps ship.
What a phone needs that a web view does badly#
A developer tool on a phone isn't a website you read. You type into it, often in a hurry, while an agent waits on you. Five things decide whether that feels good, and a web view is weak at all five.
The keyboard#
The keyboard takes half the screen, so the composer has to sit right on top of it without the chat jumping. Browsers report the keyboard to a page in different ways, and a web view mostly finds out after it has moved. A native app gets its size and timing up front. In the iPhone plan the composer rides the keyboard with the system's own animation, and a UI test checks that the gap above it stays within 1 point while the keyboard opens and closes.
Gestures#
Swipe from the edge to go back, pull a sheet down to close it, long-press a message for its menu. Thumbs know these moves from every other app. In a web view the browser's gestures compete with the page's, and the page usually loses. The Android app uses predictive back on every screen, where you see the screen underneath before you let go, and the iPhone app keeps the back swipe working everywhere.
Sheets#
Most of what you do on a phone happens in sheets that rise from the bottom: pick a model, approve a request, choose a project. A native sheet stops at half height or full, follows your finger and closes the way you expect. A web sheet is a drawing of one.
Haptics#
A small tap when a message sends or a request is approved tells you it worked without looking. Web pages get little say over the phone's vibration motor, and Safari on iPhone doesn't support the web's vibration API at all, so a web app there has almost no way to give that tap.
Push notifications#
"Your chat needs you" is the most important message Shuriken sends. On iPhone, a web app can only ask for push permission after you've added it to your Home Screen (WebKit, February 2023), and many people never do. A native app asks once, the way every other app does, with no Home Screen step first. For what works today, see getting Claude Code notifications on your phone.
Why two native apps, not one shared screen#
The middle road is one shared interface drawn the same way on both phones. That is roughly what we have: the desktop app, the web app and the phone layout are one React Native codebase, and the phone layout grew out of the desktop one. A phone was still carrying desktop parts it never displays. We have been making it lighter, but a layout that starts from the desktop will always feel like a guest.
So the iPhone app is Swift and SwiftUI and follows Apple's design, Liquid Glass and the Human Interface Guidelines. The Android app is Kotlin and Jetpack Compose and follows Google's Material 3 Expressive. Both start from the phone's jobs: see where your agents are, answer the one waiting on you, queue the next thing, put the phone away.
What they share is the wire. Both apps speak one written contract with your computers, and the Android app's protocol types, about 2,100 of them, are generated from it, never typed by hand. Your agents still run on your computers and servers, never on the phone, and your devices still talk through sealed messages that our cloud relays but can't read.
Where it stands#
Due in November 2026. We won't post progress bars we can't vouch for. When the apps are in the App Store and Google Play, the greyed-out badges on this site light up and we'll write about it here. The iOS and Android pages will carry the details, and We're building native iOS and Android apps has the original announcement.
Until then, open app.shuriken.sh on your phone and add it to your home screen. If you haven't set up Shuriken on a computer yet, that's where your agents live: try it here.
Frequently asked questions
Is a native app always better than a web app for a developer tool?
No. A web app ships everywhere at once, needs no install and updates the moment we deploy. Native wins when the tool lives on a phone: keyboard, gestures, sheets, haptics and notifications.
When are the Shuriken iPhone and Android apps coming?
They're due in November 2026. Until they're in the App Store and Google Play, use the web app at app.shuriken.sh, which you can add to your home screen.
Will the web app go away when the native apps ship?
No. We're keeping the web app for any browser and any device, on every plan.
Will agents run on my phone?
No. Agents keep running on your computers and servers. The phone apps follow their chats, send and queue messages, and answer what they ask.