A git repository is a shared, timestamped history of every change to a codebase (or a spec), organized into commits, branches, and pull requests. For a PM, the payoff isn't writing git commands — it's reading that history to understand what changed, why, and who reviewed it before it shipped.

Quick Answer: Git tracks changes as a chain of commits; branches let engineers work in parallel without stepping on each other; a pull request (PR) bundles a branch's commits for review before they merge into the main line. Read the PR description and commit messages first — the diff (the line-by-line change) is the evidence, not the story.

Most PMs treat git as "the thing engineers do before Jira closes the ticket." That's a mistake — not because you should learn to branch and rebase, but because the pull request is often the single richest artifact in your entire product record. It has the proposed change, the reasoning, the reviewer's objections, and the final resolution, all timestamped. Skipping it means you're relying on secondhand summaries of a conversation you could have read directly.

This is the sibling piece to how the web works, explained for a PM's mental model and to what an API actually is for a product manager — together they cover the technical-foundations ground mapped out in the complete guide to technical foundations for PMs. This one is about the workflow layer: not what code does, but how a team agrees on changing it.

What Is Version Control, Actually?

Version control is a system that records every change to a set of files over time, who made it, and why — so a team can collaborate without overwriting each other's work or losing history. Git is the dominant implementation; it isn't a backup tool, it's a negotiated, reviewable record of decisions.

The mental shift that matters for PMs: stop thinking of git as "save history" and start thinking of it as "conversation history." Every commit is a discrete, described change. Every pull request is a proposal with a debate attached. The repo is a paper trail of engineering decisions — including the ones that affect scope, sequencing, and risk that you care about.

A few things that make this different from a shared Google Doc's version history:

  • Every change is attributable — a specific author, a specific timestamp, an immutable identifier (the commit hash).
  • Changes are branchable — multiple people can propose different, conflicting changes simultaneously without blocking each other.
  • Nothing merges silently — a pull request is a checkpoint where a second person has to look at the change before it becomes real.
  • The history is permanent — once merged, a commit's record doesn't disappear even if the code it introduced is later reverted.

None of this requires you to run a single git command. Most engineering orgs give PMs read access to GitHub, GitLab, or Bitbucket's web UI, and everything below is readable there.

The Core Vocabulary: Repo, Commit, Branch, Merge

A repository ("repo") is the full project — all files, plus their entire change history — living in one place, usually with a hosted copy (GitHub) that the team treats as the source of truth. Everything else in this article is a way of organizing changes within that one history.

TermWhat it isThe PM analogy
RepoThe whole project's files + full historyThe shared drive folder for a workstream
CommitOne discrete, described changeOne tracked edit in a doc's version history
BranchAn isolated line of work, split off from mainA copy of the doc for one specific proposal
MergeFolding a branch's commits back into mainAccepting suggested edits into the master doc
Pull requestA branch proposed for review before merging"Suggesting" mode plus a comment thread

Commits: the atomic unit of change

A commit is a snapshot of exactly what changed, paired with a message explaining why. Good commit messages answer "what problem did this solve" — not "fixed stuff." A commit message like Fix race condition in checkout retry logic tells you there was a bug affecting checkout, under some concurrency condition, now addressed with a retry-path fix. That's product-relevant information, sitting for free in the history.

Each commit has a unique hash (like a3f5c9d) — a permanent, unambiguous pointer you can reference in a ticket, a Slack thread, or a spec. When an engineer says "that landed in a3f5c9d," they mean: this exact, described, attributable change, in the permanent record.

Branches: parallel work without collision

A branch is an independent line of development that starts as a copy of main (the trunk/production line) and diverges as new commits are added to it. Branches exist so that one person's in-progress, possibly-broken work never touches the stable version everyone else depends on.

  1. An engineer branches off main — e.g. feature/checkout-retry.
  2. They commit changes on that branch, iterating freely.
  3. When ready, they open a pull request to propose merging that branch back into main.
  4. After review and approval, the branch merges — its commits join the permanent history of main.

Multiple branches can exist simultaneously for multiple features, each isolated, each eventually reviewed and merged (or abandoned) on its own timeline. This is why "when will that ship" is really two questions: is the branch done, and has the PR been merged.

Pull Requests: Where the Actual Decision Gets Made

A pull request (PR) is a proposal to merge one branch's commits into another, packaged with a description, a diff, and a review thread — it's the checkpoint where a second set of eyes evaluates a change before it becomes permanent. For a PM, the PR is the single most information-dense artifact in the entire workflow.

Everything you need to understand a change, without reading a line of code, usually lives in three places on a PR page:

  • The title and description — what the author intended to change and why, often linking the originating ticket or spec.
  • The comment thread — reviewers pushing back, asking questions, requesting changes; this is where hidden scope, edge cases, and disagreements surface.
  • The diff — the literal before/after of every changed line (covered in detail below).

A well-written PR description typically answers: what problem does this solve, what's the approach, what did the author explicitly not do, and how was it tested. If a PR description is missing all four, that's itself a signal — either the change is trivial, or the team's review discipline has slipped, both of which are useful things for a PM to notice.

What to read first on any PR: description, then comment thread, then diff. The diff shows what changed; the description and thread tell you why — and why is almost always the part relevant to your roadmap, not the syntax.

Merge conflicts, in plain terms

A merge conflict happens when two branches changed the same lines of the same file in incompatible ways, and git can't automatically decide which version wins. It isn't a bug — it's git correctly refusing to guess. An engineer resolves it by manually choosing (or combining) the correct final version, then committing that resolution. If you hear "we're blocked on a merge conflict," it usually means two people's work overlapped and someone needs a few minutes to reconcile it — rarely a deep technical problem, but often a sequencing one worth understanding if it recurs.

How to Read a Git Diff Without Fear

A diff is a line-by-line comparison showing exactly what was added, removed, or changed between two versions of a file — the core evidence of any commit or pull request. You don't need to read code fluently to extract signal from one; you need to recognize its formatting conventions.

The convention is near-universal across GitHub, GitLab, and most code review tools:

  • Lines prefixed with - (often shown on a red background) were removed.
  • Lines prefixed with + (often shown on a green background) were added.
  • Unmarked lines are unchanged context, shown so you can see the surrounding code.

Here's a minimal example — a config change that raises a retry limit and adds a timeout:

  const CHECKOUT_CONFIG = {
-   maxRetries: 2,
+   maxRetries: 5,
+   timeoutMs: 3000,
    backoffStrategy: "exponential",
  };

Reading this without any programming background: the retry limit went from 2 to 5, and a new 3-second timeout was introduced. Combined with a PR description like "increase checkout retries after seeing transient payment-gateway failures," you now understand a real reliability decision — how many attempts a failed checkout gets before giving up, and how long the system waits — without asking an engineer to translate it for you.

What to actually look for in a diff

You're not proofreading syntax. You're scanning for shape and scope, three things in particular:

  1. Size — a diff touching 4 lines is a tweak; one touching 400 lines across 12 files is a structural change, whatever the PR title says.
  2. File names — a change confined to a test file is lower-risk than one touching a payment or auth file; file paths are usually self-descriptive even to non-engineers.
  3. Deleted vs. added ratio — mostly red (deletions) often means removing a feature or simplifying; mostly green (additions) often means new capability; a roughly even mix often means a refactor.

You'll rarely need to evaluate correctness of a diff — that's the reviewer's job. Your job is to translate "this changed" into "here's what that means for the roadmap, the release note, or the risk conversation."

Reading the Workflow End to End: A Worked Example

Put the pieces together and a PR's lifecycle reads like a short, legible story, not an opaque process. Recognizing each stage tells you exactly where a change stands and what's still pending.

StageWhat it meansWhat a PM should ask
Branch openedWork has started, isolated from mainWhat's the target date / linked ticket?
Draft PRWork-in-progress, not ready for reviewIs this still exploratory or nearly done?
PR opened (ready)Author believes it's complete and correctDoes the description match the spec's intent?
Under reviewReviewers are reading, commenting, requesting changesAny blocking objections in the thread?
ApprovedAt least one reviewer signed offIs CI (automated tests) also green?
MergedCommits are now permanently part of mainIs this behind a feature flag, or live now?

This structure is exactly why treating a repo as "a shared history and review process" rather than "backup" matters: a PM who checks a PR's stage can answer "is this actually done" more precisely than a status update filtered through a standup. It's also directly analogous to concepts you already reason about — a branch review thread resembles a stakeholder walkthrough of a customer journey map, and a PR's "what problem does this solve" framing mirrors jobs-to-be-done reasoning: someone hired this change to do a specific job, and the description should say what job.

Why this literacy compounds

Once you can read a diff and a PR thread, three recurring PM pain points get easier. First, estimating what "almost done" means — a draft PR with an unresolved 15-comment thread is not almost done, regardless of what the ticket status says. Second, spotting scope creep — a diff that's 5x larger than the linked ticket implies is a conversation worth having before it merges, not after. Third, understanding technical debt decisions as they happen, rather than reconstructing them later — which is the same instinct behind explaining technical debt to a CEO: the reasoning was written down in a PR thread months before it became a retroactive excuse.

Where This Maps Onto Spec Review, Not Just Code

The version-control habits above aren't code-specific — they're a general pattern for reviewing any change to a shared, evolving document, including a product spec. Prodinja's Spec Studio applies this same PR-style diff model to your living PRD: when a spec changes, you see the before/after as a diff, alongside readiness gates and a hand-off view, rather than hunting through comment threads or emailed versions to figure out what actually moved. If you've internalized "read the description, then the thread, then the diff" for code, the exact same reading order works for reviewing a spec's revision history.

Key Takeaways

  • Git is a shared, reviewable history, not a backup system — every change is attributable, timestamped, and permanent once merged.
  • Commits are the atomic unit: a snapshot plus a message explaining why, referenceable forever by its hash.
  • Branches let parallel work happen safely; nothing reaches main without going through a pull request first.
  • The pull request, not the diff, is where the real information lives — read the description and comment thread before the line-by-line changes.
  • A diff's -/+ convention is learnable in five minutes: removed lines, added lines, unchanged context — no coding background required.
  • Diff size, touched files, and add/delete ratio tell you more about risk and scope than trying to evaluate code correctness.
  • The same review discipline transfers to spec review — a PR-style diff on a living PRD, as in Prodinja's Spec Studio, uses the identical reading order: description, thread, diff.

Frequently Asked Questions

Do I need to know how to code to read a git diff?

No — a diff's formatting convention (- for removed, + for added, unmarked for context) is readable without programming knowledge. You're scanning for scope and shape (how much changed, which files, what ratio of additions to deletions), not evaluating whether the code itself is correct.

What's the difference between a commit and a pull request?

A commit is one discrete, described change with a permanent identifier; a pull request bundles one or more commits from a branch and proposes merging them into the main line, with a description and review thread attached. Commits are the unit of change — pull requests are the unit of review.

Why do engineers use branches instead of just editing the main code directly?

Branches isolate in-progress, potentially broken work from the stable version everyone else depends on, so parallel work doesn't collide. Editing main directly means anyone pulling the latest code could get an unfinished or broken feature; branches defer that risk until a pull request confirms the change is ready.

What should a PM actually look at on a pull request?

Start with the title and description (what problem, what approach, what was skipped), then the comment thread (objections, edge cases, unresolved questions), and only then the diff itself. That order surfaces intent and risk fastest — the diff is confirming evidence, not the starting point.

Is Git the same thing as GitHub?

No — Git is the underlying version-control system that tracks commits, branches, and history; GitHub (along with GitLab, Bitbucket, and similar tools) is a hosting service that adds a web interface, pull requests, and collaboration features on top of Git. You can use Git without GitHub, but most teams pair the two.