I keep running into the same failure mode when I’m using Claude Code seriously:

The session is doing fine… until it hits a permission prompt.

If I’m at my laptop, it’s a 2‑second decision. If I’m on my phone, it’s the difference between:

• the session finishing while I’m away, or
• the session just… sitting there, blocked.

This is the workflow I use to handle Claude permission prompts from my phone without turning my phone into a terminal.

TL;DR

1. Set up Happier (or attach via Direct sessions), then open the session on your phone.
2. Keep permissions in a sane mode (for me: Default or Safe YOLO for most work).
3. When the session asks for permission, approve / deny in context (and use “don’t ask again” style choices when they’re offered and you truly mean it).
4. If you’re stuck in Plan, treat Exit Plan Mode as a user-action request (not a normal permission prompt).

The problem (in plain language)

Claude can request permission when it wants to run tools that have real side effects — editing files, running commands, installing deps, etc.

That’s good. It’s a safety boundary.

But it also means:

• you can start a session, step away,
• and the whole run can stall on a single approval.

What I mean by “approve Claude permissions from your phone”

I don’t mean “run Claude on your phone.”

I mean:

• Claude Code is running on a machine you trust (laptop / server / dev box), where the repo and tools live.
• From your phone, you can review what Claude is asking and decide whether to allow it.

That distinction matters because it keeps this workflow realistic: the work still happens on the machine — you’re just unblocking it.

What I tried first (and what I didn’t love about it)

When I first hit this problem, I tried the obvious options:

• Just stay at my laptop: honestly great — but not realistic if the session takes 15–60 minutes and I’m moving around.
• SSH from my phone: it works, but on mobile I catch myself rushing the decision because reviewing context is awkward.
• Flip YOLO on and stop seeing prompts: fast, but it’s also the easiest way to end up with side effects I didn’t mean to allow.

What I ended up wanting was a way to review approvals in context from my phone.

• Happier: lets me approve Claude permission prompts from my phone with context, while the session keeps running on my machine. Trade-off: it’s still easy to rush the decision on mobile if you don’t slow down and read the request.

That’s the workflow this guide focuses on (with the honest caveat that there are still “real terminal moments” sometimes — conflicts, broken environments, weird edge cases).

How permissions work in Happier (the mental model)

Happier treats "permissions" as a first-class session setting:

• Permissions determine how often you’re asked to approve tool-like actions.
• The selection is stored on the session, so it stays consistent across devices.

That’s why phone approvals can be sane: you’re not guessing what the session will do — you’re looking at the session’s current policy.

Permission requests vs approvals vs user-action requests

These three are easy to confuse:

• Permission request: “Should this tool/action be allowed?”
• Approval request: “Should this higher-level action execute?” (via Happier’s action system)
• User-action request: “The agent needs a structured human decision to continue” (e.g. AskUserQuestion, Exit Plan Mode)

In practice, you’ll mostly care about:

• permission prompts (allow/deny)
• exit-plan-mode prompts (approve plan / request changes / variants)

Pick a permission mode that matches how you work

Happier exposes a few permission modes. The names are blunt on purpose:

• Default: ask when the provider/runtime asks.
• Read-only: deny write-like actions.
• Safe YOLO: auto-allow read-like actions; ask before write-like actions.
• YOLO: skip approvals as much as the provider allows.

A sane default (what I recommend for most people)

• Start with Default.
• If you’re getting interrupted too often by low-stakes prompts, move to Safe YOLO.
• Treat YOLO as an intentional “I’m going fast and I’ll review the diff after” mode.

A pattern that avoids most regret:

• Use Default or Safe YOLO day-to-day.
• Temporarily switch to Read-only when you’re debugging and want to prevent accidental writes.
• Use YOLO only when you’re intentionally trading safety for speed (and you’re ready to inspect the diff afterwards).

If you’re new to Happier (what it is, and where to get it)

If you haven’t seen Happier before: it’s an open-source companion app (mobile/web/desktop) for AI coding agents like Claude Code, Codex, and OpenCode.

The workflow here is: use Happier to approve prompts from your phone in context, while Claude Code keeps running on the machine that owns the workspace.

For this guide, that means you can handle Claude permission prompts in context (and keep sessions moving) without turning your phone into a terminal.

Get set up:

• How to run Happier from your phone
• GitHub: https://github.com/happier-dev/happier
• Install/download: https://github.com/happier-dev/happier#how-it-works
• Discord (community + support): https://discord.gg/W6Pb8KuHfg

Step-by-step: approve a Claude permission prompt from your phone

1) Open the session that’s blocked

From your phone (app or mobile web UI):

• open the session that’s running Claude
• scroll to where the prompt/request is surfaced

Depending on your settings, the permission request can appear either:

• in the transcript, or
• in the composer area (as a request UI)

2) Read what’s being requested (don’t just hit Allow)

Before approving, look for the concrete details the request includes, such as:

• command name
• target file path
• summary of the mutation (when available)

On a phone, the whole point is that you can make the decision with context.

3) Choose Allow / Deny (and optionally scope the decision)

If the provider offers scoped options (like “don’t ask again for this tool” or “don’t ask again for this command”), use them only when you really mean it.

Those “remember” choices are typically session-scoped, not a global permanent policy.

4) If you’re in Plan: handle “Exit Plan Mode” as a user-action request

This one trips people up.

Plan mode changes how Claude behaves, but it does not bypass permissions.

When Claude is ready to exit plan mode, Happier can surface Exit Plan Mode as a user-action request with choices like:

• Approve Plan
• Request changes
• (variants) Approve Plan (Accept Edits)
• (variants) Approve Plan (Bypass All Permissions)

Treat that as its own explicit decision — it’s not the same thing as a tool permission prompt.

Getting permission requests to your phone (notifications)

If you enable push notifications, Happier can notify you when a session is blocked on:

• a permission request, or
• a user-action request (like AskUserQuestion or Exit Plan Mode)

On mobile today:

• permission notifications can offer Allow / Deny
• user-action notifications can offer Answer

Important safety behavior: if the notification points at a server that isn’t trusted/known on the device, Happier routes you through a safer add/switch flow instead of silently approving on an unknown server.

Common mistakes

• Leaving YOLO on permanently → you stop seeing prompts, but you also stop noticing when you’ve crossed a boundary you cared about.
• Approving without reading → especially dangerous on mobile, where it’s tempting to just unblock the run.
• Confusing Exit Plan Mode with a tool permission → they’re different requests with different consequences.

Troubleshooting

Symptom: the session is blocked but I don’t see any prompt in the transcript

Likely causes:

• you’re not opening the right session (multi-server / multiple sessions)
• your prompt-surface setting is showing requests in the composer instead of transcript
• you’re looking at an older message and the request is further down (easy to miss on mobile)

Fix:

1. Open the session and scroll to the most recent messages.
2. Look near the composer for a request UI.
3. Check your Settings → Session → Permissions prompt-surface option.

Symptom: I tapped Allow/Deny from a notification, but nothing happened

Likely causes:

• the notification targeted a server/profile that isn’t trusted/active on this phone yet
• the machine/daemon isn’t reachable right now
• the request changed state (already handled) by the time you tapped

Fix:

1. Open the app directly (not just the notification).
2. Confirm you’re connected to the correct server/profile.
3. Open the session and check Inbox/transcript for the current request state.

Symptom: I keep getting permission prompts for the same tool/command

Likely causes:

• the provider/runtime doesn’t support a stable allowlist update for that request
• you’re switching permission modes back and forth, so your effective policy keeps changing

Fix:

1. If available, use the scoped “don’t ask again” option for the tool/command.
2. Otherwise, consider switching to Safe YOLO for the duration of the task.

Symptom: I’m getting "Exit Plan Mode" requests and I’m not sure what to pick

Likely cause:

• this is a user-action request (plan review), not a normal permission prompt.

Fix:

• If you want execution to start: pick Approve Plan.
• If you want Claude to revise the plan: pick Request changes.
• Only use “bypass permissions” style variants when you explicitly want that behavior after plan ends.

FAQ

Is this the same as turning on YOLO?

No.

The whole point is to keep prompts meaningful and reviewable — and to be able to make the decision from mobile with context.

Does Plan mode bypass permissions?

No. Plan mode is separate from permissions.

You can be in Plan mode and still get permission prompts.

Is this secure?

It’s as secure as the device + server trust you set up.

The important bit is: Happier avoids silent approvals on unknown servers, and permissions remain explicit.

Related guides

• How to run Happier from your phone
• How to commit code from your phone