I like AI coding tools, but I don’t like the feeling of committing changes I haven’t actually reviewed.

That’s easy when I’m at my desk. It gets weird when I’m on my phone:

• SSH shows you the truth, but reviewing diffs and staging precisely on a tiny screen is exhausting.
• GitHub mobile is great for PR review, but it doesn’t help much when the changes are sitting uncommitted on your machine.
• Remote desktop works, but it’s the easiest way to misclick your way into a bad commit.

What I wanted was something closer to:

“Let me scroll the diff set like a real review, open a file to inspect it, make one tiny fix, then move on.”

This is the workflow I ended up with after trying the usual options (SSH, remote desktop, GitHub mobile) and not loving the trade-offs on a phone.

TL;DR

1. Set up Happier (or attach via Direct sessions), then open the session on your phone.
2. Go to Source control → Review.
3. Scroll through the full uncommitted diff set; collapse what you’re done with.
4. When something looks off, open that file into an editor tab, fix it, then return to Review.
5. When you trust the diff, you can stage/commit — or stop at “review only” and commit later from a laptop.

The problem (in plain language)

When an agent changes a lot of files (or even just a few important ones), you need to answer two questions before you commit:

• What changed? (not just which files, but what the diff actually is)
• Do I trust it? (is it the right change, scoped correctly, and not smuggling in surprises)

On a phone, the main failure mode is that you stop reviewing carefully because the tools are awkward.

What I mean by “review diffs from your phone”

I don’t mean “edit your repo on your phone.”

I mean:

• The repo and tools live on a machine you trust (laptop / server / dev box).
• From your phone, you can inspect uncommitted changes with enough context to make a good decision.

If the machine isn’t reachable, you can’t review the real working tree state — at that point you’re back to SSH/remote desktop.

What I tried first (and why I kept bouncing off it)

• SSH + git diff works, but on a phone I end up skimming and missing the “wait, why did this file change?” moments.
• Remote desktop works, but it’s the fastest way to misclick your way into a bad edit on mobile.
• GitHub mobile is great for PR review, but it doesn’t show the uncommitted working tree on your machine.

What I wanted was a review surface I’d actually use from a phone — scroll diffs like a PR, jump into a file, make one fix, keep going.

• Happier: gives me that “scroll the diff set like a PR” experience on my phone, while the repo stays on my machine. Trade-off: if the machine/daemon isn’t reachable, you’re back to SSH/remote desktop.

The mental model: changed-files list vs “Review”

A changed-files list answers: “what files changed?”

A review surface answers: “what work happened?”

In Happier, the Review view is meant to be the “scroll through the actual work” surface:

• diffs render progressively
• you can collapse files as you finish them
• you can jump into an editor without losing your place

That’s the thing that makes mobile review feel less awkward than doing it in a tiny terminal.

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 review diffs directly from your phone, while the repo and Git stay on the machine that owns the workspace.

For this guide, that means you can review the real uncommitted working tree diff from mobile (and even make a small fix) without falling back to remote desktop.

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: review uncommitted diffs from your phone

1) Open Source control

In the session UI, open Source control.

You should see the branch summary and a changed-files list.

2) Open Review

Open Review.

Now scroll the diff set like you would in a PR review:

• collapse files you’re done with
• stop when you see something suspicious

3) Inspect and fix small issues (without losing your place)

When you spot something small (naming, stray debug log, wrong config edit):

• open that file in the editor
• make the fix
• return to Review and keep going

The key is that review stays continuous; you’re not constantly context-switching.

4) Decide what you’re going to do next

After a good review, you have a few reasonable outcomes:

• Review only: you trust the changes, and you’ll stage/commit later from a laptop.
• Stage/commit now (if Git operations are enabled) and you’re comfortable doing it from mobile.
• Send a follow-up instruction to the agent (“fix these two files, revert this one, and split commits”).

Attachments vs project files (don’t confuse the two)

If you’re reviewing changes, make sure you’re looking at workspace files (the repo) — not just attachments.

Attachments are great for sending logs or one-off artifacts to the model, but they’re not the same as repo-backed files you intend to commit.

Common mistakes

• Only reviewing the file list (not the diff) → you miss the actual risky change.
• Reviewing in a terminal on mobile, then rushing → you approve something you wouldn’t have on desktop.
• Assuming GitHub mobile reflects your machine → it doesn’t, unless the changes are already pushed into a PR.

Troubleshooting

Symptom: I can’t see Source control or diffs

Likely causes:

• the owning machine/daemon isn’t reachable
• you’re on the wrong server/profile

Fix:

1. Confirm you’re connected to the right server.
2. Confirm the machine is online/reachable.

Symptom: Review is empty but I know files changed

Likely causes:

• you’re looking at the wrong repository/workspace
• the SCM backend hasn’t refreshed yet

Fix:

• go back to the changed-files list and confirm you’re in the correct repo context

FAQ

Can I review diffs from my phone without committing?

Yes — and it’s often the best default.

Review on the phone, then do the actual commit/push later from a laptop when you have full tooling.

Is this good enough for reviewing AI-generated code?

It’s good enough for a first pass — especially for catching obvious scope issues.

For high-risk changes, I still prefer doing a deeper review on a laptop (or asking a second agent to review) before merging.

Related guides

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