Git

Traditional Git servers cannot handle the massive surge in traffic from AI-assisted tools, AI agents, and automated CI/CD processes. Git clones and fetches now take several minutes or timeout instead of completing in seconds, creating pipeline delays and blocking deployment workflows.

Once sensitive data like API keys, passwords, or confidential files are pushed to a public repository, they are challenging to remove completely, potentially exposing them to unauthorized access. The problem persists even when using git filter-branch or similar tools.

Uncommitted or unpushed work is easily lost through folder overwrites or deletion. Even pushed commits become vulnerable: deleting branches makes commits unreachable and subjects them to garbage collection and permanent loss, creating data safety concerns.

v0 has broken Git integration, manual code edits vanish during later generations, exports produce blank screens or incomplete projects (missing pages), and sharing projects with teams is problematic. Code that works in v0 often breaks in production.

Large monorepos and multi-repo setups hit massive BLOB count and ref limits. Cloud-hosted or shared disk storage creates exponential I/O transfer costs and infrastructure strain, making Git nearly unusable and driving operational budgets to unprecedented levels.

When a developer merges a branch significantly behind the milestone branch, a selection of programs can be overwritten with commit history gaps that are not reversible. Large teams (3-6+ programmers) with multiple feature branches are especially vulnerable.

According to a 2025 Atlassian survey, 38% of engineering teams report merge conflicts as their top blocker. Teams spend more time resolving conflicts than coding, especially when feature branches linger without synchronization or in complex monorepo setups.

45% of developers have been negatively impacted by a colleague's force push, which rewrites history and causes work to be lost or conflicts to become nearly impossible to resolve. This reflects inadequate team coordination and access controls.

Multiple developers pushing or fetching simultaneously cause server bottlenecks, especially on self-hosted Git servers lacking adequate hardware. Synchronization and coordination across hundreds or thousands of contributors multiply conflicts and integration issues.

Balancing multiple parallel releases with hotfixes is tricky. Pushing hotfixes directly into master without rebasing related branches risks overwriting critical changes and complicates integration across active development branches.

Git works well for single-product CI/CD with a continuous main branch, but fails for delivery models common in pharma and statistical programming where multiple non-continuous deliveries sharing code are required. Classical Git workflows cannot be easily adapted.

Claude Code lacks native undo functionality for code modifications, forcing developers to rely heavily on Git for rollbacks. While workarounds exist, they require extra manual effort and Git discipline.

While GitHub Enterprise, GitLab, and Bitbucket offer access controls, complex permission hierarchies are difficult to enforce uniformly across an organization. This creates security bottlenecks and potential for inadvertent commits or malicious changes.

Developers frequently commit to wrong branches, create merge conflicts, and experience synchronization issues between local and remote repositories, causing confusion and messy code states that require manual resolution.

Pull request review is flagged as a top workflow blocker (25% of developers), slowing team coordination and delaying merges. No structured tooling has effectively reduced this friction point.

Git is difficult to teach and learn. Advice typically boils down to 'learn these 4 commands, seek help for anything else.' Most developers use the command line interface, which they lack experience with. New users struggle with preventing merge conflicts due to inexperience with best practices.

Operations like `git status` and `git log` become resource-intensive on large repositories with billions of lines of code or thousands of files. History search becomes slow, and cloning/fetching create significant onboarding barriers.

Automatic garbage collection interrupts normal work with blocking operations, causing friction in developer workflows. This is a historical pain point in Git's design that degrades user experience during normal operations.

The combination of working copy files and local Git repository state creates a 'magical state' where certain operations become impossible (e.g., changing branches after a broken merge). Developers must search for solutions rather than having straightforward recovery paths like SVN's simple delete and update.

Git's 'one repo is one project' policy prevents partial clones or branches. Teams must maintain multiple Git repositories for multiple projects, forcing manual tracking and introducing submodule complexity. This makes migrations from SVN extremely difficult.

Standard Git clones download entire repository history even when only latest files are needed. This creates increased bandwidth and storage costs for cloud-hosted repositories and CI pipelines, and makes offline work difficult for developers.

When local and remote repositories drift out of sync, developers encounter push failures and conflicts requiring manual intervention. The process of pulling, resolving conflicts, and then pushing again is tedious and error-prone.

Git requires developers to explicitly push commits to origin after local commits, creating a two-step workflow more complex than traditional VCS. Developers frequently forget to push, leading to confusion when colleagues pull and cannot see changes.

Gemini CLI lacks support for tool subcommands (e.g., git status vs git rm), forcing developers to grant all-or-nothing permissions for entire binaries like `git`, `gh`, `vercel`, or `supabase`. Users must constantly babysit permission requests instead of setting granular policies.

30% of developers using submodules have faced issues with submodules getting detached or becoming out of sync with their parent repositories, creating complex debugging scenarios and integration problems.

Teams must make many complex branching decisions: whether to create branches liberally or use a single main branch, how to handle multiple deliveries sharing code, and whether to enforce naming conventions. These choices multiply decision complexity and administrative overhead.

The confusing staging area in Git adds an extra layer of complexity that frustrates developers. Developers must understand and manage the staging index separately from the working directory and committed code, which is unintuitive for straightforward workflows.

More than half of developers (55%) struggle with Git rebase operations, which are frequently error-prone and can corrupt history. Rebase is a complex advanced feature that many developers avoid or misuse.

Half of Git users (50%) have experienced problems with SSH keys or other authentication methods, creating friction in onboarding, CI/CD integration, and multi-machine workflows. Authentication management remains a persistent operational pain point.

Commands like 'checkout' have multiple meanings—it can switch a branch, create a new branch, or restore a file to a previous version. This semantic overloading makes it difficult for developers to know which operation will execute.

Git's tooling ecosystem lags in advanced use cases. Automation scripts break with complex operations like rebases or large merges. Advanced workflows require supplementary tools but lack native support, increasing manual effort and error potential.

After rebasing commits on a branch, projects may be configured to block merge approvals from users whose contributions were rebased. This creates approval issues and communication confusion about when rebasing is safe, especially in collaborative environments with strict approval policies.

In effort to leverage advanced Git features, developers create overly complex workflows that confuse team members and make onboarding new developers challenging. This reduces productivity despite the intent to improve it.

Branches and tags must be created twice—once locally and once remotely—or they remain visible only to the creator. It is difficult to check which branches were pushed, and tags are not pushed to origin by default, creating workflow friction.

Developers fail to implement Git hooks, missing opportunities for automation. Without hooks, developers must manually remember to run various checks or commands, increasing the risk of errors and reducing workflow efficiency.

35% of developers feel overwhelmed by the complexity of their project's commit history. Large repositories with complex branching strategies, rebases, and merges create cognitive overload and make understanding project evolution difficult.

Developers neglect to properly configure .gitignore files, causing compiled binaries, log files, and temporary files to be tracked in version control. This clutters repositories, confuses collaborators, and bloats repository size unnecessarily.

Claude Code uses weird or non-standard Git commands that may not work as intended or follow project conventions.

Git continues to evolve with new features and improvements, but developers neglect to regularly update. Running outdated versions means missing new functionalities, bug fixes, and performance improvements.