How to commit code from your phone

I keep ending up one clean commit away from “done” at the exact moment I’m not in front of my laptop.

It’s usually a small thing: an agent session wrapped up, I spot a couple drive-by fixes, and I want to lock in a clean baseline before I forget why I touched those files.

From my phone, I’m not trying to do fancy Git surgery. I just want a tight loop:

Review the diff → stage intentionally → write a good message → commit → (maybe) push.

The version of this that works for me is: use Happier as the control surface (review/stage/compose), while the actual repo and Git operations stay on the machine that owns the workspace (laptop / server / dev box).

TL;DR (the workflow)

If you want the quick version, it’s:

Open the session on your phone and check Source control.
Read the diff in Review (before you stage anything).
Stage only what belongs together.
Write a commit message (optionally generate a draft, then edit it).
Commit.
Push only if the repo state is clean (no conflicts / not behind / not detached).

What “commit from your phone” actually means (in practice)

A commit has to happen where the repository working tree lives (your laptop, server, or dev box). So the question isn’t “can my phone run git?” — it’s:

can you review and control the repo from your phone,
while the actual git operations run on the machine that owns the workspace.

That’s the workflow Happier is designed around: a phone (app or mobile web UI) as the control surface, and a machine/daemon as the execution surface.

When this approach is a good fit (and when it isn’t)

This workflow fits when:

You have a repo that lives on a machine you control (laptop, server, dev box), and you want a conservative surface for diff review + staging + committing. You’re also okay with the fact that Git write actions are behind a feature toggle (and may be marked experimental).

It’s not a fit when:

You need history surgery (rebase, reset, cherry-pick), you’re mid-conflict, or the machine that owns the repo simply isn’t reachable. In those cases, I switch back to a real terminal.

The option landscape (quick and honest)

Before the step-by-step, here are the approaches I keep circling back to — and where each one fits.

SSH + tmux
- Great when: you want full control and you’re already comfortable with terminal Git
- Trade-off on a phone: diff review and precise staging take more attention than they should on a small screen
Remote desktop
- Great when: you need access to your exact desktop tooling for one-off fixes
- Trade-off on a phone: it’s heavy and fiddly (especially selection + staging)
GitHub mobile
- Great when: you’re reviewing PRs, commenting, or doing quick repo browsing
- Trade-off: it can’t commit to the working tree that lives on your laptop/server; you’re operating on GitHub, not your running workspace
A session companion UI (Happier-style)
- Great when: you want a phone-friendly “control surface” for review + staging + commit, still operating on the real repo
- Trade-off: it depends on the owning machine/daemon being reachable, and Git write ops are still feature-gated/experimental

The closest mental model, for me, is a “GitHub Desktop-style” surface you can use on a phone — but still operating on the repo where it actually lives (not a separate copy in the cloud).

Prerequisites

You’ll need:

A Happier session connected to the machine that has your repo.
Repository/file access available (these screens can only show real data when the machine-level workspace APIs are reachable).

Enable Git write operations (important)

By default, Happier’s repository browsing and diff review can be available, but Git write actions (stage/unstage/commit/pull/push/etc.) are gated behind a feature toggle:

Go to Settings → Features → Git operations
Enable it (treat it as experimental)

If you don’t enable Git operations, you can still use the same workflow to review changes, but you’ll finish the commit from the terminal.

Step-by-step: commit code from your phone

The exact UI layout changes between desktop and mobile. On phone-sized screens, I’ve found it works better when the app uses focused “one thing at a time” screens (instead of squeezing a desktop sidebar layout into a tiny viewport).

1) Open Source control

In your session UI:

Open Source control (the repository status surface)

You should see:

the current branch summary
a changed-files list (with status like A, M, D)
additions/removals summaries where available

If you don’t see repo status at all, jump to Troubleshooting.

2) Review diffs (before staging)

Do a quick pass before you stage anything:

Open the Review surface to scroll through uncommitted diffs as one continuous review.
Collapse files you’re done with.
If you need to fix a file, open it in the editor, make the edit, then come back to Review.

On a phone, I find it much easier to stay oriented in a purpose-built diff/review UI than in a raw terminal.

3) Stage intentionally

From the changed-files list you can:

stage/unstage whole files
(where supported) stage selected lines/hunks

When I’m committing from a phone, staging discipline matters more than usual. My default rule:

stage only the files that belong to one coherent change
leave drive-by formatting, debug logs, and unrelated edits for a separate commit

4) Write a commit message (optionally generate a draft)

At the bottom of Source control, Happier provides a commit composer.

You can type your own message, or use Generate commit message to draft one.

Important notes:

the generator proposes text; it does not auto-commit
you can configure backend/instructions in Settings → Source Control

Even if you use the generator, treat it like autocomplete: skim the staged diff and adjust the message to match what you actually staged.

5) Commit

Commit the staged changes.

If Happier blocks the action, it’s usually because the repo is in a state that’s unsafe for automated UI operations (conflicts, detached HEAD, etc.). That’s intentional.

6) Push (optional) — understand the safety rails

If you choose to push from the phone, expect conservative safety rails. This is one of the reasons I like the “control surface” approach: it’s biased toward “refuse unsafe operations”.

Examples of the kinds of rules you may run into:

pull is fast-forward only
push/pull/revert are blocked when HEAD is detached
push is blocked when local is behind upstream
push/pull/revert are blocked while conflicts are present

If you hit a block, that’s usually the right moment to either:

fix the repo state from a full terminal, or
switch branches / clean up / resolve conflicts first.

A practical workflow for AI coding sessions (Claude/Codex/etc.)

If your “commit from phone” need comes from running an agent session, the phone-first loop that’s been the least painful for me is:

Review what the agent changed in Review
Make small edits from the built-in editor (fix naming, remove accidental files)
Commit with a tight message
Send a follow-up instruction to the agent (“continue from this clean baseline”)

One subtle but useful habit: use the composer Link file / file browsing tools to attach exact files into your next prompt, instead of describing paths manually.

Attachments vs project files (don’t commit the wrong thing)

Happier supports attachments as a session workflow. Attachments are great for:

pasting logs
sharing one-off files
sending artifacts for the model to read

…but attachments are not the same thing as project files you intend to commit.

If your goal is “this should land in git”, put it in the workspace via Files (create/upload/edit) — not as a transient attachment.

Troubleshooting

I can’t see Source control / diffs on my phone

Common causes:

The machine/daemon that owns the repo isn’t reachable.
You’re not connected to the same server/relay as your machine.

If the session is inactive but the machine is online, Happier can still load repository/file data via machine-level workspace APIs — but only if it can actually reach that machine.

Staging/commit buttons are missing

Git write actions are behind a toggle:

Settings → Features → Git operations

Happier won’t let me push/pull/commit

That’s usually a repo safety rule doing its job. Typical blockers:

conflicts present
detached HEAD
branch is behind upstream

Resolve the repo state from a full terminal, then come back to the phone workflow.

I can review diffs but can’t commit

That can happen if read-only repo data is available but write operations are disabled (feature toggle off) or blocked by repo state.

In that case, the “best of both worlds” workflow is:

do your diff review + cleanup on the phone
then finish the actual commit/push from the terminal when you’re back at a laptop

FAQ

Can I do this from an iPhone or Android phone?

Yes — the main difference is ergonomics.

On phones, Happier uses focused screens (lists → details) instead of a multi-pane desktop layout.
On iOS/Android, you may prefer reviewing diffs and staging on mobile, then doing any conflict cleanup from a full terminal later.

Why can I review diffs, but I can’t stage/commit?

Two common reasons:

Git write operations aren’t enabled. Enable Settings → Features → Git operations.
The repo is in a state where write ops are intentionally blocked (conflicts, detached HEAD, etc.).

Why is push blocked?

Happier is conservative by design. Push is typically blocked when:

HEAD is detached
the local branch is behind upstream
conflicts are present

In those cases, treat the phone workflow as: review + stage + commit. Then push after you’ve cleaned up repo state from a full terminal.

Do I have to push from my phone?

No. A totally reasonable “phone-first” workflow is:

review diffs
stage intentionally
commit

…and then push later when you’re back at a laptop (or when you’re comfortable doing a quick terminal sanity check).

What if my machine/daemon isn’t reachable?

Then you won’t be able to load source-control state from the repo. At that point your options are:

wait until the machine is reachable again, or
fall back to SSH / remote desktop.

Happier doesn’t make network or machine availability issues disappear — it just gives you a better control surface when the machine is reachable.

How to run Happier from your phone

Next steps

If your main pain is code review: a dedicated guide on “review diffs from your phone” is usually a better starting point (it’s a slightly different flow than committing).
If you keep getting blocked at the same step (commit/push missing, repo not reachable, etc.), turn that into a tiny checklist for yourself — it’ll save you 10 minutes every time.