Products · Product

Git

Raised as a usability problem by 2,203 people on Hacker News over 19 years (2008–2026), in 1,171 threads.

Ranked by people · period

This year (last 12 months)Last 5 yearsSince the beginning (2007)

1
History is hard to navigate and discoverUnreviewed
7 people this year · 7 threads
2
Reset and checkout do too much, making them confusingUnreviewed
5 people this year · 4 threads
3
Worktrees are hard to manage, with conflicts and confusing branchingUnreviewed
5 people this year · 5 threads
4
Moderately complex commands are hard to remember and discoverUnreviewed
4 people this year · 4 threads
5
Merges produce unwanted conflicts that must be manually undoneUnreviewed
4 people this year · 4 threads
6
Needless complexity requires extensive reading and practiceUnreviewed
4 people this year · 4 threads
7
Editing an older commit needs many error-prone manual rebase stepsUnreviewed
4 people this year · 3 threads
8
Must constantly google how to do thingsUnreviewed
4 people this year · 4 threads
9
Staging area causes surprises that users don't expectUnreviewed
3 people this year · 3 threads

1
Moderately complex commands are hard to remember and discoverUnreviewed
30 people in the last 5 years · 26 threads
2
Merges produce unwanted conflicts that must be manually undoneUnreviewed
21 people in the last 5 years · 18 threads
3
Reset and checkout do too much, making them confusingUnreviewed
21 people in the last 5 years · 17 threads
4
Editing an older commit needs many error-prone manual rebase stepsUnreviewed
20 people in the last 5 years · 17 threads
5
Dozens of obscure options make the commands confusingUnreviewed
19 people in the last 5 years · 16 threads
6
Rebase is tricky to get right and recovering from mistakes wastes timeUnreviewed
18 people in the last 5 years · 16 threads
7
Creating a branch doesn't switch to it, and checkout -b isn't foundUnreviewed
15 people in the last 5 years · 15 threads
8
Basic tasks need deep knowledge of internalsUnreviewed
15 people in the last 5 years · 12 threads
9
History is hard to navigate and discoverUnreviewed
15 people in the last 5 years · 15 threads
10
Needless complexity requires extensive reading and practiceUnreviewed
12 people in the last 5 years · 12 threads
11
Must constantly google how to do thingsUnreviewed
12 people in the last 5 years · 11 threads
12
Rebasing produces conflicts that are harder to resolveUnreviewed
12 people in the last 5 years · 12 threads
13
Checkout does different things, making Git inconsistent to learnUnreviewed
11 people in the last 5 years · 10 threads
14
Same merge conflicts reappear on every rebase of an old branchUnreviewed
11 people in the last 5 years · 11 threads
15
Inconsistent flags and command names make commands hard to rememberUnreviewed
11 people in the last 5 years · 11 threads
16
Worktrees are hard to manage, with conflicts and confusing branchingUnreviewed
11 people in the last 5 years · 10 threads
17
Reverting a file with checkout silently discards changesUnreviewed
9 people in the last 5 years · 9 threads
18
Basic operations are easy to mess up, and rebase is frustratingUnreviewed
9 people in the last 5 years · 8 threads
19
Reflog shows only hashes and messages, making commits hard to findUnreviewed
8 people in the last 5 years · 7 threads
20
Git LFS is so clunky the team had to build a workaroundUnreviewed
7 people in the last 5 years · 6 threads
21
Merge conflicts push users into random actions that break reposUnreviewed
7 people in the last 5 years · 6 threads
22
Cherry-picking between branches causes painful later conflictsUnreviewed
6 people in the last 5 years · 5 threads
23
Push fails on other branches and pull does not fix itUnreviewed
6 people in the last 5 years · 6 threads
24
Git branches differ from what other software calls branchesUnreviewed
6 people in the last 5 years · 6 threads
25
Merge commits clutter the log with noisy entriesUnreviewed
6 people in the last 5 years · 6 threads
26
Ours and theirs meanings flip between rebase and mergeUnreviewed
6 people in the last 5 years · 6 threads
27
Easy to get stuck in bad repo statesUnreviewed
5 people in the last 5 years · 5 threads
28
Finding how to do tasks is confusing for new developersUnreviewed
5 people in the last 5 years · 5 threads
29
Names like pull, checkout and rebase are vague for new usersUnreviewed
5 people in the last 5 years · 4 threads
30
Hard to tell how far back in the reflog to undo a rebaseUnreviewed
5 people in the last 5 years · 5 threads
31
Recovering from mistakes takes disproportionate effort for little valueUnreviewed
5 people in the last 5 years · 5 threads
32
Easy to enter detached HEAD state and hard to recover fromUnreviewed
5 people in the last 5 years · 5 threads
33
No easy way to split a commit with unrelated changesUnreviewed
5 people in the last 5 years · 4 threads
34
Submodules are easy to trip over, such as forgetting --recursive when cloningUnreviewed
4 people in the last 5 years · 4 threads
35
Staging area causes surprises that users don't expectUnreviewed
4 people in the last 5 years · 4 threads
36
Switching branches requires stashing, and the stash stack is hard to trackUnreviewed
4 people in the last 5 years · 4 threads
37
Merging heavy branches is painful to learnUnreviewed
4 people in the last 5 years · 4 threads
38
Mail clients are hard to configure for git-over-emailUnreviewed
4 people in the last 5 years · 4 threads
39
Easy to forget new untracked files, so they're left out of commitsUnreviewed
4 people in the last 5 years · 4 threads
40
Merge conflicts, lost changes and reset cause trouble for usersUnreviewed
4 people in the last 5 years · 4 threads
41
Rebase conflicts that go wrong force restarting the workUnreviewed
4 people in the last 5 years · 4 threads
42
Verbs like checkout don't match what they do, so commands can't be memorisedUnreviewed
4 people in the last 5 years · 4 threads
43
Overloaded command is a footgun that silently causes mistakesUnreviewed
4 people in the last 5 years · 4 threads
44
Commands like git diff --cached must be memorised by heartUnreviewed
3 people in the last 5 years · 3 threads
45
Must repeatedly split and skip hunks to stage the right changesUnreviewed
3 people in the last 5 years · 3 threads
46
Add-then-commit staging confuses learners and persists into rebaseUnreviewed
3 people in the last 5 years · 3 threads
47
Undo isn't straightforward among inconsistent commandsUnreviewed
3 people in the last 5 years · 3 threads
48
Repository state is hidden unless users run commands, so changes get missedUnreviewed
3 people in the last 5 years · 3 threads
49
Too many features make it hard to work out proper usageUnreviewed
3 people in the last 5 years · 3 threads
50
Email-based patch submission is hard for contributors to useUnreviewed
3 people in the last 5 years · 3 threads
51
Command-line inconsistency forces users to think in commitsUnreviewed
3 people in the last 5 years · 3 threads
52
Pull error message is unhelpful, so diverged branches get misdiagnosedUnreviewed
3 people in the last 5 years · 3 threads
53
Undoing an undo is counterintuitive and multi-step undo needs the reflogUnreviewed
3 people in the last 5 years · 3 threads
54
Conflict output lacks base context, forcing lookups of each side's changesUnreviewed
3 people in the last 5 years · 3 threads
55
Experts still mess up many footguns on hard tasksUnreviewed
3 people in the last 5 years · 3 threads
56
Rebase parameters and the --onto flag are confusingUnreviewed
3 people in the last 5 years · 3 threads
57
Fixing a diverged branch needs obscure commands, so people copy the repoUnreviewed
3 people in the last 5 years · 3 threads
58
Applying one stashed file requires checkout, which is unintuitiveUnreviewed
3 people in the last 5 years · 3 threads
59
Footguns must be navigated every time a user does anythingUnreviewed
3 people in the last 5 years · 3 threads
60
Docs don't distinguish when snapshot and diff models applyUnreviewed
3 people in the last 5 years · 3 threads

1
Moderately complex commands are hard to remember and discoverUnreviewed
95 people since the beginning · 81 threads
2
Dozens of obscure options make the commands confusingUnreviewed
78 people since the beginning · 57 threads
3
Creating a branch doesn't switch to it, and checkout -b isn't foundUnreviewed
53 people since the beginning · 41 threads
4
Merges produce unwanted conflicts that must be manually undoneUnreviewed
51 people since the beginning · 45 threads
5
Reset and checkout do too much, making them confusingUnreviewed
48 people since the beginning · 42 threads
6
Needless complexity requires extensive reading and practiceUnreviewed
41 people since the beginning · 40 threads
7
Editing an older commit needs many error-prone manual rebase stepsUnreviewed
39 people since the beginning · 35 threads
8
Basic tasks need deep knowledge of internalsUnreviewed
32 people since the beginning · 28 threads
9
Checkout does different things, making Git inconsistent to learnUnreviewed
30 people since the beginning · 27 threads
10
Rebase is tricky to get right and recovering from mistakes wastes timeUnreviewed
29 people since the beginning · 27 threads
11
Inconsistent flags and command names make commands hard to rememberUnreviewed
29 people since the beginning · 23 threads
12
History is hard to navigate and discoverUnreviewed
25 people since the beginning · 25 threads
13
Must constantly google how to do thingsUnreviewed
25 people since the beginning · 24 threads
14
Reverting a file with checkout silently discards changesUnreviewed
24 people since the beginning · 23 threads
15
Same merge conflicts reappear on every rebase of an old branchUnreviewed
21 people since the beginning · 21 threads
16
Easy to get stuck in bad repo statesUnreviewed
19 people since the beginning · 18 threads
17
Rebasing produces conflicts that are harder to resolveUnreviewed
18 people since the beginning · 16 threads
18
Reflog shows only hashes and messages, making commits hard to findUnreviewed
17 people since the beginning · 16 threads
19
Finding how to do tasks is confusing for new developersUnreviewed
16 people since the beginning · 16 threads
20
Cherry-picking between branches causes painful later conflictsUnreviewed
16 people since the beginning · 15 threads
21
Error messages are cryptic, leaving users unable to see what went wrongUnreviewed
15 people since the beginning · 13 threads
22
Commands like git diff --cached must be memorised by heartUnreviewed
14 people since the beginning · 13 threads
23
Basic operations are easy to mess up, and rebase is frustratingUnreviewed
14 people since the beginning · 13 threads
24
Switching branches requires stashing, and the stash stack is hard to trackUnreviewed
13 people since the beginning · 10 threads
25
Submodules are easy to trip over, such as forgetting --recursive when cloningUnreviewed
12 people since the beginning · 12 threads
26
Push fails on other branches and pull does not fix itUnreviewed
12 people since the beginning · 12 threads
27
Same operations need obscure flags and multi-step incantationsUnreviewed
12 people since the beginning · 9 threads
28
Common tasks take several commands, with obscure arguments for fewerUnreviewed
12 people since the beginning · 11 threads
29
Git LFS is so clunky the team had to build a workaroundUnreviewed
12 people since the beginning · 9 threads
30
Names like pull, checkout and rebase are vague for new usersUnreviewed
11 people since the beginning · 10 threads
31
Must repeatedly split and skip hunks to stage the right changesUnreviewed
11 people since the beginning · 11 threads
32
Pull-before-push sequence is unclear, merging in others' work unintentionallyUnreviewed
11 people since the beginning · 11 threads
33
Worktrees are hard to manage, with conflicts and confusing branchingUnreviewed
11 people since the beginning · 10 threads
34
Staging area causes surprises that users don't expectUnreviewed
10 people since the beginning · 10 threads
35
Git branches differ from what other software calls branchesUnreviewed
10 people since the beginning · 10 threads
36
Hard to tell how far back in the reflog to undo a rebaseUnreviewed
10 people since the beginning · 9 threads
37
Cloning a repo with many binaries takes days, so folders get copied manuallyUnreviewed
10 people since the beginning · 10 threads
38
Add-then-commit staging confuses learners and persists into rebaseUnreviewed
10 people since the beginning · 10 threads
39
Undo isn't straightforward among inconsistent commandsUnreviewed
10 people since the beginning · 10 threads
40
Merge commits clutter the log with noisy entriesUnreviewed
9 people since the beginning · 9 threads
41
Merge conflicts push users into random actions that break reposUnreviewed
9 people since the beginning · 8 threads
42
Must learn it deeply just to use it at allUnreviewed
8 people since the beginning · 8 threads
43
Recovering from mistakes takes disproportionate effort for little valueUnreviewed
8 people since the beginning · 8 threads
44
Workflow exposes implementation, hard for non-developers to useUnreviewed
8 people since the beginning · 8 threads
45
Hard to remember which command discards file changesUnreviewed
8 people since the beginning · 7 threads
46
No easy way to split a commit with unrelated changesUnreviewed
8 people since the beginning · 7 threads
47
Staging area is called index, cache and staging, causing confusionUnreviewed
8 people since the beginning · 8 threads
48
Deleting a remote branch is confusing for usersUnreviewed
7 people since the beginning · 7 threads
49
So many how-to guides are needed to use itUnreviewed
7 people since the beginning · 7 threads
50
Switching branches silently deletes uncommitted changesUnreviewed
7 people since the beginning · 7 threads
51
Poorly chosen defaults make mistakes easy to makeUnreviewed
7 people since the beginning · 7 threads
52
Needs many explanatory articles to understandUnreviewed
7 people since the beginning · 7 threads
53
Easy to enter detached HEAD state and hard to recover fromUnreviewed
7 people since the beginning · 7 threads
54
Merging heavy branches is painful to learnUnreviewed
7 people since the beginning · 7 threads
55
Ours and theirs meanings flip between rebase and mergeUnreviewed
7 people since the beginning · 7 threads
56
Too many features make it hard to work out proper usageUnreviewed
7 people since the beginning · 7 threads
57
Push rejection messages are cryptic and give no next stepUnreviewed
7 people since the beginning · 6 threads
58
Repository state is hidden unless users run commands, so changes get missedUnreviewed
6 people since the beginning · 6 threads
59
Shallow clones break git log and blame, sparse checkouts need the full repoUnreviewed
6 people since the beginning · 6 threads
60
Must read multiple man pages to find needed informationUnreviewed
6 people since the beginning · 6 threads
61
Overloaded concepts and terms cause unexpected behaviorUnreviewed
6 people since the beginning · 6 threads
62
Mail clients are hard to configure for git-over-emailUnreviewed
6 people since the beginning · 6 threads
63
Recovering from a mistake or undoing it becomes complicated and dangerousUnreviewed
6 people since the beginning · 6 threads
64
Command-line inconsistency forces users to think in commitsUnreviewed
6 people since the beginning · 6 threads
65
Easy to forget new untracked files, so they're left out of commitsUnreviewed
6 people since the beginning · 6 threads
66
Manual committing means people forget to commit their changesUnreviewed
6 people since the beginning · 6 threads
67
Confusion comes from underlying concepts, not verb names like pushUnreviewed
6 people since the beginning · 6 threads
68
Each command does many things, so finding one means long help pagesUnreviewed
5 people since the beginning · 5 threads
69
Stash stack loses entries on pop and can't pop with uncommitted changesUnreviewed
5 people since the beginning · 5 threads
70
Commits hidden by a rebase are hard to findUnreviewed
5 people since the beginning · 5 threads
71
Long commit messages wrap badly in the terminalUnreviewed
5 people since the beginning · 5 threads
72
Email-based patch submission is hard for contributors to useUnreviewed
5 people since the beginning · 5 threads
73
Docs don't help with real-world mistakes, conflicts or undoing errorsUnreviewed
5 people since the beginning · 5 threads
74
Setting up a central repo across many projects is time-consumingUnreviewed
5 people since the beginning · 5 threads
75
Merge conflicts, lost changes and reset cause trouble for usersUnreviewed
5 people since the beginning · 5 threads
76
Stashing and untangling work-in-progress commits becomes tediousUnreviewed
5 people since the beginning · 5 threads
77
Pull error message is unhelpful, so diverged branches get misdiagnosedUnreviewed
5 people since the beginning · 5 threads
78
Merging UI pushes people toward a single mergerUnreviewed
5 people since the beginning · 4 threads
79
Undoing an undo is counterintuitive and multi-step undo needs the reflogUnreviewed
5 people since the beginning · 4 threads
80
Conflict output lacks base context, forcing lookups of each side's changesUnreviewed
4 people since the beginning · 4 threads
81
Easy to reach states where users don't know how to recoverUnreviewed
4 people since the beginning · 4 threads
82
Previewing pulls and undoing a bad pull is counter-intuitiveUnreviewed
4 people since the beginning · 4 threads
83
Viewing file history or undeleting a file needs convoluted commandsUnreviewed
4 people since the beginning · 4 threads
84
Command line hides which branches and commits exist, requiring memorized commandsUnreviewed
4 people since the beginning · 4 threads
85
Setting up SSH keys is painful for non-technical usersUnreviewed
4 people since the beginning · 4 threads
86
Aliasing a builtin silently causes confusing behavior, with no warningUnreviewed
4 people since the beginning · 4 threads
87
Pull and fetch names mean different things despite seeming similarUnreviewed
4 people since the beginning · 4 threads
88
Hard to remember many commands and find commit hashes in logsUnreviewed
4 people since the beginning · 4 threads
89
Newer features are ugly and need extra manual config setupUnreviewed
4 people since the beginning · 4 threads
90
Rebase conflicts that go wrong force restarting the workUnreviewed
4 people since the beginning · 4 threads
91
People copy-paste commands they don't understandUnreviewed
4 people since the beginning · 4 threads
92
Git output is inconsistent to parse and its format options are underdocumentedUnreviewed
4 people since the beginning · 4 threads
93
Experts still mess up many footguns on hard tasksUnreviewed
4 people since the beginning · 4 threads
94
Rebase parameters and the --onto flag are confusingUnreviewed
4 people since the beginning · 4 threads
95
Applying one stashed file requires checkout, which is unintuitiveUnreviewed
4 people since the beginning · 4 threads
96
Size warning on small screens forces zooming out until text is unreadableUnreviewed
4 people since the beginning · 4 threads
97
History-editing commands are hard for beginners to useUnreviewed
4 people since the beginning · 4 threads
98
Non-developers can't undo things partially outside linear commitsUnreviewed
4 people since the beginning · 4 threads
99
Poorly named commands often do the wrong thingUnreviewed
4 people since the beginning · 4 threads
100
Behavior is unpredictable, so users memorise commands by roteUnreviewed
4 people since the beginning · 4 threads
101
Verbs like checkout don't match what they do, so commands can't be memorisedUnreviewed
4 people since the beginning · 4 threads
102
Overloaded command is a footgun that silently causes mistakesUnreviewed
4 people since the beginning · 4 threads
103
Fixing a diverged branch needs obscure commands, so people copy the repoUnreviewed
3 people since the beginning · 3 threads
104
Easy to commit unintended changes or lose local config editsUnreviewed
3 people since the beginning · 3 threads
105
Implementation complexity leaks inconsistently, making DAG operations hard to rememberUnreviewed
3 people since the beginning · 3 threads
106
GUIs lack drag-and-drop for rebasing commits, forcing tedious text editsUnreviewed
3 people since the beginning · 3 threads
107
Index and commit IDs are hard-to-understand abstractionsUnreviewed
3 people since the beginning · 3 threads
108
Hard to remember which option produces the desired resultUnreviewed
3 people since the beginning · 3 threads
109
Old versions show confusing errors instead of saying to upgradeUnreviewed
3 people since the beginning · 3 threads
110
Terminology is confusing and branch deletion syntax is hard to useUnreviewed
3 people since the beginning · 3 threads
111
Commands are learned by use-case, not concept, so mastery takes monthsUnreviewed
3 people since the beginning · 3 threads
112
Hooks can't be auto-installed, so teams must set them up manuallyUnreviewed
3 people since the beginning · 3 threads
113
Users must guess invocations and avoid footgunsUnreviewed
3 people since the beginning · 3 threads
114
Must stop to recall file-adding and push syntax when committingUnreviewed
3 people since the beginning · 3 threads
115
SSH keys and host settings must be copied to several placesUnreviewed
3 people since the beginning · 3 threads
116
Branch operations take many CLI steps and are easy to botchUnreviewed
3 people since the beginning · 3 threads
117
Silent LF to CRLF conversion causes a hard-to-diagnose build errorUnreviewed
3 people since the beginning · 3 threads
118
Uppercase protocol in URL makes clone fail, requiring lowercasing itUnreviewed
3 people since the beginning · 3 threads
119
Checking repo state via the CLI is slower and less clear than a GUIUnreviewed
3 people since the beginning · 3 threads
120
No symmetric command to unstage a file, needs obscure reset syntaxUnreviewed
3 people since the beginning · 3 threads
121
Expert users accidentally trash repositories and spread the damageUnreviewed
3 people since the beginning · 3 threads
122
Documentation is inconsistent, so reading it worsens understandingUnreviewed
3 people since the beginning · 3 threads
123
No visualization of repository data, making branch juggling hardUnreviewed
3 people since the beginning · 3 threads
124
Must manually stage files, since changes aren't committed by defaultUnreviewed
3 people since the beginning · 3 threads
125
Hard to guess the command when you know the goalUnreviewed
3 people since the beginning · 3 threads
126
Command silently discards uncommitted changes irrecoverablyUnreviewed
3 people since the beginning · 3 threads
127
Usability so poor that people give up on their dataUnreviewed
3 people since the beginning · 3 threads
128
Hard to track which branch and remote are in use across machinesUnreviewed
3 people since the beginning · 3 threads
129
Footguns must be navigated every time a user does anythingUnreviewed
3 people since the beginning · 3 threads
130
Squash, merge and rebase commands are hard to tell apartUnreviewed
3 people since the beginning · 3 threads
131
Context-sensitive commands are hard to predict and use correctlyUnreviewed
3 people since the beginning · 3 threads
132
Staged-changes flag is buried in docs and has inconsistent namesUnreviewed
3 people since the beginning · 3 threads
133
No obvious way to blame or view a specific file's history by clickingUnreviewed
3 people since the beginning · 3 threads
134
Accidentally unreachable commits take googling and trial to recoverUnreviewed
3 people since the beginning · 3 threads
135
Hard reset discards uncommitted changes with no backupUnreviewed
3 people since the beginning · 3 threads
136
Leaky abstraction forces use of plumbing commandsUnreviewed
3 people since the beginning · 3 threads
137
Branches break too often, so users avoid themUnreviewed
3 people since the beginning · 3 threads
138
Unusual operations can leave the repository unrecoverableUnreviewed
3 people since the beginning · 3 threads
139
Low-level primitives are too hard to use, forcing workaroundsUnreviewed
3 people since the beginning · 3 threads
140
Partial checkouts are awkward to useUnreviewed
3 people since the beginning · 3 threads
141
New users land in unexpected rebase states and can't tell what happenedUnreviewed
3 people since the beginning · 3 threads
142
Confusing defaults must be learned through trial and errorUnreviewed
3 people since the beginning · 3 threads
143
GUIs leave users stuck and frustrated when things break in edge casesUnreviewed
3 people since the beginning · 3 threads
144
Docs don't distinguish when snapshot and diff models applyUnreviewed
3 people since the beginning · 3 threads

Every issue, all time, most people first

Moderately complex commands are hard to remember and discoverUnreviewed
95 people since 2008, in 19 different years · 4 this year
20082026
- Commands are hard to remember and need a cheatsheet beyond basic use2026-05-18
- Overwhelming number of commands and options, hard to learn and remember2026-01-12
- Users must look up commands and syntax, can't remember them all, and it is error-prone2025-12-30
Something wrong here?
Dozens of obscure options make the commands confusingUnreviewed
78 people since 2009, in 18 different years · 1 this year
20082026
- Command line syntax is overly confusing and opaque to users2026-02-25
- Inconsistent commands make it hard to work out how to solve problems2025-02-04
- Confusing jargon and inconsistent commands; users can't tell why some commands work and others don't2024-01-10
Something wrong here?
Creating a branch doesn't switch to it, and checkout -b isn't foundUnreviewed
53 people since 2010, in 16 different years · 2 this year
20082026
- Checkout does both branch switching and discarding changes, which is confusing2026-04-08
- Branch create and delete commands are inconsistent and hard to remember2026-02-27
- Useful branch output requires extra flags, and commands give cryptic errors and hidden options2025-01-18
Something wrong here?
Merges produce unwanted conflicts that must be manually undoneUnreviewed
51 people since 2010, in 16 different years · 4 this year
20082026
- Forces you to stop everything and resolve merge conflicts immediately, and rebase conflicts one by one2026-05-25
- Requires understanding internal data structures; people can't explain rebase versus merge2026-05-17
- Merge feels unpleasant and makes tracking changes hard2026-03-04
Something wrong here?
Reset and checkout do too much, making them confusingUnreviewed
48 people since 2011, in 13 different years · 5 this year
20082026
- Checkout command has overlapping modes that can silently discard uncommitted changes2026-07-14
- Reset and checkout commands do too much, making them confusing2026-07-14
- Commands like checkout and reset do many different things, some destructive, making them hard to use2026-04-22
Something wrong here?
Needless complexity requires extensive reading and practiceUnreviewed
41 people since 2009, in 15 different years · 4 this year
20082026
- Unfriendly interface that is hard for people to use2026-07-29
- Interface is inconsistent, causing repeated frustration even after years of use2026-05-17
- Interface is arcane and hard to learn; every aspect feels bespoke2026-04-10
Something wrong here?
Editing an older commit needs many error-prone manual rebase stepsUnreviewed
39 people since 2010, in 15 different years · 4 this year
20082026
- Moving a commit and its descendants to a new parent is unintuitive to invoke2026-05-17
- Editing a past commit message was complicated until a recent release2026-04-28
- Amending a commit a few parents back takes about five manual steps2025-12-07
Something wrong here?
Basic tasks need deep knowledge of internalsUnreviewed
32 people since 2008, in 16 different years · 1 this year
20082026
- Too many details and edge cases, so the person forgets how it works soon after learning2026-05-18
- Very difficult to learn, so people are forced to struggle with it2025-10-26
- Too much unnecessary complexity; people learn only enough to get by2025-10-26
Something wrong here?
Checkout does different things, making Git inconsistent to learnUnreviewed
30 people since 2010, in 14 different years · 2 this year
20082026
- Commands are unintuitive, e.g. 'git checkout -- foo.txt' confuses people, so they fumble around2026-04-22
- Git checkout -- file is unintuitive and its restore replacement is unclear2026-04-22
- Git checkout does five or more unrelated things, making the CLI confusing2025-04-10
Something wrong here?
Rebase is tricky to get right and recovering from mistakes wastes timeUnreviewed
29 people since 2013, in 11 different years · 3 this year
20082026
- Interactive rebase commands can leave the working tree half-broken, causing fear2026-07-14
- Rebase requires memorizing command line options and building a mental model2026-07-14
- Hard to keep track of what powerful commands like rebase are doing2025-11-11
Something wrong here?
Inconsistent flags and command names make commands hard to rememberUnreviewed
29 people since 2012, in 11 different years · 1 this year
20082026
- Millions of people confused, hunting for correct commands among poorly named flags2026-04-22
- Too many commands and flags, and docs don't help users understand them2024-07-06
- CLI is full of footguns, inconsistent flags, and can silently delete commits2024-02-23
Something wrong here?
History is hard to navigate and discoverUnreviewed
25 people since 2010, in 15 different years · 7 this year
20082026
- Git history is hard to navigate and review history is lost after merging PRs2026-09-22
- Merge-heavy history makes git log output a screenful of pipes, hard to read2026-07-14
- Git is poor at interactive history browsing and forces people into an unfamiliar environment2026-04-28
Something wrong here?
Must constantly google how to do thingsUnreviewed
25 people since 2008, in 13 different years · 4 this year
20082026
- When something goes wrong, the user can't work out how to fix it and must search for magic commands2026-09-02
- GUIs are more confusing than typing commands and don't match the user's workflow2026-07-10
- Commands are semantically incoherent, so users must look up workflows every time2026-04-08
Something wrong here?
Reverting a file with checkout silently discards changesUnreviewed
24 people since 2010, in 13 different years · 1 this year
20082026
- Git loses track of moved and edited binary assets, showing them as deleted and recreated2026-08-20
- Manual doesn't say when git add's default behaviour for deleted files changed2024-05-29
- Overloaded checkout command is confusing, so restore and switch were added2023-12-11
Something wrong here?
Same merge conflicts reappear on every rebase of an old branchUnreviewed
21 people since 2012, in 12 different years · 1 this year
20082026
- Same conflict reappears on each commit, so earlier resolutions seem lost2026-07-27
- Branch is unusable until merge conflicts are fully resolved2025-08-31
- Long-lived branches touching same files force repeated manual conflict resolution, even rerere doesn't help2025-05-26
Something wrong here?
Easy to get stuck in bad repo statesUnreviewed
19 people since 2012, in 12 different years · none this year
20082026
- Easy to get into repo states the user cannot figure out how to recover from2025-02-12
- Repo stays in bisect state, easy to run wrong command or get confused2024-11-28
- Beginners break their repo and must re-clone instead of recovering2024-02-01
Something wrong here?
Rebasing produces conflicts that are harder to resolveUnreviewed
18 people since 2014, in 10 different years · 1 this year
20082026
- Rebasing and resolving conflicts in git is a painful, costly process2026-01-13
- Git's UI is bad, forcing users to learn workarounds for rebasing and conflicts2025-10-13
- Rebasing a stack of branches requires many manual steps and branch pointer resets2025-07-21
Something wrong here?
Reflog shows only hashes and messages, making commits hard to findUnreviewed
17 people since 2009, in 13 different years · 1 this year
20082026
- Reflog format is confusing, so recovering from rebase mistakes is hard2026-01-13
- Reflog is considered very confusing and complicated to understand2025-01-16
- Reflog feature is hidden internals people don't understand, poor UI discoverability2024-02-03
Something wrong here?
Finding how to do tasks is confusing for new developersUnreviewed
16 people since 2012, in 11 different years · none this year
20082026
- Hard to discover available commands and options, unclear what state is changing2025-05-30
- Too low-level, making simple everyday tasks hard to do2024-04-06
- Developers constantly need to search online to figure out how to do basic tasks2023-10-08
Something wrong here?
Cherry-picking between branches causes painful later conflictsUnreviewed
16 people since 2012, in 10 different years · 2 this year
20082026
- Branch and detached HEAD states look identical but change how commits behave, so people lose work2026-04-14
- Branches behave as moving tags, so it's hard to trace where commits came from2026-04-14
- Novices fail to notice which branch is checked out, then panic when commits seem to vanish2026-04-14
Something wrong here?
Error messages are cryptic, leaving users unable to see what went wrongUnreviewed
15 people since 2010, in 9 different years · 1 this year
20082026
- CLI error messages are obscure and assume expertise, not friendly to users2026-04-24
- Help text recommends a command the docs say is not ready for use2021-04-13
- Easy to make mistakes, and error messages are confusing and hard to decipher2019-05-24
Something wrong here?
Commands like git diff --cached must be memorised by heartUnreviewed
14 people since 2008, in 10 different years · none this year
20082026
- Reviewing git activity and tracking changes over time in the terminal is unproductive and tedious2022-10-15
- Hard to reliably tell which changes a branch contains; git log hard to parse2022-06-10
- Git revision syntax is terrible and git diff behaves differently than it looks2022-01-19
Something wrong here?
Basic operations are easy to mess up, and rebase is frustratingUnreviewed
14 people since 2010, in 9 different years · 1 this year
20082026
- Basic git operations are hard, easy to mess up, and rebase is frustrating2026-01-13
- Git's merge model is confusing, so juniors mess up rebases and force-push2025-09-22
- Git leaves the repository stuck mid-rebase, so you can't safely switch to other work2025-09-01
Something wrong here?
Switching branches requires stashing, and the stash stack is hard to trackUnreviewed
13 people since 2013, in 6 different years · none this year
20082026
- Switching branches needs stashing, and the stash stack becomes hard to track2025-07-22
- Switching between parallel branches requires tedious stashing and cherry-picking, and conflicts stop work2025-02-12
- Switching tasks in Git needs fiddly stashes and remembering which branch each stash is for2025-02-04
Something wrong here?
Submodules are easy to trip over, such as forgetting --recursive when cloningUnreviewed
12 people since 2012, in 9 different years · none this year
20082026
- Confusing hidden state, not cloned by default, and unhelpful diffs for submodule changes2024-12-02
- Confusing: unclear what submodule init does, and submodule storage and switching behave unintuitively2023-08-08
- Users must remember extra submodule commands after every clone, pull or checkout2023-04-26
Something wrong here?
Push fails on other branches and pull does not fix itUnreviewed
12 people since 2011, in 9 different years · none this year
20082026
- Must repeat a manual push-with-branch-name dance each time because git push can't be configured to do it2023-11-23
- Branch tracking behaviour makes git pull too counter-intuitive to understand or explain2023-08-08
- Git push --tags is all-or-none, so pushing single tags is inconvenient and risks accidental pushes2023-01-23
Something wrong here?
Same operations need obscure flags and multi-step incantationsUnreviewed
12 people since 2014, in 8 different years · 1 this year
20082026
- Confusing, multipurpose commands based on inner workings make bad states hard to recover from2026-05-18
- Commands map unintuitively onto the operations they actually perform2021-06-21
- Commands are unclear about which state levels they operate on, confusing people2021-06-21
Something wrong here?
Common tasks take several commands, with obscure arguments for fewerUnreviewed
12 people since 2010, in 7 different years · none this year
20082026
- Uncommon tasks require wasting time searching docs; command naming is unintuitive2021-09-02
- Simple tasks need two commands instead of one, due to a poor model2021-04-28
- Inconsistent commands make rarely used tasks need the manual every time2020-11-17
Something wrong here?
Git LFS is so clunky the team had to build a workaroundUnreviewed
12 people since 2018, in 6 different years · 3 this year
20082026
- Silently does the wrong thing unless users actively set up git-lfs2026-06-22
- Git LFS felt unworkably clunky, so the team had to build a workaround2026-06-17
- Git with LFS causes constant problems when used with Unity and Unreal2026-06-17
Something wrong here?
Names like pull, checkout and rebase are vague for new usersUnreviewed
11 people since 2010, in 9 different years · none this year
20082026
- Command names like checkout and add are counter-intuitive for what they actually do2023-03-31
- Command names like blame and cherry-pick are confusing to understand2023-01-04
- Command names like commit, rebase and merge are unintuitive, so users struggle to know what to run2022-01-01
Something wrong here?
Must repeatedly split and skip hunks to stage the right changesUnreviewed
11 people since 2013, in 7 different years · none this year
20082026
- Staging works one hunk at a time, which is painful to use compared to selecting lines2024-04-08
- Hunk-by-hunk prompts lack context and can't split hunks, forcing a raw diff editor2024-02-17
- Hard to stage individual lines in hunks that can't be automatically split2022-03-20
Something wrong here?
Pull-before-push sequence is unclear, merging in others' work unintentionallyUnreviewed
11 people since 2011, in 6 different years · none this year
20082026
- Defaults push people into merge pulls and large commits, so developers don't understand rebase2023-08-05
- Git pull creates unwanted merge commits by default instead of rebasing2021-08-13
- Pushing without pulling first forces a merge commit, and undoing that mistake is painful2021-06-21
Something wrong here?
Worktrees are hard to manage, with conflicts and confusing branchingUnreviewed
11 people since 2022, in 5 different years · 5 this year
20082026
- Worktrees cannot share the same branch, so only one can use master2026-08-24
- Worktrees are annoying to manage: branch-name workarounds, many directories to track, stale ones needing prune2026-07-30
- Worktrees are hard to manage, with conflicts and confusing branching2026-06-22
Something wrong here?
Staging area causes surprises that users don't expectUnreviewed
10 people since 2011, in 9 different years · 3 this year
20082026
- Staging a few non-adjacent lines in a single file via git's interactive mode is really painful2026-06-22
- Even experienced users find interactive git staging complicated and prefer IntelliJ2025-12-24
- Confusing staging-related flag names and output make Git needlessly hard to learn2025-12-09
Something wrong here?
Git branches differ from what other software calls branchesUnreviewed
10 people since 2012, in 8 different years · 2 this year
20082026
- Git's branch naming is confusing because a branch is really just a pointer2026-05-18
- Unexplained switch to multiple default branch names confuses new engineers creating repos2026-02-21
- Branch names like origin/foo are confusing and remote branches are misleadingly named2024-07-13
Something wrong here?
Hard to tell how far back in the reflog to undo a rebaseUnreviewed
10 people since 2016, in 8 different years · 1 this year
20082026
- Can't find how to undo a long, bad rebase, so the repo must be nuked2026-01-13
- Undoing a git rebase that updates many branches is not easy2025-02-05
- Easy to mess up rebase, leaving repo needing deletion and re-clone2023-01-23
Something wrong here?
Cloning a repo with many binaries takes days, so folders get copied manuallyUnreviewed
10 people since 2011, in 7 different years · none this year
20082026
- Old repos reference remotes that no longer exist, leaving incomplete clones2023-03-03
- Cloning a monorepo takes 5+ minutes even shallow and with LFS, no good subset checkout2021-11-15
- Rebasing is slow in monorepos with many changing files2021-10-17
Something wrong here?
Add-then-commit staging confuses learners and persists into rebaseUnreviewed
10 people since 2009, in 7 different years · none this year
20082026
- Junior developers get lost when the staging area and index are introduced2022-10-10
- Index staging with add then commit confuses learners and persists into rebase and cherry-pick2022-07-05
- Forced staging index confuses new users between changing a file and committing it2022-02-19
Something wrong here?
Undo isn't straightforward among inconsistent commandsUnreviewed
10 people since 2013, in 6 different years · none this year
20082026
- Lacks easy undo, feedback, consistency, and discoverability in commands2023-06-03
- Inconsistent, confusing commands; common tasks like undo aren't straightforward2023-04-26
- Undoing mistakes is hard because the commands are cryptic and there are many options2022-07-24
Something wrong here?
Merge commits clutter the log with noisy entriesUnreviewed
9 people since 2018, in 7 different years · 2 this year
20082026
- Git can't tell a branch was merged after its commits were rewritten2026-08-18
- Commands show nothing for merge commits, so people can't find changes on side branches2026-01-13
- Merge commits wrongly credit the merger as author of merged lines, hurting debugging2024-07-03
Something wrong here?
Merge conflicts push users into random actions that break reposUnreviewed
9 people since 2016, in 5 different years · none this year
20082026
- Gets merge conflicts on single-user projects and has to delete the repo to escape them2024-01-06
- Beginners get lost recovering from merge conflicts or rejected pushes, making their repository worse2023-11-25
- Merge conflicts are frustrating to resolve, pushing users into random actions that break repos2023-09-15
Something wrong here?
Must learn it deeply just to use it at allUnreviewed
8 people since 2009, in 7 different years · none this year
20082026
- Steep initial learning curve; people get frustrated not knowing how to fix messes2023-03-30
- Steep learning curve means people must learn it deeply to use it at all2022-01-18
- Steep learning curve, sharp edges can cause permanent loss of work2020-06-11
Something wrong here?
Recovering from mistakes takes disproportionate effort for little valueUnreviewed
8 people since 2011, in 6 different years · none this year
20082026
- Doing things is harder and mistakes are easier to make and harder to recover from2025-10-31
- Hard to learn and recover from mistakes; requires disproportionate effort for little value2024-07-13
- Hard to know where to start and hard to recover from mistakes2022-09-01
Something wrong here?
Workflow exposes implementation, hard for non-developers to useUnreviewed
8 people since 2009, in 6 different years · none this year
20082026
- Simple workflows break down; the tool is legendarily complicated and difficult to use2024-10-20
- Developer gave up on it due to complexity and poor workflow2024-01-28
- Very complicated workflow too close to its implementation, hard for non-developers2020-08-28
Something wrong here?
Hard to remember which command discards file changesUnreviewed
8 people since 2012, in 6 different years · 1 this year
20082026
- Reverting one file while keeping other changes requires many obscure steps and memorized incantations2026-07-19
- Throwing away changes and ignoring files is cumbersome; stateful ignore process requires manual untracking2021-04-27
- Inconsistent commands for discarding file changes, hard to remember which to use2019-05-14
Something wrong here?
No easy way to split a commit with unrelated changesUnreviewed
8 people since 2012, in 6 different years · 1 this year
20082026
- Splitting a commit requires an obscure rebase-edit sequence most users wouldn't guess2026-08-18
- Can squash commits but can't pull hunks out to split or move them2024-02-13
- Splitting a commit takes many commands and is easy to mess up2024-02-03
Something wrong here?
Staging area is called index, cache and staging, causing confusionUnreviewed
8 people since 2013, in 6 different years · none this year
20082026
- Uses internal jargon like staging and index, and its CLI is huge and byzantine2024-01-09
- Confusing names like index and reset; reset docs are hard to understand2022-06-25
- Reset juggles several concepts at once (HEAD, index, working tree), making it hard to understand2021-10-22
Something wrong here?
Deleting a remote branch is confusing for usersUnreviewed
7 people since 2010, in 7 different years · none this year
20082026
- Cannot version-control branch deletions or recover deleted branches cleanly2024-07-02
- Git makes it hard to delete a version after secrets were committed2024-05-10
- Git commands can silently delete uncommitted work without any confirmation or warning2021-06-22
Something wrong here?
So many how-to guides are needed to use itUnreviewed
7 people since 2008, in 7 different years · none this year
20082026
- Users must spend tens of hours learning internals to use it2023-06-18
- Needs a cheat-sheet or must be put up with, hard to learn2021-11-25
- Hard to learn; users must consult the manual even once2019-11-01
Something wrong here?
Switching branches silently deletes uncommitted changesUnreviewed
7 people since 2009, in 7 different years · 1 this year
20082026
- Cannot cleanly separate simultaneous changes into multiple dependent branches2026-05-16
- Switching branches with staged or uncommitted changes requires care2021-04-27
- CLI is fragile, so a wrong switch can destroy changes on another branch2020-08-16
Something wrong here?
Poorly chosen defaults make mistakes easy to makeUnreviewed
7 people since 2010, in 7 different years · none this year
20082026
- Default settings are bad, leading users to do the wrong things2025-02-05
- Lacks a consistent UI, and defaults copy the original awful UX, so users must configure it2024-07-29
- Useful settings exist but aren't defaults, making first-time use harder2020-11-17
Something wrong here?
Needs many explanatory articles to understandUnreviewed
7 people since 2012, in 6 different years · none this year
20082026
- Tutorials' backwards-pointing arrow diagrams are unintuitive and make Git seem more mystical2021-07-04
- Jargon for the same concept and help text leaves users less sure what commands do2021-06-21
- Documentation for advanced commands is too full of jargon to understand2020-09-04
Something wrong here?
Easy to enter detached HEAD state and hard to recover fromUnreviewed
7 people since 2015, in 6 different years · 1 this year
20082026
- Detached HEAD state is hard to tell apart from named branches in the prompt2026-04-15
- IDEs let users easily enter detached HEAD state with no help recovering2025-02-05
- Easy to mistakenly enter detached HEAD state and hard to recover from2025-01-17
Something wrong here?
Merging heavy branches is painful to learnUnreviewed
7 people since 2010, in 6 different years · 2 this year
20082026
- Confusing mix of branch and path syntax trips up newcomers to git2026-07-23
- Juggling several work-in-progress branches in a Git working copy becomes complex and tedious2026-04-12
- Git's branching model causes confusing conflicts and errors that are easy to screw up2024-01-22
Something wrong here?
Ours and theirs meanings flip between rebase and mergeUnreviewed
7 people since 2020, in 5 different years · 2 this year
20082026
- Confusing merge conflict interface and 'ours vs theirs' naming make conflicts hard to understand2026-03-22
- Ours/theirs terms confuse newcomers and mean different things across tools2026-01-13
- "Yours" and "Theirs" labels mean opposite things in different contexts, confusing users2024-02-13
Something wrong here?
Too many features make it hard to work out proper usageUnreviewed
7 people since 2016, in 5 different years · 1 this year
20082026
- Many powerful features are difficult to use and not intuitive2026-04-15
- Too many features; users only need a small subset, so it feels complex2024-04-05
- New UI is harder to use; colleagues struggle to find hidden features2024-03-29
Something wrong here?
Push rejection messages are cryptic and give no next stepUnreviewed
7 people since 2008, in 5 different years · none this year
20082026
- Push rejection error is confusing to users, per the quoted example2024-07-06
- GUI gave a wrong error message for a rejected push2021-06-10
- Push fails with a long, semi-helpful error message that is hard to act on2016-05-10
Something wrong here?
Repository state is hidden unless users run commands, so changes get missedUnreviewed
6 people since 2015, in 6 different years · none this year
20082026
- Git's mental model is too complex and terminal use gives no view of repository state2025-07-22
- Users must actively run commands to see repository state, so it's easy to miss2024-01-08
- Terminal commands force users to hold a mental model of repository state2023-06-17
Something wrong here?
Shallow clones break git log and blame, sparse checkouts need the full repoUnreviewed
6 people since 2008, in 6 different years · none this year
20082026
- Large binaries make cloning and pulling very painful, and git log -S crashes on them2025-06-12
- Clones of large repos fail, pushes randomly fail, and pulls create unexpected conflicting branches2020-11-17
- Partial checkouts of large repositories are hard to do in Git, unlike Subversion and Perforce2019-04-24
Something wrong here?
Must read multiple man pages to find needed informationUnreviewed
6 people since 2010, in 6 different years · none this year
20082026
- Must search or read multiple man pages to find needed information2021-04-06
- Man pages are badly written, so fixing problems means lots of searching2018-04-11
- Most users must consult man pages or Stack Overflow to perform common actions2017-03-31
Something wrong here?
Overloaded concepts and terms cause unexpected behaviorUnreviewed
6 people since 2016, in 5 different years · none this year
20082026
- Interface is too hard for beginners, and undo unexpectedly discards index and local changes2021-06-21
- Inconsistent, patternless interface with confusing terms like index, reset and revert2020-08-16
- Interface is abysmal, uses multiple terms for same concepts2019-11-20
Something wrong here?
Mail clients are hard to configure for git-over-emailUnreviewed
6 people since 2017, in 5 different years · 1 this year
20082026
- Mail clients are hard to configure correctly for git-over-email, so it is user-unfriendly to set up2026-04-29
- Setting up git send-email to work with modern mail servers is confusing and variable2025-08-17
- Setting up email credentials for git-send-email takes obscure steps and careful configuration2025-03-06
Something wrong here?
Recovering from a mistake or undoing it becomes complicated and dangerousUnreviewed
6 people since 2015, in 5 different years · none this year
20082026
- Easy to use until a mistake, then recovering or undoing it becomes complicated and dangerous2025-10-30
- Easy to make irreversible mistakes and hard to undo them2020-11-17
- Non-intuitive to use, making it easy to accidentally delete work2017-08-18
Something wrong here?
Command-line inconsistency forces users to think in commitsUnreviewed
6 people since 2017, in 4 different years · none this year
20082026
- Commands don't make sense and lead users to misunderstand commits as changes2023-06-17
- Stacked commits are painful in git, requiring custom shell scripts to make simple2022-11-16
- Command interface is unintuitive, exposing internal commit graph representation to users2022-08-06
Something wrong here?
Easy to forget new untracked files, so they're left out of commitsUnreviewed
6 people since 2018, in 4 different years · 1 this year
20082026
- Easy to forget new untracked files, so they get left out of commits2025-12-14
- Completely removing a committed file requires rewriting history with obscure, hard tools2025-04-24
- Cluttered output makes it easy to forget files needed for commits2023-08-01
Something wrong here?
Manual committing means people forget to commit their changesUnreviewed
6 people since 2014, in 4 different years · 1 this year
20082026
- The commit step's wording confuses people about what committing means2026-04-22
- Requires manual committing, so people forget to commit changes2022-11-22
- Commit signing is so hard to set up correctly that people struggle to recommend it2021-06-21
Something wrong here?
Confusion comes from underlying concepts, not verb names like pushUnreviewed
6 people since 2012, in 4 different years · none this year
20082026
- Git's opaque terms like push, pull, commit, and origin were not intuitive to learn2021-07-04
- Man page description of git push is unintelligible to newcomers, using undefined jargon like refs2021-04-08
- Hides Git terminology, so users must learn how Git concepts map onto the UI's own terms2015-03-04
Something wrong here?
Each command does many things, so finding one means long help pagesUnreviewed
5 people since 2010, in 5 different years · none this year
20082026
- Users must read docs for simple tasks and guess what commands will do2024-01-12
- Needs a long book to learn which commands to run next2017-12-18
- Simple tasks are hard; must read pages of docs to choose right command2014-08-02
Something wrong here?
Stash stack loses entries on pop and can't pop with uncommitted changesUnreviewed
5 people since 2011, in 5 different years · none this year
20082026
- Stash pop fails confusingly and suggested restore --staged seems to wipe local changes2025-03-02
- Stashes form a numbered stack; only the top one can be popped, and popping deletes it, risking data loss2022-11-16
- Stash is a stack, so popping loses entries and can't pop with uncommitted changes2018-11-23
Something wrong here?
Commits hidden by a rebase are hard to findUnreviewed
5 people since 2014, in 5 different years · none this year
20082026
- Hard to find commits hidden before a rebase2025-06-22
- Can't tell real commits from unrebased throwaway commits in history2024-09-11
- Original commits are hidden behind a link to an external web page after squashing2021-08-08
Something wrong here?
Long commit messages wrap badly in the terminalUnreviewed
5 people since 2011, in 5 different years · none this year
20082026
- Tools show only the first line, so long commit messages are almost never seen2024-02-01
- Small commit message fields make long messages feel like wrong tool usage2022-08-02
- Generates verbose, ugly commit messages made of JSON2015-02-20
Something wrong here?
Email-based patch submission is hard for contributors to useUnreviewed
5 people since 2016, in 5 different years · none this year
20082026
- Email-based patch submission is archaic and hard for contributors to use2025-03-06
- Email-based patch workflow feels worse than GitHub's pull requests for handling changes2023-07-18
- Emailing patches via git send-email is more hassle than centralized pull requests2022-07-25
Something wrong here?
Docs don't help with real-world mistakes, conflicts or undoing errorsUnreviewed
5 people since 2019, in 4 different years · none this year
20082026
- Docs don't help with real-world mistakes, conflicts, or undoing errors2023-11-23
- Users without a mental model fix mistakes by awkward trial and error2021-06-14
- Constantly consulting docs and undoing minor mistakes because the UI is ad hoc2020-12-17
Something wrong here?
Setting up a central repo across many projects is time-consumingUnreviewed
5 people since 2017, in 4 different years · none this year
20082026
- No easy out-of-the-box way for repos on dev machines to find each other2022-02-20
- Game devs can't fetch just part of a repo, forcing awkward subtree and submodule setups2020-11-09
- Hard to preconfigure repo settings like submodules and merge drivers for non-technical users2020-07-27
Something wrong here?
Merge conflicts, lost changes and reset cause trouble for usersUnreviewed
5 people since 2015, in 4 different years · none this year
20082026
- Git can't rebase history containing merge commits, so the user restarts from scratch2025-08-31
- Git's API is user unfriendly; merge conflicts, lost changes and git reset cause trouble2025-02-13
- Git doesn't track renames, so merges and logs produce false conflicts2023-11-03
Something wrong here?
Stashing and untangling work-in-progress commits becomes tediousUnreviewed
5 people since 2016, in 4 different years · none this year
20082026
- Stashing, switching, pulling and untangling WIP commits becomes tedious and gets old fast2025-02-12
- Stash is not robust enough, so users resort to WIP commits to avoid losing work2022-07-22
- Bisect workflow would become unusable with every WIP commit recorded2021-07-05
Something wrong here?
Pull error message is unhelpful, so diverged branches get misdiagnosedUnreviewed
5 people since 2013, in 4 different years · none this year
20082026
- Confusing 'divergent branches' error on pull with no clear next step2025-03-03
- Easy to mistype or forget to specify a branch, risking unintended force pushes2024-04-30
- Error message after a pull is unhelpful, so people misdiagnose diverged branches2024-04-13
Something wrong here?
Merging UI pushes people toward a single mergerUnreviewed
5 people since 2014, in 4 different years · 1 this year
20082026
- Merges are painful because of poor native user experience design2026-03-22
- Distributed merge-centric design confuses newcomers using a centralized workflow2016-12-27
- Obvious merge UI element is misleading; people are told to use other workflows instead2015-02-15
Something wrong here?
Undoing an undo is counterintuitive and multi-step undo needs the reflogUnreviewed
5 people since 2016, in 4 different years · none this year
20082026
- Hard to undo committed mistakes in shared history2024-03-04
- Undo requires manipulating HEAD and reflog; stashes are needlessly complex concepts2023-01-08
- Lacks an undo, so mistakes are hard to reverse2022-11-16
Something wrong here?
Conflict output lacks base context, forcing lookups of each side's changesUnreviewed
4 people since 2010, in 4 different years · 1 this year
20082026
- Presenting conflict choices as options confuses newcomers, who blindly pick the familiar side2026-01-13
- Default conflict output lacks base context, so people can't resolve conflicts without looking up each side's changes2024-02-17
- Conflicts are discovered only after files are already changed, with no easy way back2023-10-07
Something wrong here?
Easy to reach states where users don't know how to recoverUnreviewed
4 people since 2013, in 4 different years · none this year
20082026
- Gets into bad states that are unclear, with no way to tell what went wrong or how to recover2025-02-05
- Easy to get into states where user doesn't know how to recover2016-10-03
- Beginners get into unrecoverable states when things go wrong, harder to escape than in SVN2014-02-19
Something wrong here?
Previewing pulls and undoing a bad pull is counter-intuitiveUnreviewed
4 people since 2010, in 4 different years · 1 this year
20082026
- Line-based diffs cause merge conflicts and make pull requests hard to read2026-03-17
- Each pull retrieves changes for the whole codebase, including unrelated files2023-08-14
- Contributors struggle to learn how to fix conflicts in their pull requests2021-04-08
Something wrong here?
Viewing file history or undeleting a file needs convoluted commandsUnreviewed
4 people since 2015, in 4 different years · none this year
20082026
- Too many different incantations to delete a file, hard to learn and remember2021-03-07
- Has to keep looking up commands and subflags for routine tasks like checking out old files2020-01-07
- Basic tasks like viewing file history or undeleting a file need convoluted commands2016-12-14
Something wrong here?
Command line hides which branches and commits exist, requiring memorized commandsUnreviewed
4 people since 2013, in 4 different years · none this year
20082026
- Users must memorize commands, and the command line hides which branches and commits exist2022-06-25
- Can't remember the commands to diff a branch or a single commit, must Google each time2019-11-01
- Users must memorize shell commands and delete projects when errors occur2017-08-18
Something wrong here?
Setting up SSH keys is painful for non-technical usersUnreviewed
4 people since 2008, in 4 different years · none this year
20082026
- Newcomers struggle to learn terminal, Git, and ssh-keygen key management, adding friction2021-08-12
- Students struggle to push using SSH and keys without prior experience2015-06-11
- Setting up SSH keys is arcane and unintuitive for Windows-only users2012-05-21
Something wrong here?
Aliasing a builtin silently causes confusing behavior, with no warningUnreviewed
4 people since 2013, in 4 different years · none this year
20082026
- Commands are so ad hoc that users must rely on personal aliases to operate it2023-02-28
- Too much command line syntax to look up and alias2018-08-05
- Can't set default flags on aliases, so must create awkward workaround commands2016-09-30
Something wrong here?
Pull and fetch names mean different things despite seeming similarUnreviewed
4 people since 2012, in 4 different years · none this year
20082026
- Terminology like 'Pull Request' is backwards from other version control systems, confusing2024-05-27
- Command names like fetch, pull and clean -nx are confusing and frustrating2023-01-08
- Distinction between pull and fetch was confusing when first learning2020-11-17
Something wrong here?
Hard to remember many commands and find commit hashes in logsUnreviewed
4 people since 2012, in 4 different years · none this year
20082026
- Hard to remember many git commands and find commit hashes in logs2016-11-11
- Checking out a specific commit takes hours of research due to countless command variations2015-05-10
- Hard to select commits matching complex conditions with git's command line options2014-10-26
Something wrong here?
Newer features are ugly and need extra manual config setupUnreviewed
4 people since 2014, in 4 different years · 1 this year
20082026
- Installing Git means wading through many confusing alternate configurations and packages2026-03-24
- Newer Git features are ugly to use and need extra manual config setup2021-08-17
- Hard to set up shared git config settings for a distributed team2020-07-27
Something wrong here?
Rebase conflicts that go wrong force restarting the workUnreviewed
4 people since 2023, in 4 different years · 1 this year
20082026
- Rebasing halts on conflicts, so you can't resolve them separately from the rebase2026-09-04
- Rebase conflicts force stopping work and restarting if resolution goes wrong2025-07-22
- Rerere is undiscoverable, and rebasing forces repeated conflict resolution and clashes with shared-history rules2024-09-16
Something wrong here?
People copy-paste commands they don't understandUnreviewed
4 people since 2012, in 4 different years · none this year
20082026
- Poorly designed interface makes people copy-paste commands they don't understand2025-06-05
- Unusual commands are hard to remember, so users copy snippets from Stack Overflow2023-08-08
- People get completely lost when something goes wrong and can only copy-paste fixes2017-12-18
Something wrong here?
Git output is inconsistent to parse and its format options are underdocumentedUnreviewed
4 people since 2009, in 4 different years · none this year
20082026
- Git works poorly with binary and non-text files, forcing awkward tooling workarounds2023-07-19
- Typing nested file paths to git add is slower than copy-pasting from git status output2016-07-23
- Parsing git's output is inconsistent and its format options are underdocumented2014-03-07
Something wrong here?
Experts still mess up many footguns on hard tasksUnreviewed
4 people since 2019, in 4 different years · none this year
20082026
- Makes even basic things difficult and lets experts easily make destructive mistakes2025-02-05
- Makes it easy to do the wrong thing and hard to do the right one2024-01-02
- Makes nearly every common task a pain to do2023-01-08
Something wrong here?
Rebase parameters and the --onto flag are confusingUnreviewed
4 people since 2016, in 4 different years · 1 this year
20082026
- The rebase --onto invocation is extremely unintuitive to use2026-05-18
- Rebase parameters and the --onto flag are confusing to use2023-12-11
- The --onto rebase command for stacked branches is confusing to get right2021-11-17
Something wrong here?
Applying one stashed file requires checkout, which is unintuitiveUnreviewed
4 people since 2016, in 3 different years · none this year
20082026
- Staging area and stash behave inconsistently with commits, requiring extra special commands2025-02-05
- Creating a branch via checkout and odd stash pop staging behaviour confuse users2023-06-05
- Command syntax is unintuitive and inconsistent across similar operations, like deleting branches and stashes2023-02-28
Something wrong here?
Size warning on small screens forces zooming out until text is unreadableUnreviewed
4 people since 2013, in 3 different years · none this year
20082026
- Text too small on high-res display; zooming enlarges text but shrinks margins2025-07-16
- Zooming on mobile makes a left rectangle expand and cover the screen2016-02-05
- Text is annoying to read on iPad, requires zooming in2013-04-08
Something wrong here?
History-editing commands are hard for beginners to useUnreviewed
4 people since 2018, in 3 different years · none this year
20082026
- Commands have convoluted options, so even small history edits take many obnoxious commands2022-11-10
- Hard for new users; requires learning a small language to manage history2022-09-03
- History-editing commands are hard for beginners and the UI is occasionally poor2019-05-10
Something wrong here?
Non-developers can't undo things partially outside linear commitsUnreviewed
4 people since 2014, in 3 different years · none this year
20082026
- Visual git clients corrupted repositories and leave users unable to do anything beyond basic commits2021-08-01
- Non-developers struggle badly to undo things partially, and version control becomes painful beyond linear commits2017-12-12
- Automatic commits and syncing could accidentally push junk files to everyone on the project2017-03-30
Something wrong here?
Poorly named commands often do the wrong thingUnreviewed
4 people since 2013, in 3 different years · none this year
20082026
- Users get lost when something goes wrong outside basic commands, so they re-clone2023-08-07
- Commands are poorly named and often do the wrong thing, confusing new users2019-11-01
- Users lose work through confusing commands, with frequent incidents of lost changes2019-05-14
Something wrong here?
Behavior is unpredictable, so users memorise commands by roteUnreviewed
4 people since 2012, in 3 different years · none this year
20082026
- Hard to understand; users must memorize commands and keep syncing by rote2021-11-06
- Inconsistent interface with context-dependent behavior that requires rote memorization2016-09-09
- Interface is inscrutable and unpredictable, so users memorize commands by rote2016-05-11
Something wrong here?
Verbs like checkout don't match what they do, so commands can't be memorisedUnreviewed
4 people since 2022, in 2 different years · none this year
20082026
- Basic actions are hard to remember because the CLI is not structured sensibly2024-10-20
- CLI forces users to memorize tool internals instead of offering intuitive, consistent design2024-04-07
- CLI is involved and confusing, e.g. 'checkout -b' and too many switches to remember2022-11-05
Something wrong here?
Overloaded command is a footgun that silently causes mistakesUnreviewed
4 people since 2023, in 2 different years · 1 this year
20082026
- Overloaded command is a footgun that can silently cause mistakes2026-04-14
- Overloaded command causes users to accidentally lose work through mistakes2023-11-25
- Overloaded command makes it easy to do the wrong thing accidentally2023-11-22
Something wrong here?
Fixing a diverged branch needs obscure commands, so people copy the repoUnreviewed
3 people since 2023, in 4 different years · 1 this year
20082026
- Fixing a diverged branch needs obscure commands, so people copy the repo instead2026-05-25
- Repos split between main and master, so users must remember and retype the branch name2025-02-04
- Mixed master and main names force remembering which repo uses which, and mistakes clobber working trees2024-02-16
Something wrong here?
Easy to commit unintended changes or lose local config editsUnreviewed
3 people since 2015, in 3 different years · none this year
20082026
- Easy to commit unintended changes or lose local config edits2024-12-12
- Can't figure out how to throw away local changes, so relies on a GUI for anything beyond basics2016-02-21
- Personal IDE tweaks in shared config files show as modifications and must be undone before each push2015-02-01
Something wrong here?
Implementation complexity leaks inconsistently, making DAG operations hard to rememberUnreviewed
3 people since 2012, in 3 different years · none this year
20082026
- Exposes implementation complexity inconsistently, making DAG operations hard to remember2022-11-16
- Shows full DAG by default, confusing users expecting a simple linear history2017-05-08
- UI is sometimes weird because it began as low-level tools for manipulating a DAG2012-01-19
Something wrong here?
GUIs lack drag-and-drop for rebasing commits, forcing tedious text editsUnreviewed
3 people since 2010, in 3 different years · none this year
20082026
- GUIs lack drag-and-drop and copy-paste for rebasing commits, forcing tedious text edits2025-03-02
- GUI clients are slow, cluttered, and can't show diffs between selected revisions2015-05-01
- Committing selected hunks takes several separate commands and manual editing, far less efficient than a GUI2010-09-28
Something wrong here?
Index and commit IDs are hard-to-understand abstractionsUnreviewed
3 people since 2011, in 3 different years · none this year
20082026
- Hard to understand changes and review code due to per-commit granularity2023-06-03
- Hash-based commit IDs are hard to refer to compared with sequential revision numbers2018-04-11
- Adds many hard-to-understand abstractions like the index and commit IDs2011-07-14
Something wrong here?
Hard to remember which option produces the desired resultUnreviewed
3 people since 2017, in 3 different years · none this year
20082026
- Hard to figure out which command is needed; command structure and options are non-orthogonal2023-05-26
- Hard to remember which command option produces the desired result2021-06-22
- Hard to remember which command does a given operation, so users must guess2017-04-27
Something wrong here?
Old versions show confusing errors instead of saying to upgradeUnreviewed
3 people since 2017, in 3 different years · none this year
20082026
- Old Git versions show confusing errors instead of saying they need upgrading2022-06-23
- Forgets the git commands needed to update plugins, must check notes or docs2021-02-17
- Editing a hunk for git add --patch often produced errors in the git CLI2017-12-12
Something wrong here?
Terminology is confusing and branch deletion syntax is hard to useUnreviewed
3 people since 2013, in 3 different years · none this year
20082026
- Can't remember or guess syntax for merges, recovery, branch deletion, and bisect undo2023-04-20
- Status says branch is up-to-date and clean when it is misleading; undo is complicated and coarse-grained2015-05-01
- Terminology is confusing and branch deletion syntax is awful to use2013-02-20
Something wrong here?
Commands are learned by use-case, not concept, so mastery takes monthsUnreviewed
3 people since 2016, in 3 different years · none this year
20082026
- Commands and switches are not orthogonal or intuitive, requiring significant time to master2020-01-07
- Takes months to master because commands are learned by use-case rather than concept2019-12-24
- Takes a very long time to master, sapping time for other work2016-10-25
Something wrong here?
Hooks can't be auto-installed, so teams must set them up manuallyUnreviewed
3 people since 2018, in 3 different years · none this year
20082026
- Developers must remember to manually set up the hook in every repository2025-10-20
- Config is decentralized, so a team can't enforce shared hooks, diff tools, or settings2021-04-27
- Hooks can't be auto-installed on everyone's machine, so teams must set them up manually2018-07-28
Something wrong here?
Users must guess invocations and avoid footgunsUnreviewed
3 people since 2018, in 3 different years · none this year
20082026
- Leaky abstractions and overloaded commands force users to guess invocations and footguns2023-11-02
- Storage-layer details leak to users and single commands serve many unrelated purposes2022-11-16
- Incoherent commands and leaky abstractions make it hard to understand top-down2018-03-14
Something wrong here?
Must stop to recall file-adding and push syntax when committingUnreviewed
3 people since 2017, in 3 different years · 1 this year
20082026
- Moving to the next commit requires remembering confusing commands and DAG details2026-05-18
- Entering a multi-line commit message on the command line is painful; -m only suits one-liners2024-03-21
- Committing from the command line requires stopping to recall file-adding and push syntax, slowing the commander down2017-03-31
Something wrong here?
SSH keys and host settings must be copied to several placesUnreviewed
3 people since 2013, in 3 different years · 1 this year
20082026
- Confusing auth errors and convoluted non-default ssh key cloning, easy to get into bad state2026-06-18
- Cannot set SSH parameters and key paths via .ssh/config, leaking identities and blocking jump hosts2024-02-21
- SSH keys and host settings must be copied into several places and paths are mixed2013-01-30
Something wrong here?
Branch operations take many CLI steps and are easy to botchUnreviewed
3 people since 2020, in 3 different years · none this year
20082026
- Newbies struggle with CLI, mess up branches, and fear rebasing2025-01-16
- CLI terminology is confusing, e.g. 'the index' and deleting remote branches are hard2023-03-30
- CLI branch operations take many steps and are easy to botch, unlike visual clients2020-11-17
Something wrong here?
Silent LF to CRLF conversion causes a hard-to-diagnose build errorUnreviewed
3 people since 2013, in 3 different years · none this year
20082026
- Default LF to CRLF conversion causes problems working with files in WSL2021-10-10
- Merges insert LF conflict markers into CRLF files, and the needed settings are obscurely documented2016-01-26
- Silent LF to CRLF conversion caused a confusing, hard-to-diagnose build error2013-02-25
Something wrong here?
Uppercase protocol in URL makes clone fail, requiring lowercasing itUnreviewed
3 people since 2010, in 3 different years · 2 this year
20082026
- Git's --end-of-options flag breaks the usual -- convention, so users must remember a special case2026-07-23
- Uppercase protocol in URL makes git clone fail, so user must remember to lowercase it2025-11-07
- Renaming a folder just to change its case confuses git, catching the user often2010-10-29
Something wrong here?
Checking repo state via the CLI is slower and less clear than a GUIUnreviewed
3 people since 2017, in 3 different years · 1 this year
20082026
- CLI has an awful confusing UX and doesn't show repository state easily2026-07-23
- Inspecting repo state via the CLI is slower and less clear than a GUI2019-07-24
- Command line makes it harder to see repo structure and resolve merges2017-12-12
Something wrong here?
No symmetric command to unstage a file, needs obscure reset syntaxUnreviewed
3 people since 2016, in 3 different years · none this year
20082026
- Hard to find the right command to unstage a file; restore --staged is confusing2024-04-06
- No symmetric command to unstage a file; unstaging needs the obscure git reset syntax2021-06-21
- Unstaging a file requires the unintuitive 'git checkout -- <file>' command2016-10-27
Something wrong here?
Expert users accidentally trash repositories and spread the damageUnreviewed
3 people since 2014, in 3 different years · none this year
20082026
- GUIs corrupt repositories and don't show what operations actually did2021-11-30
- Requires heavy cognitive load and repeatedly corrupts repositories for users2020-06-29
- Expert users accidentally trash repositories and spread the damage2014-03-07
Something wrong here?
Documentation is inconsistent, so reading it worsens understandingUnreviewed
3 people since 2013, in 3 different years · none this year
20082026
- Unexpected situations lead to deep rabbit holes of documentation searching2021-06-13
- Documentation is inconsistent and confusing, so reading it worsens understanding2016-05-12
- Confusing terminology and cryptic error messages that require reading docs or searching to understand2013-03-12
Something wrong here?
No visualization of repository data, making branch juggling hardUnreviewed
3 people since 2014, in 3 different years · none this year
20082026
- Lacks visualization of repository data, making juggling branches hard without a GUI2022-10-09
- Understanding the repository graph from the command line is very hard for people2019-01-17
- Merge-heavy repository graphs are nearly impossible to follow for master history2014-01-10
Something wrong here?
Must manually stage files, since changes aren't committed by defaultUnreviewed
3 people since 2010, in 3 different years · none this year
20082026
- Forces users to manually stage files, not committing all changes by default2022-10-09
- Exact file lists break as new files are added, requiring every user to update patterns2020-01-17
- Viewing changes before committing requires double-clicking each file individually2010-11-27
Something wrong here?
Hard to guess the command when you know the goalUnreviewed
3 people since 2009, in 3 different years · none this year
20082026
- Non-intuitive for people who know the goal in plain English but not the command2019-05-23
- Unintuitive metaphors and cryptic commands for simple tasks, requiring constant searching unless memorized2018-11-23
- Commands are hard to guess when you know the goal but not the incantation2009-02-20
Something wrong here?
Command silently discards uncommitted changes irrecoverablyUnreviewed
3 people since 2010, in 3 different years · 1 this year
20082026
- Command silently discards uncommitted changes, unintuitive and irrecoverable, so people misunderstand it2026-04-15
- Common discard action uses an obscure command form that has nothing to do with its purpose2020-08-16
- Benign-looking commands like checkout silently erase uncommitted changes, unlike other RCS tools2010-04-17
Something wrong here?
Usability so poor that people give up on their dataUnreviewed
3 people since 2015, in 3 different years · none this year
20082026
- Last attempt at git-annex was very rough; wiki gives database errors on account creation2021-05-13
- Commenter says git-annex is so poor in usability that people give up on the data2017-09-27
- Explaining git-annex to the whole team is too big a barrier2015-04-08
Something wrong here?
Hard to track which branch and remote are in use across machinesUnreviewed
3 people since 2012, in 3 different years · none this year
20082026
- Confusing usage patterns, flaky tools, and leftover branches and remotes that can't be removed2017-05-26
- Hard to track which branch and remote are in use across machines, causing mistakes2013-02-16
- Hard to delete local caches of remote tracking branches2012-03-20
Something wrong here?
Footguns must be navigated every time a user does anythingUnreviewed
3 people since 2021, in 3 different years · 1 this year
20082026
- Has many footguns that make it error-prone and painful to use2026-09-10
- Many footguns must be navigated every time a user does anything2024-08-16
- Powerful commands with footguns cause people to mess up their repositories2021-11-11
Something wrong here?
Squash, merge and rebase commands are hard to tell apartUnreviewed
3 people since 2016, in 3 different years · 1 this year
20082026
- Confusing command names like rebase, squash, and theirs/ours even confuse experienced engineers2026-03-22
- Separate squash, merge and rebase commands are confusing to tell apart2018-12-14
- Term 'squash' is confusing because it's used for a merge that keeps history2016-04-02
Something wrong here?
Context-sensitive commands are hard to predict and use correctlyUnreviewed
3 people since 2013, in 3 different years · none this year
20082026
- Command line forces users to hold lots of context in their head2023-12-10
- Overloaded context-sensitive commands are hard to predict and use correctly2021-08-01
- One command does four different things, requiring lots of context to parse2013-12-04
Something wrong here?
Staged-changes flag is buried in docs and has inconsistent namesUnreviewed
3 people since 2017, in 3 different years · none this year
20082026
- Staged vs unstaged changes concept is confusing to users2024-02-03
- Staged changes have three names and need an obscure option to diff2021-04-08
- Staged-changes flag is buried in docs, so users miss it and see inconsistent names2017-12-12
Something wrong here?
No obvious way to blame or view a specific file's history by clickingUnreviewed
3 people since 2010, in 3 different years · 1 this year
20082026
- No obvious way to blame or view history for a specific file by clicking2025-11-11
- Having to tiptoe around files you don't want in history2023-08-01
- Confusing to view a single file at different points in history2010-06-11
Something wrong here?
Accidentally unreachable commits take googling and trial to recoverUnreviewed
3 people since 2010, in 3 different years · none this year
20082026
- After a commit fails partway, recovering requires digging into plumbing and dangling objects2017-12-13
- Accidentally made commits unreachable, and recovering them took googling and trying2014-12-12
- Users can't find how to recover from detached HEAD commits; docs and search fail2010-11-04
Something wrong here?
Hard reset discards uncommitted changes with no backupUnreviewed
3 people since 2017, in 3 different years · none this year
20082026
- Unstaged changes are lost for good after reset --hard, despite the reflog's promise2023-02-28
- Reset --hard also changes working tree files, a surprising side effect2021-07-05
- Hard reset discards uncommitted changes with no backup, so work is easily lost2017-06-12
Something wrong here?
Leaky abstraction forces use of plumbing commandsUnreviewed
3 people since 2015, in 3 different years · none this year
20082026
- Leaky abstraction forces users to use plumbing commands more often than not2025-09-01
- Users must know magic incantations; plumbing commands are hard to pick2023-11-06
- Exposes too much plumbing and has a baroque interface for certain tasks2015-02-15
Something wrong here?
Branches break too often, so users avoid themUnreviewed
3 people since 2018, in 3 different years · none this year
20082026
- Branches bug out too often, so the commenter avoids using them2024-04-05
- Switching branches rewrites the working tree, which the commenter finds annoying2020-11-17
- Switching branches with uncommitted changes is so cumbersome the commenter browses history on GitHub instead2018-11-30
Something wrong here?
Unusual operations can leave the repository unrecoverableUnreviewed
3 people since 2017, in 2 different years · none this year
20082026
- Tooling frequently puts the repo into nonsensical states and is nearly unusable2020-11-06
- Non-routine operations are impenetrable and often leave repositories in irrecoverable states2020-10-13
- Unintuitive and hard to learn; out-of-ordinary operations often leave repository unrecoverable2020-06-29
Something wrong here?
Low-level primitives are too hard to use, forcing workaroundsUnreviewed
3 people since 2020, in 2 different years · none this year
20082026
- Flexible tools take years to learn before they work for basic use2022-08-06
- Tool's low-level primitives are too hard to use productively, forcing workarounds2020-10-13
- Tooling gives no guidance, so developers must keep workflows in their heads and often get them wrong2020-03-04
Something wrong here?
Partial checkouts are awkward to useUnreviewed
3 people since 2020, in 2 different years · 2 this year
20082026
- Developers must set up LFS correctly, and missed steps silently commit binaries or checkout pointers2026-06-17
- Partial checkouts are awkward to use, and LFS locks are buggy2026-03-22
- Second auth system and parallel commands to learn; broken checkouts without the LFS extension installed2020-01-07
Something wrong here?
New users land in unexpected rebase states and can't tell what happenedUnreviewed
3 people since 2014, in 2 different years · none this year
20082026
- Novice users create messes and nightmares when they try to rebase2017-08-09
- New users get into unexpected states during rebases and can't tell what happened2017-05-23
- Many interacting versions make new users easily reach inconsistent states they cannot recover from2014-11-13
Something wrong here?
Confusing defaults must be learned through trial and errorUnreviewed
3 people since 2016, in 2 different years · none this year
20082026
- Average users must expend extra effort to learn it and avoid mistakes2020-12-17
- Confusing defaults that every user must learn through trial and error, wasting time2020-11-17
- Non-obvious best practices and quirky defaults that users must learn over time2016-12-21
Something wrong here?
GUIs leave users stuck and frustrated when things break in edge casesUnreviewed
3 people since 2020, in 2 different years · none this year
20082026
- GUI gives vague errors or silently does something wrong instead of explaining the problem2021-08-01
- UI is not well thought out and creates countless corner cases2020-11-17
- GUIs aggravate problems when things break in weird edge cases, leaving the user frustrated2020-04-22
Something wrong here?
Docs don't distinguish when snapshot and diff models applyUnreviewed
3 people since 2022, in 2 different years · none this year
20082026
- Docs do a poor job distinguishing when snapshot and diff models apply2024-01-06
- Snapshot model and rerere behave unintuitively, not matching what users expect2022-07-05
- Hybrid snapshot and diff-patch model makes merges and pulls confusing to understand2022-06-25
Something wrong here?

This list counts all time; the period switch above only changes the ranking. Each issue is a group of similar complaints raised by at least 3 people in 3 different months and threads. Each line under an issue is Claude Haiku's summary of one of its latest comments, not a quote; follow it to read the comment on Hacker News.

Unreviewed issues were grouped by machine: Claude Haiku labelled each comment as a usability complaint, named what it's about and summed up the problem in a line, and a small model grouped similar problems. Nobody has checked them by hand. Expect mistakes.

The newest 50 complaints