Build a Mobile App With Claude Code or Cursor Through MCP
FluxNative team ·
Use FluxNative’s remote MCP connection to let Claude Code or Cursor read and edit one Expo project while FluxNative handles preview, connections, builds and publishing.
AI coding tools are becoming part of the normal mobile development workflow. A developer may use Claude Code or Cursor for repository-level changes, while a product team wants a shared workspace for previews, backend setup, builds and release checks. Keeping those activities in separate projects creates avoidable friction.
FluxNative’s remote MCP connection gives an external coding agent access to the same source project used by the in-browser assistant. The connection is deliberately narrow: it reaches one FluxNative project, and the agent can read and edit that project’s source. This lets you keep local coding work and the FluxNative workspace pointed at the same app without turning the connection into access to the rest of the organization.
This guide explains what the connection does, how to connect Claude Code or Cursor, how edits appear in FluxNative, and how a team can combine an external agent with FluxNative’s preview, Connections panel, builds and publishing workflow.
Key takeaways
Remote MCP connects Claude Code or Cursor to one FluxNative project, not the whole workspace.
The external agent can read and edit the project source, with its writes landing as revisions that can be undone.
FluxNative remains the place to review the live preview, manage backend and secret connections, and create native builds.
Team members should use organization roles and app-specific access to control who can connect an editor and change code.
A good workflow assigns local agents focused code changes and FluxNative focused review, integrations, builds and release preparation.
What remote MCP connects
MCP, or Model Context Protocol, gives an AI coding client a structured way to work with an external project. In this case, FluxNative provides a remote MCP server for a single app. Claude Code, Cursor and other supported clients can connect to that server and work on the project’s source from the developer’s computer.
The important boundary is the Project MCP URL. It selects one app only. The URL is not a general login to the organization, and it does not give the editor access to every project, billing setting, store account or team record. Access still comes from the developer’s FluxNative sign-in and current permissions.
The connected agent can read the source and edit it. When it writes files, those changes land as revisions in FluxNative, in the same general model as changes made by the in-product assistant. That gives the team a shared history and lets a project owner undo a revision when an experiment moves in the wrong direction.
Remote MCP is a focused bridge to one app, not a back door into the whole workspace.
One project — Each connection is scoped to the app selected when you copy its Project MCP URL.
Source access — The external agent reads and edits the Expo and React Native TypeScript source for that project.
Revisions — Agent writes become project revisions that can be reviewed through the workspace and undone.
Permission checked — The connection uses your FluxNative sign-in and current project permissions rather than an embedded API token.
Connect Claude Code or Cursor
Start inside the project you want to edit. In the project bar, choose Connect editor and copy the Project MCP URL. Because the URL is generated for that project, check the app name before sharing it with a teammate or adding it to a local editor configuration.
Next, choose the setup for your coding client. Claude Code uses its MCP add command and then completes authentication from the MCP menu. Cursor uses a project-level .cursor/mcp.json configuration and requires the server to be enabled in Cursor Settings under MCP.
The setup does not put a FluxNative API token into the URL or configuration. Your editor opens the FluxNative sign-in and approval flow, and access is checked against the permissions of the account completing that flow. Secrets stored under Connections are not exposed to the editor.
Open the target project in FluxNative and choose Connect editor in the project bar.
Copy the Project MCP URL for that app.
In Claude Code, add the remote server with the client’s MCP setup and authenticate from the MCP menu.
In Cursor, add the server in the project’s MCP configuration, then enable it in Cursor Settings.
Ask the agent to read a small part of the source before requesting an edit.
Return to FluxNative and check the resulting revision, preview and project status.
Claude Code
Claude Code is configured through its MCP command, followed by authentication from the client’s MCP screen.
Add the FluxNative server for the selected project.
Complete the sign-in and approval flow.
Start with an inspection request before editing.
Cursor
Cursor uses its MCP configuration file and a setting that enables the connected server.
Add the project server to the Cursor MCP configuration.
Enable it in Cursor Settings.
Confirm the agent is looking at the intended FluxNative project.
Divide work between the agent and workspace
A local coding agent is most useful when the task benefits from reading several files, making a coordinated source change or applying a precise implementation pattern. For example, you might ask it to adjust a navigation flow, refactor a component, or update several screens so they use the same existing service. The agent works against the real project rather than a pasted code sample.
FluxNative remains valuable for the parts that depend on the app as a product rather than just a set of files. Its preview is a web build of the same project, shown in a device frame for review. The App panel shows screens, navigation and shared components, while Code lets the team inspect the source in the workspace.
Use a clear handoff after each meaningful external change. Let the agent finish one coherent task, then open the FluxNative project, inspect the revision and click through the preview. If the result is wrong, undo the revision before starting a different experiment. This keeps the project’s history easier to understand than a long sequence of unrelated edits.
The external agent changes the source; the FluxNative workspace tells you whether the app still works as a product.
Use the agent for — Multi-file source changes, focused refactors and implementation work that benefits from local coding context.
Use FluxNative for — Previewing the app, reviewing revisions, managing connections, running builds and preparing releases.
Review in batches — Group related changes into a small revision, then inspect the preview before adding another layer.
Avoid overlap — Do not have a chat turn and an external agent rewrite the same area simultaneously.
Keep integrations and secrets in Connections
Remote MCP is for source access. It does not turn an external editor into a place where your backend credentials should be entered. FluxNative projects have a Connections panel with separate tabs for Backend, In-app purchases and API keys and secrets.
Use Connections for Supabase, Firebase, Cloudflare or your own API, and for RevenueCat when the app has subscriptions. Named secrets are stored in the project’s vault. The assistant can see a secret’s name and description, but not its value, and those values are not exposed to the connected editor.
This separation is useful when an external agent needs to add code that calls an existing service. The developer can ask the agent to work with the project’s current integration patterns without placing a credential in chat or a local MCP configuration. The actual connection setup stays in FluxNative.
Backend work
Connect the backend in FluxNative first, then ask the coding agent to implement or adjust the app code that uses the configured service.
Supabase
Firebase
Cloudflare
Your own HTTP or GraphQL API
Payments and secrets
RevenueCat belongs under In-app purchases, while named secret values belong in API keys and secrets.
Never send a key in chat.
Do not place a secret in MCP configuration.
Let FluxNative deliver connected secrets through its supported project integrations.
Build and publish from the shared project
After the code change passes review, use the FluxNative build panel rather than treating the local agent as the release system. Android builds produce a signed APK or App Bundle on FluxNative’s builders, using the project’s Android key. iOS builds run from the same build panel and produce a signed IPA when the required Apple credentials are connected.
This gives the team a practical checkpoint after local agent work: source revision, preview review, native build and then release preparation. A browser preview is useful for interaction review, but a native build is the right place to catch issues that only appear in the signed Android or iOS artifact.
When store accounts are connected, a finished App Bundle can be uploaded to the Google Play internal testing track and a signed IPA can be uploaded to TestFlight from the build panel. FluxNative also keeps a readiness checklist showing the Apple and Google steps and who owns them. Store review and production release remain with the account owner.
Review the external agent’s revision in the FluxNative project.
Run through the preview and check the affected screens and navigation.
Confirm that backend, purchase and secret connections are configured in Connections.
Create an Android APK, App Bundle or iOS IPA from the Build panel.
Use internal testing or TestFlight for device validation.
Follow the publishing checklist and leave production submission and store review with the account owner.
Use MCP safely with a team
A remote editor connection inherits the permissions of the person who authenticates it. That makes organization roles important. FluxNative organizations have owner, admin, developer and viewer roles, and developers and viewers can be limited to selected apps.
A developer can create, edit, export and build apps by default, while a viewer can open previews and export source without changing apps. Owners and admins have broader responsibilities around members, projects and publishing. The organization owner can adjust permissions for admin, developer and viewer roles, but billing and store account management stay with the owner.
Give MCP access to the people who should edit that particular app, and use app-level limits when a team member needs access to one project but not another. If someone only needs to review a preview or export source, a viewer role may be a better fit than connecting an editing client.
Connect an editor to the smallest project and role scope that supports the work.
Owner — Controls the organization, billing and store accounts.
Admin — Manages members and projects and can publish.
Developer — Can create, edit, export and build apps by default.
Viewer — Can open previews and export source but cannot change apps by default.
Frequently asked questions
Can Claude Code access every FluxNative project in my organization?
No. A remote MCP connection reaches one project only, selected by that project’s MCP URL. The connected editor is not a login to the rest of the workspace, and access is checked against the authenticated user’s current permissions.
Can Cursor see my backend credentials or API keys?
No. Secrets stored in Connections are not exposed to the editor. Enter credentials in FluxNative’s Connections panel, where values are stored securely and the assistant sees only the secret’s name and description.
Do edits made through Claude Code appear in FluxNative?
Yes. The external agent edits the same project source, and its writes land as revisions you can review and undo in the FluxNative workspace. You can then inspect the preview and continue with chat, builds or other project work.
Can I use MCP on the Free plan?
Remote MCP is included on the plans marked as supporting it on the pricing page. The Free plan does not include remote MCP, so check your organization’s plan before configuring an editor.
Do I still need FluxNative if I use a local coding agent?
Yes, if you want the shared project workflow around the source. FluxNative provides the live preview, Connections panel, signed Android and iOS builds, publishing checklist and organization permissions, while the local agent provides another way to read and edit the source.
Keep exploring
Connect an editor — Read the setup and security details for Claude Code, Cursor and the other supported MCP clients.
Tour the workspace — See where Connect editor, Code, Connections, Build, Publish and Export fit in the project screen.
Organizations and roles — Review team permissions and app-specific access before giving someone an editing connection.
Introduction — Understand how a FluxNative project moves from source and preview through connections, builds and publishing.