Sources

its easier when you work on projects where there is 1 developer and 1 qc programmer. This will allow for each ADAM program or TLG program a branch can be created. If teams get bigger, for example there are 3-6 programmers, different practices are being introduced. For example, every programmer has their own branch and from time to time they merge their programs to the milestone branch. Once somebody merged an their branch to the milestone branch and as it was way behind, a selection of programs got overwritten and there was a gap in the commit history. This was not reversible. … ... For adoption, I think git is difficult to both teach and learn. Most advice boils down to "learn these 4 commands, seek help for anything else". The command line interface is (in my experience) how most developers use git. Which is normally another area where users have no (or at best, some) experience and this further makes git both difficult to teach and less appealing to use. The main area where I have typically seen new users struggle after grasping the basics is ensuring they do not cause merge conflicts. This is typically due to not following best practices (due to their inexperience). For business processes, I think the key challenges for git typically lie in two areas. Firstly in the branching strategy, which has many decisions that need to be made. For example, whether you choose to create branches liberally for each dry run/delivery or have a single main branch that is merged onto and tagged at appropriate points (normally not recommended if you have multiple deliveries that may want to share code). Or whether or not you trust users to appropriately choose the names of their branches or enforce a common naming structure linked back to issues/deliverable identifiers. A common issue I have encountered revolves around asynchronous code writing to a synchronised data folder. That is, any user may be on any commit and run a program (say ADSL) on that commit. This will update the synchronised data folder so that all other users are now reading from that version of ADSL. … A common issue I have encountered revolves around asynchronous code writing to a synchronised data folder. That is, any user may be on any commit and run a program (say ADSL) on that commit. This will update the synchronised data folder so that all other users are now reading from that version of ADSL. ... ### corinabioinformatic commented Apr 7, 2025 • edited Loading Challenges (broadly) - Fear (as commented today by one of the members) to break anything when pulling or pushing. Because lack of knowledge. - No leadership in this area, makes using git like a non-priority goal. Leadership to gain confidence using this is key. - Curve -just a bit- learning for advanced features. (Who knows about git merge, not merging because conflicts?) … There is a lack of desire to want to engage with or utilise the tool beyond its most basic features as a lot of the more collaborative features are covered by legacy systems. This means that although alternative systems may be more appropriate long term, until there is a validated method of capturing this information for the audit trail, people will not engage with GitHub beyond the necessities as it is seen as "rework". ### langkabh commented Apr 25, 2025 I agree with what @tomratford wrote above - especially about the branching strategy - and @kieranjmartin 's reaction. I also think that the main challenge is that git works really well in a classical CI/CD setting where you have a single product that you want to have a continuous production version of (i.e. main branch) while you work on new features in the background (e.g. a webpage). This simply isn't how we deliver statistical programming products in pharma and hence classical git workflows cannot be easily used by us.

1. **87%** of Git users have encountered merge conflicts at some point.8 2. Around **65%** of Developers have mistakenly lost a commit or changes in their Git history.8 3. **58%** of Developers have accidentally deleted a branch or commits.9 4. About **12%** have experienced repository corruption or other severe Git issues.9 5. **40%** complain that their repositories have become bloated and slow to clone.8 6. **35%** feel overwhelmed by the complexity of their project's commitment history.8 7. About **30% ** of Developers using submodules have faced issues with them getting detached or out of sync.8 8. **45%** have been affected negatively by a colleague's force push.9 9. **28%** have been confused or lost work when using ‘Git stash.’8 10. Roughly **55%** find Git rebase to be challenging and error-prone at times.8 11. **70%** have used a Git command without fully understanding its implications.9 12. **50%** have experienced issues with SSH keys or other authentication methods.9 > Navigating the intricacies of Git has proven challenging for many, with many users facing merge conflicts. Missteps in understanding its tools have led to lost commits and, alarmingly, even repository corruption for some. While submodules present their own challenges, the underpinning concern remains – a lack of comprehensive knowledge of Git commands amplifies risks. These statistics show the pressing need for improved training and streamlined workflows for designers collaborating on projects. … ## The key challenges & solutions in Git-based development 1. **85%** rely on Git's man pages or online resources to clarify command usage.8 2. **70%** use SSH agents or credential managers to simplify authentication.9 3. **35%** switched to faster Git hosting platforms or solutions for improved performance.9 4. **55%** utilize pre-commit hooks to catch unintended file changes or secrets before they get committed.9 5. **90%** believe continuous learning and training are crucial to avoiding and solving Git problems.8 6. **75%** of Developers find peer programming or review helps catch and solve Git issues early.9 Git-based development challenges are more common than one might think. This article illuminates those problems and provides tangible solutions to navigate them easily. Understanding and applying these insights can help developers foster a smoother collaborative environment.

What if we could keep Git compatibility while fixing its most frustrating aspects—painful merges, scary rebases, being stuck in conflict states, and the confusing staging area?

GitHub Actions has grown massively since its release in 2018; in 2025 alone, developers used 11.5 billion GitHub Actions minutes in public and open source projects, up 35% year over year from 2024. At the same time, this has not been without its growing pains, and you’ve made clear to us what improvements matter most: faster builds, improved security, better caching, more workflow flexibility, and rock-solid reliability. … ... This was not without its share of pain; it slowed the pace of feature work and delayed progress on long-standing community requests. ... Repositories can now exceed the previous 10GB cache limit, removing a long-standing pain point for teams with large dependencies or multi-language monorepos. For teams with larger codebases or complex build pipelines, the old 10GB GitHub Actions cache limit often meant build dependencies were evicted before they could speed up your next workflow run, leading to repeated downloads and slower builds. This release was only possible due to our architecture rework and fulfills a request from the community, particularly among some of our largest users.

## Pain Point #1: Deployment Bottlenecks ### The Problem How long does it take your team to get code from commit to production? For most teams, it's days or weeks. Elite teams deploy in under a day. The bottleneck isn't usually the code—it's the deployment process itself. When deployments require specialized knowledge or manual steps, everything slows down. If the one person who knows how to deploy is on vacation, you're stuck. … ### Getting Started You don't need a huge budget to implement this. Start with: - GitHub Actions or GitLab CI for automated pipelines - Docker (used by 59% of professional developers) for consistent environments - Standardized deployment scripts checked into your repo Set up templates for your most common deployment types and build from there. … ## Pain Point #3: Environment Inconsistency ### The Problem "It works on my machine" might be the most frustrating phrase in software development. Environment inconsistencies waste countless hours on debugging issues that only appear in specific environments. When dev, test, and production environments don't match, you're essentially testing different systems. Problems appear out of nowhere during deployment, and fixing them becomes a painful guessing game. … ## Pain Point #4: Cognitive Load from Multiple Tools ### The Problem Most teams juggle 6+ different tools, with 13% managing up to 14 different tools in their development chain. Each tool has its own interface, quirks, and mental model. Learning and remembering how to use all these tools creates massive cognitive overhead, especially for new team members. … ### Getting Started Start by: - Auditing your current toolchain to identify redundancies - Creating consistent interfaces for your most-used tools - Building wrapper scripts that standardize common commands - Setting up a simple internal portal or wiki that provides single-point access ## Pain Point #5: Security & Compliance Overhead ### The Problem Security is crucial but often becomes a productivity killer. Manual security reviews, compliance checks, and remediations consume valuable development time and delay deployments. When security is bolted on at the end rather than built in from the start, it creates friction and frustration. … ## Leveraging What You Already Have The good news? ... Your Git workflow can expand beyond code versioning to include configuration and Infrastructure as Code specs. Those Docker containers you use for local development? With some standardization, they become the basis for consistent environments across your pipeline.

This makes it harder than ever to maintain projects and make sure they continue moving forward in the intended direction. Auto-generated issues and pull requests increase volume without always increasing the quality of the project. As a result, maintainers need to spend more time reviewing contributions from developers with vastly variable levels of skill. In a lot of cases, the amount of time it takes to review the additional suggestions has risen faster than the number of maintainers. … ## Record growth is healthy, if it’s planned for On the surface, record global growth looks like success. But this influx of newer developers can also be a burden. The sheer popularity of projects that cover basics, such as contributing your first pull request to GitHub, shows that a lot of these new developers are very much in their infancy in terms of comfort with open source. There’s uncertainty about how to move forward and how to interact with the community. Not to mention challenges with repetitive onboarding questions and duplicate issues.

However, encountering Git errors is common, especially for those new to the platform. This blog aims to address prevalent Git mishaps faced by developers and provide actionable solutions to overcome them. ... **Git Mishaps and Their Solutions ** **Issue 1: “fatal: not a git repository (or any of the parent directories): .git”** Occurs when executing Git commands outside a repository. Typically, due to forgetting initialization or misplacement/deletion of the .git directory. Solution: Ensure you’re within a Git repository. If not, navigate to the correct directory and initialize a new repository with git init. **Issue 2: “error: failed to push some refs to ‘git@github.com:USERNAME/REPOSITORY.git’” ** Occurs when attempting to push changes to a remote repository, but local and remote repositories are out of sync. Solution: Pull the latest changes with git pull, resolve conflicts if any, and then attempt to push again. **Issue 3: “error: Your local changes to the following files would be overwritten by merge” ** Occurs when pulling changes conflicts with local modifications. Solution: Resolve conflicts using a merge tool, save changes, commit them, and then retry pulling from the remote repository. **Issue 4: “error: pathspec ‘file.txt’ did not match any file(s) known to git” ** Occurs when referencing a file not present in the repository. Solution: Verify filename correctness, create the file if missing, or restore it from backup. Add and commit changes accordingly. **Issue 5: “error: failed to clone some remote refs” ** Occurs when cloning a repository with remote repository issues. Solution: Confirm remote repository existence and access permissions. If private, seek collaborator status. If issues persist, retry later or contact the repository owner. Navigating through Git pitfalls can be daunting, but understanding common issues and their remedies is key to becoming proficient in version control.

This makes it harder than ever to maintain projects and make sure they continue moving forward in the intended direction. Auto-generated issues and pull requests increase volume without always increasing the quality of the project. As a result, maintainers need to spend more time reviewing contributions from developers with vastly variable levels of skill. In a lot of cases, the amount of time it takes to review the additional suggestions has risen faster than the number of maintainers. … ## Record growth is healthy, if it’s planned for On the surface, record global growth looks like success. But this influx of newer developers can also be a burden. The sheer popularity of projects that cover basics, such as contributing your first pull request to GitHub, shows that a lot of these new developers are very much in their infancy in terms of comfort with open source. There’s uncertainty about how to move forward and how to interact with the community. Not to mention challenges with repetitive onboarding questions and duplicate issues.

GitHub has done much when it comes to making open-source software and code accessible to users, but there are still areas where developers think the repository could improve. In an open letter to GitHub, developers from projects like jQuery, Meteor, PhantomJS, React Native and Selenium have detailed their most frequent problems with GitHub, along with their remedies to those problems. “Those of us who run some of the most popular projects on GitHub feel completely ignored by you,” the developers wrote. “We’ve gone through the only support channel that you have given us either to receive an empty response or even no response at all. We have no visibility into what has happened with our requests, or whether GitHub is working on them. Since our own work is usually done in the open and everyone has input into the process, it seems strange for us to be in the dark about one of our most important project dependencies.” **(Related: The most popular projects on GitHub)** Problems include: • Dealing with issues that are missing crucial information such as reproduction steps or the version tested. “We’d like issues to gain custom fields, along with a mechanism (such as a mandatory issue template, perhaps powered by a newissue.md in root as a likely simple solution) for ensuring they are filled out in every issue,” the developers wrote. • Dealing with issues that accumulate contentless +1 comments, which cause spam for maintainers or contributors. “These +1s serve a valuable function in letting maintainers know how widespread an issue is, but their drawbacks are too great. We’d like issues to gain a first-class voting system, and for contentless comments like ‘+1’ or ‘’ or ‘me too’ to trigger a warning and instructions on how to use the voting mechanism,” the developers said. • Dealing with issues and pull requests that don’t adhere to the contribution guidelines. “Maintainers should be able to configure a file in the repo (interpreted as [GitHub Flavored Markdown]) to be displayed at the top of the new issue/PR page instead of that link. Maintainers can choose to inline content there and/or link to other pages as appropriate,” the developers wrote. According to the developers, they have been waiting years for these problems to be addressed, and can no longer stand idly by waiting for GitHub to make progress on them. “If GitHub were open-source itself, we would be implementing things ourselves as a community—we’re very good at that,” they wrote.

# GitHub Pain Points This is my feedback on using GitHub to manage a popular project (ESLint). Topics are presented in no particular order. In general, everything I say about issues also refers to pull requests. For each problem I've suggested a solution. ... ## Problem: No good way to distinguish new issues from "accepted" issues Users are opening new issues every day, and these issues automatically bubble to the top of the issues list by default. We do label issues that we're committed to doing as "accepted", but if there are enough new issues, you don't even see those until the second page of issues. Why is this a problem? In a word: distraction. Almost every day I go to the issues list intending to work on something specific and then get sidetracked because I see 3-4 new issues at the top of the list. The extra step of needing to filter by the "accepted" label is not effective at solving this problem. **Possible Solution:** A kanban board where issues must be explicitly added to the board by a team member so new issues don't show up there automatically. That would also allow us to easily see which issues we should be focusing on now, which should be next, and which need review. ## Problem: All notifications are mixed together In order to keep my sanity, I've had to turn off all notifications except for when I'm mentioned specifically. I use the notifications page most days, but that can also be overwhelming when there are dozens of notifications to look at it. There's no way to tell the difference between a new issue/PR, an issue I'm actively discussing, or an issue that someone mentioned me on. Additionally, once I click through on a notification to the issue/PR, even if I just decide I want to work on it later, that notification is now removed from the notifications page so I need to use some other mechanism to remember to go back to it. … ## Problem: Limited instructions for new issues/PRs While issue templates helped, it forces me to decide what the most important issue type and focus on that. Otherwise, I'd have to write a long bit of text that no one reads to say "If it's a bug, do this; if it's an enhancement, do this." Right now, we have the template for bug reports and ask people to go to another URL if they want to report something else. Not surprisingly, people tend to just delete the issue template and type whatever they want instead. That leads to more time we need to spend asking for the relevant information. Barely anyone actually clicks through on the contribution guidelines message, as well. **Possible Solution:** A customizable dropdown on the "new issue" page that automatically fills in the appropriate template for what the person is reporting. For ESLint, we'd want to be able to have options for: Possible bug, new rule proposal, new rule option proposal, new CLI option proposal, documentation change, or other. Those could be tied to templates in the `.github` directory. ## Problem: Lots of duplicate issues filed The setup of GitHub issues encourages people to just file new issues without doing any sort of search for similar issues first. And since no one reads the contribution guidelines message linked on the new issue page, we are end up wasting a lot of time on duplicate issues. **Possible Solution:** Add a note directly on the new issue page asking people to search for already existing issues first. Maybe even throw a search box next to that note to make it easy. Or to be really aggressive, optionally allow repos to specify that users must complete a search before being allowed to open an issue. ## Problem: Ghost issues As our issue count has grown, we've ended up with more issues waiting for response from the original reporter or conversation just trails off. It's really easy to lose track of these issues since they do not show up in notifications unless someone interacts with them. Those issues end up getting pushed down the issue list as new issues are opened and can easily be lost. … ## Problem: No good way to easily gather votes While the reactions feature is nice, it mixes together all users (team members and non-team members). That can be problematic when you're trying to determine whether or not to implement a suggestion. Right now, there's no easy way to tell the community "here are the things we need feedback on" and then tally those results. Similarly, there's no easy way to say that an issue needs three +1s from the team to proceed.

Artificial intelligence sits at the center of 2025's open source story, but not only in the flattering ways the industry tends to celebrate. AI has made it easier for new developers. They can now understand codebases, draft patches, and contribute sooner. But this comes with a downside. Maintainers face a flood of what the report calls "AI slop." This means high-volume, low-quality, and often inaccurate contributions. These contributions take up reviewers’ time without significantly helping the project. The scale of this problem is significant enough that GitHub draws an analogy to a denial-of-service attack on human attention. Auto-generated issues and pull requests have increased dramatically, but the number of maintainers with the authority and context to review them has not kept pace. The review burden has grown faster than the reviewer pool, creating a bottleneck that threatens to stall projects even as their contributor counts climb. … Growth at the bottom of the contributor funnel has not been matched by equivalent growth in people moving into ownership and maintainer roles. The report highlights a growing gap. More people are joining open source projects, but the number taking on stewardship roles remains steady. This gap creates problems. As more developers join, they bring onboarding questions, duplicate issues, and uncertainty about community norms. Existing maintainers have to deal with all this. … GitHub's 2026 outlook highlights that the open source community faces not just technical challenges, but mainly organizational ones. The tooling to write software has never been more accessible. The missing layer is governance, documentation, and community support. These are needed to manage what happens when millions of new contributors join without a shared context.

### Body TL;DR: The enormous focus on activity tracking and how absolutely **IN YOUR FACE** it is, everywhere, completely does not jibe with my use of this service. In fact, it is so stressful that I have avoided working on my projects entirely. **The contribution calendar genuinely gives me heartburn and causes long term anxiety/depression.** … Things on GitHub that I want to disable: - All the contribution and activity tracking and all the charts displayed on the main (profile) page. - Achievements! - The Projects thing. - The Insights thing. - The Wiki thing. I have always been amazing at writing and including documentation within my content. I don't want to feel I am supposed to use your proprietary thing too. - The Security thing. I don't care about computer security. It's an a non-subject. After 30+ years, I'm sick of hearing about it. As basic user of GitHub, I certainly don't give any wingdings whatsoever about it in relation to my repos. If someone wants to write me an email about an issue, cool, I will read it, but I certainly don't need an entire framework to manage this one stupid topic. You already have the whole "Issues" thing for tracking... issues.