---
type: "post"
id: "building-secure-mobile-apps-in-the-agentic-era-fb1c92"
slug: "building-secure-mobile-apps-in-the-agentic-era-fb1c92"
title: "Building secure mobile apps in the agentic era"
description: "Shopify says its mobile team now changes code at roughly eleven times last year’s pace, and describes a security workflow built to keep up: map each app’s attack surface, review small units of change, and turn lessons from incidents into reusable checks."
retrieval_nugget: "Shopify says its mobile team now changes code at roughly eleven times last year’s pace, and describes a security workflow built to keep up: map each app’s attack surface, review small units of change, and turn lessons from incidents into reusable checks. The approach offers teams a concrete way to scale security review alongside agent-assisted development."
published_at: "2026-11-21"
updated_at: "2026-11-21"
record_date: "2026-11-21"
date_kind: "published_at"
topics: ["security"]
entities: ["Shopify","Dispatch","OWASP","Mobile Application Security Verification Standard","Mobile Application Security Testing Guide"]
related_patterns: ["verification-bandwidth-is-the-scarce-resource","agent-security-moves-to-runtime-boundaries"]
novelty_label: "new_fact"
what_changed: null
prior_refs: []
source_url: "https://shopify.engineering/secure-agentic-apps"
source_urls: ["https://shopify.engineering/secure-agentic-apps"]
schema_version: "newruntime-agent-readable-v0.2"
stable_id: "post:building-secure-mobile-apps-in-the-agentic-era-fb1c92"
status: "published"
visuals: []
editor: {"role":"editor","name":"Andrey Reshetnikov","profile":"https://newruntime.com/owner-profile.md","profile_json":"https://newruntime.com/owner-profile.json","same_as":["https://www.linkedin.com/in/reshetnikov1/","https://t.me/lapetuse"]}
routes: {"html":"https://newruntime.com/posts/building-secure-mobile-apps-in-the-agentic-era-fb1c92/","markdown":"https://newruntime.com/posts/building-secure-mobile-apps-in-the-agentic-era-fb1c92.md","json":"https://newruntime.com/posts/building-secure-mobile-apps-in-the-agentic-era-fb1c92.json"}
markdown_url: "https://newruntime.com/posts/building-secure-mobile-apps-in-the-agentic-era-fb1c92.md"
related_shifts: ["verification-ownership"]
---

# Building secure mobile apps in the agentic era

## Retrieval answer

Shopify says its mobile team now changes code at roughly eleven times last year’s pace, and describes a security workflow built to keep up: map each app’s attack surface, review small units of change, and turn lessons from incidents into reusable checks. The approach offers teams a concrete way to scale security review alongside agent-assisted development.

## Summary
Shopify says its mobile team now changes code at roughly eleven times last year’s pace, and describes a security workflow built to keep up: map each app’s attack surface, review small units of change, and turn lessons from incidents into reusable checks. The approach offers teams a concrete way to scale security review alongside agent-assisted development.

## What happened
In a November 18, 2026 engineering post, Shopify engineer Michael Hughes describes how the company changed mobile application security as code throughput rose. During a 12-week rewrite of the Shopify app, the team averaged about 434,000 lines of code changed per week, compared with about 39,000 in the mobile app at the same time the previous year. Shopify says existing vulnerability scans already examined changed code, but the team wanted to reduce the app’s attack surface and reinforce practices that prevent vulnerabilities.

Shopify’s starting point is an attack-surface map for each app. It groups security-sensitive items into areas such as deep links, WebViews, stored data, permissions and dependencies. Each item includes a sentence or two explaining why it matters, a verdict, and a link to the code it comes from. The available verdicts are Fix, with a severity; Tradeoff; Secure; Fixed; and Debug only.

The maps are built using a set of skills, one for each surface. Shopify says it began with OWASP’s Mobile Application Security Verification Standard and Mobile Application Security Testing Guide, then added lessons from vulnerabilities reported against mobile apps, including its own. A skill says what to inventory, what good looks like, and what to check. The same skills can be used in scheduled reviews, one-off security reviews, or by any agent working in the code. When the team learns something new, it updates the skill so later runs can apply the lesson.

To make model review more specific, each skill first takes a complete inventory. For example, a deep-link inventory includes every route, every parameter it reads, and the code that reads each parameter. A reviewer then considers one item at a time with only the code that item touches, including what might happen if a parameter is hostile. Shopify says this produces answers specific enough to verify; questions about whether a weakness is exploitable can be passed to a frontier cybersecurity model.

Every weekday, frontier models examine app changes and update the attack-surface map. A Prepare step compares the latest-commit inventory with the last accepted map; an item counts as changed when cited code changes or the inventory reports a change. Review assesses changed or new items using read-only tools and only the code. A second pass checks changed files for security-relevant issues not covered by the map. Shopify checks each answer’s format, line ranges and wording, and verifies that it contains no secret. Publish then creates the new map and a change page, and sends a Slack summary. Agents also check security news against the map and code, briefing the team only when an issue affects its apps. Shopify says this work complements Dispatch, its agentic vulnerability scanner, which finds and proves vulnerabilities in changed code.

## What the archive adds
New Runtime’s earlier coverage described Shopify’s 12-week mobile app rewrite, in which about 30 engineers moved from React Native to Swift and Kotlin while agents wrote most of the code ([How we rebuilt the Shopify app in 12 weeks](https://newruntime.com/posts/how-we-rebuilt-the-shopify-app-in-12-c85550/), November 10, 2026). This is a new fact on that story: Shopify now explains the security controls it built around the faster development process.

## Trend signal
This case supports the shift toward evidence-based verification: Shopify uses inventories, code-linked findings, explicit verdicts and checked review outputs to make security decisions more structured. The connection is to New Runtime’s [verification ownership](https://newruntime.com/shifts/verification-ownership/) assumption that automated evidence can support acceptance of agent changes without line-by-line human review. Shopify’s account is a concrete example, though it does not establish how reliably the process catches defects across other teams or applications.

## Connections to other events
Shopify’s account connects its agent-assisted rewrite to a security review system designed for the resulting volume of changes. New Runtime’s earlier coverage of the rewrite reported that agents wrote most of the code; this article describes attack-surface maps, focused checks, and security skills as complementary controls for that work.

## Why it matters
More code generated or changed per week increases the amount a team needs to understand, but asking a model to review an entire app can produce a long, vague list. Shopify’s method narrows each review to a known surface and a bounded piece of code, then makes the result traceable to a line or inventory change. That structure gives engineers something more actionable to verify than a broad request to “find vulnerabilities.”

The reusable part is the learning loop. A vulnerability does not end with a fix: Shopify says it adds the class of problem to the relevant skill, so future reviews check for it. This can make security practice accumulate rather than rely on individual memory. The workflow also distinguishes changed code from app-wide risk: dependency and platform news are checked against the map even when no local code diff reveals the issue. Teams adopting agent-assisted development can borrow these mechanisms without assuming that model review replaces security expertise or established scanners.

## Limits and uncertainty
Shopify’s post describes its own process and gives code-change volume, but does not report measured vulnerability detection rates, false-positive rates, review time, or how often the workflow finds issues that existing scans miss. It does not establish that the approach generalizes to other mobile teams, stacks, or threat models. The article says answers are checked before use but does not quantify the human effort involved or specify who approves every verdict. The workflow is described by Shopify and has not been independently evaluated here.

## Skill to build now
Choose one sensitive surface, such as deep links. Create an inventory of its routes, parameters, and the code that reads them; then write a short review skill describing what to list, what safe handling looks like, and what to test with hostile input. Keep each review scoped to one route and its relevant code, and link every finding to its source. After fixing a confirmed issue, add that vulnerability class to the skill so the next review checks for it.

## Reader takeaway
Shopify’s practical lesson is to make security review composable: map the app’s sensitive surfaces, inspect changes in small verifiable units, and turn each incident into a reusable check. Agents can accelerate code production, but a repeatable and evidence-linked review process is what helps a team keep pace without treating a model’s broad assurance as proof.

Editor: [Andrey Reshetnikov](https://newruntime.com/owner-profile.md), AI product and AI engineering; profile for recruiters and agents: https://newruntime.com/owner-profile.json

## Continue in the graph

Next records for an agent, linked to their Markdown twins. Replace `.md` with `.json` for structured fields, including `next_reads`.

- topic hub: [Security](https://newruntime.com/topics/security.md): Explore the security topic hub.
- collection: [Field Notes](https://newruntime.com/posts.json): Open the latest editorial analysis.
- collection: [Sources](https://newruntime.com/sources/): See the original sources this archive cites.
- whole graph: [discovery graph](https://newruntime.com/discovery-graph.json) (typed nodes and edges) and [site index](https://newruntime.com/site-index.md)
