When I started running multiple AI agents in parallel, I noticed something: I was approving permissions and letting them work, but I wasn't systematically reviewing what they actually did until much later.

By the time I looked at the diffs, patterns emerged:

• One agent was adding debug prints I didn't want
• Another kept reformatting unrelated files
• A third was making progress but in a direction I should have steered earlier

I needed a mobile-first review workflow that caught these patterns before they spread across sessions.

TL;DR

1. After each significant turn or at natural break points, review what the agent changed
2. Use Happier's diff review from your phone (no SSH required)
3. Check for patterns: formatting churn, scope creep, debug artifacts
4. Catch mistakes while context is fresh, not hours later
5. For multiple agents: review all sessions daily to spot cross-session patterns

The problem

AI agents work fast. That's the point.

But speed means:

• Changes accumulate quickly
• You approve permissions based on descriptions, not full diffs
• By the time you git diff, dozens of files changed
• Spotting "the agent is going sideways" happens too late

The expensive failure mode isn't one bad change. It's:

• An agent develops a pattern (over-commenting, unnecessary refactors)
• You don't notice for 3 hours
• Now that pattern is in 6 files across 4 sessions
• Rolling back means re-explaining context

What I tried first (and where I bounced off)

• Review at the end of the day: Too late. Patterns already spread.
• SSH and run git diff: Works but tedious on mobile. I'd rush and miss things.
• GitHub PR diffs: Good for final review, but I want to check before committing.
• Trust the agent: Fast but risky. Quality varies by task complexity.

Happier's mobile diff review solved this:

• See diffs from your phone without SSH
• Review after each turn or on schedule
• Inline with session context
• Can request changes immediately

If you're new to Happier

Happier is an open-source companion app for AI coding agents like Claude Code, Codex, and OpenCode.

The workflow here: agents run on your machine, Happier shows you what changed from your phone, and you can spot issues before they compound.

Get set up:

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

Step-by-step: review agent changes from your phone

1) Open the session

From the Happier app:

1. Tap the session you want to review
2. Wait for the current turn to finish (or open while it's running)

2) Access the diff review

Look for diff/changes access points:

• In the session transcript, turn summaries may include change indicators
• Session info/details often show file change counts
• Swipe or tap to access diff view

3) Review changed files

The diff view shows:

• Which files changed
• Line-by-line additions and deletions
• Syntax highlighting
• File path context

On mobile:

• Scroll through files one at a time
• Focus on high-risk changes (core logic, config files)
• Skim safe changes (tests, comments)

4) Look for patterns

Common agent patterns to catch early:

Debug artifacts:

# Added debug print the agent forgot to remove
print(f"DEBUG: user_id={user_id}")

Formatting churn:

- existing_function()
+ existing_function(
+ )

The logic didn't change but now every line shows as modified.

Scope creep:

# You asked to fix auth.py
# Agent also reformatted database.py, models.py, utils.py

Over-commenting:

# Initialize the variable
x = 0
# Increment the variable
x += 1

Unnecessary complexity: The agent replaced 5 lines with 20 lines of over-engineered abstraction.

5) Act on what you find

If the changes look good:

• Continue to the next session or task
• Commit if this is a logical stopping point

If you spot issues:

• Reply to the agent: "Remove debug prints from auth.py before continuing"
• Or: "Revert the formatting changes to database.py, that file wasn't in scope"
• The agent can fix it before you commit

A workflow for multiple parallel agents

When running 3-5 agents at once:

Morning check-in

1. Open each session
2. Review what each agent did overnight
3. Spot patterns across sessions

Example finding:

"All three agents are adding type hints inconsistently. Two use typing.List, one uses list. Set a standard."

Lunch review

1. Check sessions that finished turns
2. Review their diffs
3. Approve next steps or request corrections

End-of-day audit

1. Review all uncommitted changes across all sessions
2. Look for cross-session patterns
3. Commit clean work, fix or discard the rest

Quality patterns to watch for

File selection accuracy

Did the agent touch files you expected?

Good:

• You asked to fix auth
• It modified: auth.py, auth_test.py

Red flag:

• You asked to fix auth
• It modified: auth.py, database.py, utils.py, config.py, README.md

Change granularity

Are changes focused or sprawling?

Good:

• 50-line function modified, 3 lines changed

Red flag:

• 50-line function modified, 45 lines changed (possible rewrite when edit was expected)

Test coverage

Did the agent add/update tests?

Good:

• Modified feature.py and added tests in feature_test.py

Red flag:

• Modified core logic, no test changes

Commit boundaries

Can you commit this work cleanly?

Good:

• One logical change, ready to commit

Red flag:

• Three unrelated changes mixed together
• Debug code still present
• Commented-out code left in

Catching agent drift early

Agent drift: when the agent's understanding of the task gradually shifts.

Signs:

• First change: exactly what you asked
• Second change: still related but broader
• Third change: now solving adjacent problems you didn't ask for

Catch it early:

Review after each turn. If turn 2 shows drift, redirect immediately:

"The CSV export looks good, but don't refactor the entire import system yet. Let's test the export first."

Don't catch it early:

Review at the end. Now the agent refactored imports across 12 files and you have to untangle what's safe to keep.

Mobile review tips

Focus on high-signal files

You don't need to review every changed file line-by-line.

Priority order:

1. Core logic files (auth, business logic, API handlers)
2. Configuration files (can break everything)
3. Tests (make sure they test the right thing)
4. Documentation (lower risk, review later)

Use change counts as triage

If a session changed:

• 3 files, 50 lines: Review now, fast scan
• 12 files, 300 lines: Review now, focus on core files
• 50 files, 2000 lines: Probably formatting or refactor, spot-check 5 key files

Review at natural boundaries

Don't review mid-turn unless the agent is stuck.

Review when:

• Agent finishes a turn and asks what's next
• Agent completes a logical milestone
• You're about to approve the next big permission

Troubleshooting

Symptom: Can't see diffs from the app

Likely cause:

• Session is running on a machine Happier can't access
• Git repository not initialized
• Diff view not available for this session type

Fix:

1. Ensure the session's machine is reachable
2. Verify the session is in a git repository
3. Check session type supports diff review

Symptom: Too many changes to review on mobile

Likely cause:

• Agent made sweeping refactor or formatting change
• Multiple turns combined

Fix:

1. Triage: focus on core files first
2. Switch to desktop for full review
3. Or: ask agent to summarize changes by file

Symptom: Agent keeps making the same mistakes

Likely cause:

• Pattern not explicitly addressed in agent instructions
• Agent doesn't have project style guide

Fix:

1. Create or update AGENTS.md with style rules
2. Be explicit: "Don't add debug prints", "Don't reformat files outside scope"
3. After correction, verify agent understood in next turn

Common questions

Should I review every single turn?

No. Review at logical boundaries:

• After completing a subtask
• Before committing
• When multiple turns accumulated
• When switching agents

For exploratory work, review less often. For production code, review more.

What if I spot a mistake hours later?

Ask the agent to fix it:

"In auth.py line 45, you added a debug print. Remove it and check for others."

Or revert the file:

git checkout HEAD -- auth.py

Then ask the agent to redo that specific change.

Can I review without Happier?

Yes:

git diff
git status

But on mobile, SSH + git is awkward compared to Happier's UI.

Does this work for all agents?

Works for any agent running in a git repository:

• Claude Code
• Codex
• OpenCode
• Custom agents

The diff is standard git output, not agent-specific.

How do I review work across multiple agents?

From your phone:

1. Open Happier
2. Check each session's recent changes
3. Look for conflicting patterns or overlapping edits

Or from desktop:

git diff main
git log --oneline --graph

Related guides

• How to review diffs from your phone
• How to review what changed in the last turn (diff summary)
• Get notified when an agent is waiting on you across many parallel sessions
• How to tell which Claude Code, Codex, and OpenCode session is stuck