How to Control Claude Code Remotely From Your Phone
Can I really control Claude Code from my phone?
I was skeptical. AI coding assistants feel inherently desktop-bound. They need file access, terminal control, and constant supervision. How could that possibly work from a mobile device?
Turns out, it works better than I expected. And the use case is more compelling than I initially thought.
The Problem: Claude Code Needs Approval
I use Claude Code’s autonomous mode extensively. I set up a task, enable bypass mode, and let it run. But there’s a catch.
Not everything should be fully autonomous. Some actions genuinely need human oversight:
- Deleting files
- Pushing to production branches
- Running commands with sudo
- Modifying database schemas
In semi-autonomous mode, Claude Code pauses at these critical actions, waiting for approval. Which is fine—unless I’m away from my desk.
That’s when I discovered the remote control feature.
Two Ways to Control Claude Code Remotely
There are two approaches to mobile control:
┌─────────────────────────────────────────────────────────────┐│ REMOTE CONTROL │├─────────────────────────┬───────────────────────────────────┤│ NATIVE FEATURE │ THIRD-PARTY TOOLS │├─────────────────────────┼───────────────────────────────────┤│ - Built into Claude │ - claudecodeui ││ Code │ - Custom webhook servers ││ - Lightweight │ - More control ││ - Mobile-friendly UI │ - Web dashboard ││ - Limited features │ - Advanced monitoring │└─────────────────────────┴───────────────────────────────────┘I tested both. Here’s what I found.
Native Remote Control: The Official Solution
Claude Code now has built-in remote control documented at code.claude.com/docs/en/remote-control. This is the simplest approach.
What It Does
The native feature handles:
- Approval requests - Receive push notifications when Claude needs permission
- Session monitoring - Check status of running sessions
- Action confirmation - Approve or deny file writes, command executions
- Session management - Stop or pause sessions remotely
How I Set It Up
The setup process was straightforward:
# Check current configurationclaude-code config list
# Enable remote controlclaude-code config set remote-control enabled
# Configure what requires approvalclaude-code config set require-approval-for file-delete,bash-sudo,git-push
# Optional: Set notification preferencesclaude-code config set notification-method pushOnce enabled, I could access the mobile interface through the Claude Code app or web portal.
My First Mobile Approval
I started a refactoring task on my desktop, then left for a coffee run. While waiting in line, I got a notification:
Claude Code: Requesting permission to delete
legacy-utils.ts
I opened the mobile interface, saw the context—Claude had created a new unified utility file and wanted to remove the old one—and approved it. Thirty seconds total.
┌─────────────────┐│ Claude Pauses ││ at critical ││ action │└────────┬────────┘ │ ▼┌─────────────────┐ ┌─────────────────┐│ Push │ │ You see: ││ Notification │────▶│ - Action type ││ to phone │ │ - File/context │└─────────────────┘ │ - Risk level │ └────────┬────────┘ │ ┌────────┴────────┐ │ │ ▼ ▼ ┌──────────┐ ┌──────────┐ │ APPROVE │ │ DENY │ └──────────┘ └──────────┘ │ │ └────────┬────────┘ │ ▼ ┌─────────────────┐ │ Claude │ │ continues... │ └─────────────────┘This changed how I think about AI-assisted development. I no longer need to be physically present for every decision.
What You Can Actually Do Remotely
The native feature supports several key actions:
Approve File Modifications
The most common use case. Claude wants to modify a file, you see the diff on your phone, approve or reject.
┌─────────────────────────────────────┐│ File Modification Request │├─────────────────────────────────────┤│ File: src/auth/login.ts ││ Risk: MEDIUM ││ Changes: +45 lines, -12 lines ││ ││ ┌─────────────────────────────────┐ ││ │ - const oldAuth = ... │ ││ │ + const newAuth = ... │ ││ │ + // Added retry logic │ ││ └─────────────────────────────────┘ ││ ││ [APPROVE] [DENY] │└─────────────────────────────────────┘Confirm Command Executions
Claude wants to run a bash command. You see the command, assess the risk, approve.
This is particularly useful for:
- Package installations (
npm install,pip install) - Build commands
- Database migrations
- Git operations
Monitor Session Progress
Check on long-running tasks:
- What’s Claude currently doing?
- How many files have been modified?
- Are there any errors?
- How long has it been running?
Stop or Pause Sessions
Emergency brake. If Claude is going down a wrong path, stop it immediately from your phone.
Advanced Control with claudecodeui
For power users, claudecodeui offers a more comprehensive web-based dashboard.
What It Adds
The third-party solution provides:
- Real-time dashboard - See all active sessions at once
- Full terminal output - Not just approval requests
- Session history - Review past sessions and their outcomes
- Multi-project view - Manage multiple Claude Code instances
- Custom webhooks - Build your own notification flows
Setting It Up
# Clone the repositorygit clone https://github.com/siteboon/claudecodeui.gitcd claudecodeui
# Install dependenciesnpm install
# Configure (optional - can use defaults)cp config.example.json config.json
# Start the web interfacenpm start
# Access from your phone at:# http://your-server-ip:3000What the Dashboard Looks Like
┌──────────────────────────────────────────────────────────────┐│ Claude Code Remote Dashboard [Settings] │├──────────────────────────────────────────────────────────────┤│ ││ Active Sessions: 2 ││ ││ ┌────────────────────────────────────────────────────┐ ││ │ Session: auth-refactor │ ││ │ Status: RUNNING │ ││ │ Duration: 2h 15m │ ││ │ Files modified: 12 │ ││ │ Last action: Writing tests for login.ts │ ││ │ [VIEW] [PAUSE] │ ││ └────────────────────────────────────────────────────┘ ││ ││ ┌────────────────────────────────────────────────────┐ ││ │ Session: api-migration │ ││ │ Status: AWAITING APPROVAL │ ││ │ Action: Delete file 'deprecated-api.ts' │ ││ │ [APPROVE] [DENY] │ ││ └────────────────────────────────────────────────────┘ ││ │└──────────────────────────────────────────────────────────────┘When to Use Each Solution
┌─────────────────┐ │ Need remote │ │ approvals only? │ └────────┬────────┘ │ ┌──────────────┴──────────────┐ │ │ YES NO │ │ ▼ ▼ ┌─────────────────┐ ┌─────────────────┐ │ Native Remote │ │ Need full │ │ Control │ │ dashboard? │ │ │ └────────┬────────┘ │ (simpler, │ │ │ built-in) │ ┌────────┴────────┐ └─────────────────┘ │ │ YES NO │ │ ▼ ▼ ┌──────────────┐ ┌──────────────┐ │ claudecodeui │ │ Native is │ │ │ │ probably │ │ (more │ │ sufficient │ │ features) │ │ │ └──────────────┘ └──────────────┘Limitations I’ve Encountered
Remote control isn’t perfect. Here’s what it can’t do:
No New Session Creation
You can manage existing sessions, but starting a fresh Claude Code session from scratch requires being at your computer. Remote control is for oversight, not initiation.
Limited Code Review
The mobile interface shows diffs and context, but reviewing complex code changes on a phone screen is impractical. I use remote approval for straightforward changes and save complex reviews for when I’m back at my desk.
Network Dependencies
Both native and third-party solutions require:
- Your development machine running Claude Code
- Network connectivity between phone and machine
- Server accessibility (for claudecodeui)
If your machine goes to sleep or loses network, remote control stops working.
Security Considerations
Think carefully about what you’re exposing:
- Approval requests contain file contents and context
- Web dashboards need proper authentication
- Mobile access means your phone becomes a security boundary
My Current Workflow
I’ve settled into a pattern that balances autonomy with oversight:
START (at desk) │ ├──▶ Define task with clear constraints │ ├──▶ Enable semi-autonomous mode │ (not full bypass) │ ├──▶ Configure approval requirements: │ - File deletions: require approval │ - Git push: require approval │ - Bash with sudo: require approval │ - File writes: auto-approve │ ├──▶ Leave Claude running │ ├──▶ Go mobile │ │ │ ├──▶ Receive notification │ │ │ ├──▶ Quick assessment on phone │ │ │ │ │ ├──▶ Low risk? → Approve │ │ │ │ │ └──▶ Uncertain? → Pause, review later │ │ │ └──▶ Return to find progress made │ └──▶ Final review at deskSecurity Best Practices
Remote access to your development environment requires careful security:
1. Limit What Requires Remote Approval
Don’t configure every action to need approval. That defeats the purpose of autonomy. Reserve remote approval for genuinely sensitive operations.
# Good: Targeted approval requirementsclaude-code config set require-approval-for file-delete,git-push-force,bash-sudo
# Bad: Too restrictiveclaude-code config set require-approval-for file-write,file-delete,bash-any,git-any2. Use Secure Connections
For claudecodeui or custom solutions:
- HTTPS, not HTTP
- Authentication required
- VPN or private network when possible
3. Audit Remote Actions
Keep logs of remote approvals. Know what you approved and when.
4. Lock Your Phone
Your phone now has access to approve code changes. Treat it accordingly.
The Reddit Insight
When I researched this topic, I found interesting patterns in community discussions:
-
Many users didn’t know this existed - Comments like “didn’t they just introduce the feature where u can do that on your phone?” suggest the feature is under-marketed.
-
Confusion between solutions - Users asked “why use third-party tools if Claude Code already does everything?” A fair question. The answer: native is for approvals, third-party is for comprehensive monitoring.
-
The approval workflow is the key use case - Users specifically mentioned wanting to “give the confirmations” remotely. This is exactly what native remote control provides.
When This Matters
Remote control sounds like a nice-to-have. But it changes how I work:
Scenario 1: Long-Running Tasks I start a major refactoring, enable semi-autonomous mode, go to a meeting. Claude works for two hours, pausing only when it needs to delete old files. I approve from my phone during the meeting break.
Scenario 2: Background Processing I’m running a test suite generation task. It takes 3 hours. I’m not sitting at my desk waiting. But when Claude wants to commit the changes, I get a notification and approve.
Scenario 3: Emergency Stops Claude starts down an unexpected path. I see it in the dashboard, stop the session immediately, preventing wasted time and potential issues.
Getting Started
If you want to try this:
- Start with native remote control - It’s built-in, no setup required beyond configuration
- Configure sensible approval requirements - Don’t over-approve or under-approve
- Test with a low-stakes session - Try it on a non-critical project first
- Evaluate if you need more - If native isn’t enough, explore claudecodeui
The feature exists. It works. And it genuinely changes the relationship between developer and AI assistant—from requiring constant presence to enabling productive oversight from anywhere.
Final Words + More Resources
My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me
Here are also the most important links from this article along with some further resources that will help you in this scope:
- 👨💻 Claude Code Remote Control Documentation
- 👨💻 claudecodeui GitHub Repository
- 👨💻 Reddit Discussion on Claude Code Remote Control
Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!
Comments