Skip to content

Parallel Dev ​

This lens answers: who keeps committing to the same files in the same week, and on which files? A file with two or more people in one week has a collision that week, and the lens counts them by pair of people and by file.

Its biggest limit is that a collision is a fact about timing, not about trouble. GitRelic never reads what changed, so two people fixing unrelated functions count the same as two people fighting over one. Read every number here as "worth asking about."

Reading the numbers ​

What you seeWhat it means
"6 pairs of people on the same files in the same week"Every two people with at least one collision, on any counted file. That includes files the table doesn't list, so this number can be above zero while the table is empty.
"Dara Quinn and Eli Marsh committed to the same files in 15 weeks: pipeline.py, schema.py."The pair who meet most, and the two files they shared most.
A pair's weeksCalendar weeks, not file-weeks. If two people collide on four files in one week, that's one week for the pair.
"pipeline.py had two or more people in 12 of its 40 active weeks."The file with the most collision weeks. An active week is a week the file had a counted commit from anyone, in the analyzed period. It doesn't count the weeks in between.
"…one of 4 files that change together."The file sits in a family that shares one row in Collision lanes (see How it's measured).
"Left out 6 sweeping commits (over 20 files) and 40 bot commits…"Commits the lens ignored completely. They add no collisions and no active weeks.
Score0 to 100, from the share of a file's active weeks with a collision, raised when those weeks were crowded. It's not a percentage: 40% of weeks at 4 people scores 80.
A score of 8 in the tableThere's no minimum score. A file is listed for having 3 or more active weeks and 2 or more collision weeks, however low that scores.
Weeks with 2+ peopleThe file's collision weeks. The table sorts by this, so its top row may not have the top score.
Most people in a weekThe most people on that file in any one week.
"Dara Quinn, Eli Marsh, Fatima Noor +1"The people who collided on the file, most collision weeks first. Three are named, and the rest are a count.
"0 files" on the OverviewThe Overview counts listed files, not pairs. It can read 0 while the lens shows pairs. Its preview of the ten most contested files, such as "parallel 30," ranks by score.

The tiers, and other cuts of the score ​

The table's tiers are Low (0–24), Medium (25–49), High (50–74) and Critical (75 and up). They exist only in the table. A high tier doesn't mean most of a file's weeks had a collision, because crowded weeks raise the score: 40% of weeks at 4 people is Critical.

Other parts of the dashboard cut the same score at different places:

WhereCuts atWhat it does
Table25, 50, 75Names the tier
The rail's badge70Counts "heavy same-week editing" files, and shows when those reach 2% of the repository's files
Cursed Files20Adds 5 points at 20, rising evenly to 20 points at 100

So a file scoring 72 is High in the table, counts as heavy on the rail and earns 15 Cursed Files points, and a file scoring 22 is Low and still earns 5. Cursed Files also considers the ten highest-scoring files here as candidates.

Four example repositories ​

These repositories are invented, but each result is what GitRelic reports for commits like these.

A Go service where people overlap but no file repeats ​

2 pairs of people on the same files in the same week

Ana Ruiz and Ben Okoye committed to the same files in 6 weeks: audit.go, balance.go.

Collision lanes shows no rows, and says:

No file had two or more people in two weeks

One overlap on a file is chance, so it isn't listed.

What it means: Ana and Ben met in six different weeks, each time on a different file in internal/ledger. Each file had one collision week, so none clears the bar: the table is empty, and the Overview reads "0 files." The pairs still count them: one overlap on a file can be chance, but six overlaps across six files is a pattern between two people.

What to look at: no single file is in dispute, so the question is about the folder. Ownership shows whether internal/ledger has a clear owner. A longer window with --since all shows whether any of these files had a second collision earlier.

A Python repo where the score and the weeks disagree ​

Dara Quinn and Eli Marsh committed to the same files in 15 weeks: pipeline.py, schema.py.

pipeline.py had two or more people in 12 of its 40 active weeks.

FileWeeks with 2+ peopleActive weeksMost people in a weekScoreTier
etl/pipeline.py1240230Medium
etl/schema.py410480Critical
etl/sinks.py34275Critical
etl/retry.py22528Low

What it means: four different stories, and the score alone would hide them.

  • pipeline.py has the most collisions and only a Medium score, because 12 of 40 weeks is 30%. Two people have been sharing it steadily.
  • schema.py scores 80 from just 4 weeks. Those weeks are 40% of its 10 active weeks, and all four people were on it each time, which doubles the 40.
  • sinks.py scores 75 because 3 of its 4 active weeks had a collision. That's a high score on very little history.
  • retry.py is listed at 8: 2 of 25 weeks. It's the lowest reading, and it's on the list because it had two collision weeks.

What to look at: Collision lanes separates a habit from an episode. schema.py's four stacks are four weeks in a row, so it's worth asking whether that change is finished. pipeline.py's are spread through the period, so it's the one to ask whether two people should keep sharing.

A TypeScript monorepo with a family of files ​

Hana Ito and Ivan Petrov committed to the same files in 7 weeks: flags.android.ts, flags.ios.ts.

flags.android.ts had two or more people in 7 of its 12 active weeks, one of 4 files that change together.

Left out 6 sweeping commits (over 20 files) and 40 bot commits: two big commits in one week aren't people coordinating.

FileWeeks with 2+ peopleActive weeksScoreTier
packages/app/src/flags.android.ts71258High
packages/app/src/flags.ios.ts71258High
packages/app/src/flags.server.ts71258High
packages/app/src/flags.web.ts71258High
packages/app/src/router.ts2540Medium

What it means: the table has five rows, but this is one pair and two topics. Collision lanes draws two rows, flags.* (4 files, 7 weeks) and router.ts. The pair's 7 weeks isn't the 30 you'd get by adding up the table: the four flag files collide in the same seven weeks, and the router's two fall inside them.

The left-out line matters as well. Hana and Ivan each ran a sweeping commit over the same 30 view files in three weeks. Counted, each of those files would show 3 collision weeks out of 3 active, a score of 100, for what were codemods.

What to look at: Coupling shows how tightly those flag files move together. If each flag means editing four files by hand, that's what puts two people on them, and it's worth asking whether it has to.

A Rust repo where one partner is an AI agent ​

Copilot and Mei Lin committed to the same files in 9 weeks: lexer.rs, ast.rs.

lexer.rs had two or more people in 11 of its 14 active weeks.

FilePeopleWeeks with 2+ peopleActive weeksScoreTier
crates/parser/src/lexer.rsMei Lin, Copilot, Tomas Reyes111479Critical

What it means: bots are left out, but AI agents aren't, so an agent that makes its own commits sits in the circle like anyone else. Here 9 of the 11 collision weeks are Mei and Copilot. Without Copilot's commits the same file would have 2 collision weeks of 14, a score of 14, which is Low. Mei is the only person still on this file, and Tomas, marked gone, accounts for the other two weeks.

What to look at: decide whether a person working next to an agent is the kind of overlap you care about. There's no option to leave agents out, so read the People column before the tier. AI & Co-authors shows how much of the work comes from agents.

How it's measured ​

The period is the last 12 months by default. Use --since all for everything, or --since with a date. Only commits reachable from the analyzed branch count.

A week runs Monday to Sunday in UTC, using each commit's author date. A person is counted once per week per file, however many commits they made.

What's left out:

  • Merge commits, which are never read.

  • Sweeping commits, which touch more than 20 files. All of a commit's paths count toward the 20, including tests and config, so the whole commit goes. A commit of exactly 20 files stays.

  • Bot commits. See what counts as a bot. AI agents aren't bots, so their commits count.

  • Files that aren't source. --include-fixtures doesn't bring any back here. This covers:

    • Tests: *.test.*, *.spec.*, foo_test.go, test_foo.py, FooTest.java, BarTests.cs, __tests__/, tests/, Tests/, *.Tests/, src/test/, and test/ or spec/ at the repository's root or a package's
    • Fixtures: fixtures/, __fixtures__/, testdata/, __snapshots__/, __mocks__/, *.snap
    • Generated code: __generated__/, vendor/, third_party/, *.generated.*, *.pb.go, *.min.js
    • Plumbing: package manifests and lockfiles, changelogs, licenses, .github/, tsconfig.json, *.config.ts

    Source means everything else. That includes docs such as a README, and files in a test/ folder deeper in the tree, as in lib/test/, where the name is too ambiguous to rule out.

  • Files that no longer exist in the analyzed commit. Work on a deleted file is dropped. So is a renamed file's activity under its old path, since the old path no longer exists. Only commits under the current name count, starting with the rename commit itself.

People are commit authors, by email address, after .mailmap. One person's split addresses (different capitalization, a GitHub noreply address, the same full name) are merged by default, and --no-merge-identities turns that off. A Co-authored-by: trailer doesn't make someone an author here.

Pairs skip the file rules. A pair's weeks count every collision on any counted file, including a file with one collision week or fewer than 3 active weeks. So the pair count and the chords can include overlaps on files that the table, the score and Collision lanes don't show. A file's rules ask whether that file is contested. A pair who met once each on six files, in six different weeks, still met six times.

The score is calculated only for listed files:

share of weeks  = collision weeks ÷ active weeks × 100
average people  = people per collision week, averaged over collision weeks
multiplier      = average people ÷ 2, kept between 1.0 and 2.0
score           = share of weeks × multiplier, rounded, at most 100

Two people is the normal collision and adds nothing. Three people on average multiplies by 1.5, and four or more by 2.

FileActive weeksCollision weeksAverage peopleShareMultiplierScore
pipeline.py40122301.030
Router.java1053501.575
schema.py1044402.080
core.rs5531001.5100 (capped from 150)
retry.py252281.08
cool.ts1012——Not listed: one collision week

Families. Files that nearly always change together share a row in Collision lanes. Two listed files join when their shared commits number at least 5 and make up at least 75% of the busier file's commits, as measured by Coupling. A family is named for what its file names share (flags.*), or after one member when they share too little (api.ts +2). The table still lists each file on its own.

In the dashboard ​

Find this lens under Team & Activity.

  • Pairs is the main picture. People sit around an oval, with a chord between two people who've had a collision, as wide as their weeks compared with the widest chord. Up to 24 people are drawn, those with the most weeks added across all their pairs, and partners sit near each other so groups form neighborhoods. Anyone whose partners all fell outside the 24 isn't drawn, and if that would leave no chords, whole pairs are seated instead, most weeks first. A dot's size is the same sum, so a week shared with two partners counts twice. Its color shows whether the person is active, quiet or gone, as defined in Contributors, and the line under their name says which.
    • Point at a person to light their chords and fade the rest. Click to keep them lit: people they never met dim, and each partner's line says something like "4 weeks with Ana Ruiz."
    • Hover a chord for the two people, their weeks and the files they shared most. A pair keeps five files at most, so in "and 2 more" the real number can be higher.
  • Collision lanes (the corner toggle) answers where and when. Each row is a file or a family, with weeks across, or months when the period is longer than two years. Each week with a collision is a stack of dots, one per person, colored by the same status. The 14 rows with the most collision weeks are drawn, and the rest are in the table.
    • A stack shows everyone from that row's files in that column. In a family's row or a month column, the people in a stack didn't necessarily meet on one file in one week.
    • Hover a dot for the person, the week and who else was there. Click a dot to select that person, which lights their dots in every row and fades the rest. Click a row to select its file. Hover a family's row for the files in it.
  • The time strip under the picture shows all commits per week, including ones this lens leaves out, and not collisions. A selection lights its own weeks.
  • The inspector, with nothing selected, shows the pair count, the findings quoted above and up to six pairs who meet most. Each name selects that person.
  • The table (T) lists every file with 2 or more collision weeks: its people, weeks with 2+ people, active weeks, most people in a week, score and package. It starts with the most collision weeks first. Its filter says "Filter by path…" but matches people's names too, so typing a name lists the files that person collided on. It lists files, not pairs, so a pair outside the circle and the inspector's six appears only in the People column, and nowhere if none of their files is listed.

With no collisions at all, Pairs says "No two people committed to the same file in the same week."

What it can't tell you ​

  • Whether anyone got in anyone's way. A collision is two commits to one file in one week. They may touch different functions, or be one person's review fixes on another's work. Likewise it can't tell you whether they talked.
  • Whether these files have more bugs. The lens's one-line description in the dashboard says concurrent work correlates with defects. GitRelic doesn't measure that on your repository, and a high score doesn't show a file is defective. Fix Rate counts how often a file's changes needed fixing.
  • Overlap that doesn't land in one week. A Sunday commit and a Monday commit a day apart aren't a collision, and a Monday and Friday commit four days apart are. Because weeks are in UTC, a Sunday evening in the Americas can already be next week.
  • When work reached the branch. The author date is when the commit was written, and it survives a rebase. Commits on branches that aren't merged don't appear at all. Neither do collisions inside a squash-merged PR, which becomes one commit with one author.
  • Who else worked on a commit. Only the author counts, so pair programming shows as one person. AI & Co-authors shows who is credited together.
  • Much about new files, or from a short window. A file under 3 active weeks can't be listed however crowded it was. And a short window means fewer active weeks, so scores move with --since: the same two collisions read differently against 4 weeks and against 40.
  • Files across a rename. Collisions before a rename are dropped, so a renamed file starts over and may fall below the bars. See Renames.
  • One person with two unmerged addresses. If GitRelic can't tell that two addresses belong to one person, they can collide with themselves. A .mailmap fixes it.
  • Contributors — who works on what, and what active, quiet and gone mean.
  • AI & Co-authors — who's credited together on one commit, and how much comes from AI agents.
  • Coupling — files that change in the same commits, behind the families here.
  • Cursed Files — uses this score as one of its reasons.
  • Fix Rate — how often changes need a fix, which this lens doesn't measure.
  • Ownership — how much of each package rests on one person.
  • Renames — what a move does to a file's history, which this lens doesn't follow.

Released under the MIT License.