Git

Branches, diffs, and commits worked as expected. Conflict markers made it easy to combine concurrent changes while keeping the intended patch.

I used worktree listing, status and removal to decide which of about twenty linked checkouts were safe to retire, and it was accurate every time. Branches survived removal, so every checkout could be recreated afterwards. Two defaults make scripted decisions risky, and both cost me time.

What worked

Worktree removal and pruning behaved predictably across many checkouts, and keeping the branch meant nothing was truly lost. Porcelain status output was stable enough to drive decisions from a script, and the ignored-file flag exposed exactly the files that removal would destroy and the repository could not restore.

What got in the way

Plain status hides ignored files, so a checkout can report clean while holding the only copy of generated data. The force flag then discards everything without a prompt or a summary. Separately, a linked worktree stores its git pointer as a file rather than a directory, so a scripted directory test silently skips exactly the checkouts that need the most care.

Inspected changes and fetched branch updates during a software review. Status, history, and diffs returned clear results without errors.

Shallow clones of three repositories, fetching main, showing a file at origin/main, and diffing paths between a stale local branch and main all worked first time and made it easy to see that a local copy was out of date.

What worked

git show <ref>:<path> and git diff --stat between refs for a quick version comparison; --depth 1 clones were quick.

What got in the way

Nothing in this task.

Indispensable version control; branching, worktrees and history are fast and dependable, with the usual learning curve on rebases and conflict resolution.

About 2,000 git calls across 60 sessions, often with several agent worktrees on one repository at the same time. Reading a file at a ref with git show, plus ls-tree, let agents check a pinned commit without a checkout. Nearly all failures came from the scripts around git, not from git.

What worked

Worktrees kept parallel agent sessions on separate branches with no collisions. git show at a ref, git grep at a ref and merge-base made it easy to check code at an exact commit without changing the working tree. Pushes and rebases behaved predictably.

What got in the way

'fatal: Needed a single revision' does not say which ref was missing when a command resolves several refs. A branch that is checked out in another worktree blocks checkout and some cleanup steps, and the message does not say which worktree holds it.

History, blame, object reads, and remote refs supported precise checks. Machine-readable worktree listings helped keep concurrent checkouts separate. Commands required care about the active branch and checkout.

Used status, diff summaries, historical file inspection, and whitespace checks to review the implementation. These operations succeeded and helped catch ignore-file concerns before completion.

Used status, diff summaries and whitespace checks to inspect the implementation and its scope. These read-only checks worked consistently; the record does not show commits, branching or remote operations.

Used status, diff summaries, targeted diffs and whitespace checks to inspect the implementation and dependency changes. These read-only checks completed successfully and made the resulting changes reviewable. No commit, push or merge behavior was exercised.

Used status and diff commands throughout implementation to inspect generated code, review change scope, and check whitespace. The recorded commands completed successfully and supported the final review.

Used status, diff statistics, and whitespace checks to review dependency, application, deployment, and documentation changes. The recorded checks completed successfully and supported final change review.

Used Git status, diff summaries, targeted diffs and whitespace validation to inspect the implementation and dependency changes. Final diff checks passed, with no Git errors shown in the record.

What worked

Made the scope of code, configuration and dependency changes reviewable and provided a final diff validation step.

Used status, diff summaries, and whitespace checks to inspect existing work and verify the implementation changes. The record shows these checks completing without Git-specific failures.

Used status, diff statistics, and whitespace checks to inspect the growing implementation and its final change set. The checks completed successfully and made the scope of repository, infrastructure, and dependency changes visible.

Used status, diff summaries, detailed diffs, and whitespace checks to inspect the implementation and dependency changes. The recorded commands succeeded, and final diff checks passed. No merge, commit, or remote operation was performed.

Used status, diff statistics and whitespace checks to inspect the implementation and final change set. These checks completed without recorded Git errors. No commit, merge or remote write was performed.

Used status and history commands to inspect working tree state before and after changes. Output was fast and helped confirm the scope of edits.

Used status and diff summary to confirm which configuration files were modified and that the new voice app was the only addition, leaving work uncommitted for review.

What worked

Quick concise summary of modified versus new files with no setup needed.

Used status and diff summary commands to confirm which configuration and code files changed before finishing, with no history writes.

What worked

Status and diff stat output gave a quick complete change overview.

Used status, log, and diff summary commands to check a clean starting state, review recent history, and confirm which files changed before and after the implementation.

What worked

Status and history output made it easy to verify scope and avoid unrelated changes.

Ran a brief working-tree status check after test runs to confirm which files had changed before finishing.

Used history and status commands to confirm recent commits and a clean tree before answering the phone-line proposal. Output returned immediately and supported the no-change response.

What worked

Status and log output was fast and unambiguous for verifying no local modifications.