Best of Git — 2025
- 1
- 2
- 3
Dev Tools·47w
Froggit - Git TUI
Froggit is a new Git TUI (Terminal User Interface) tool in development that aims to simplify Git usage through a visual interface in the terminal. The project focuses on making Git more accessible for both beginners and advanced users by providing an intuitive alternative to complex command-line operations, with goals of being simple, fast, and workflow-enhancing.
- 4
Hacker News·26w
The (lazy) Git UI You Didn't Know You Need
Lazygit is a terminal-based Git UI that enhances productivity through consistency, discoverability, and interactivity. The tool maintains Git CLI terminology while providing visual guidance for operations like interactive rebasing, cherry-picking, and commit patching. Its vim-style keybindings enable quick workflows (e.g., amending and force-pushing in 5 keystrokes), while interactive prompts prevent mistakes and teach better Git patterns. The TUI approach delivers speed and portability without overwhelming users, making complex operations like splitting commits or selective line resets significantly simpler than traditional CLI or GUI alternatives.
- 5
thoughbot·24w
Git 3.0 will use main as the default branch
Git 3.0 will default to 'main' as the initial branch name instead of 'master', marking the completion of a transition announced in 2020. Expected near the end of 2026, the release will also switch from SHA-1 to SHA-256 hashing for improved security, introduce a new storage format optimized for macOS and Windows, and formally integrate Rust into the build process.
- 6
YouTube·1y
Google's Git Killer Is INSANELY Better (and it's open source)
Explore how JJ, a new version control system written in Rust, offers a fresh approach to version control. Backed by experts and featuring advanced functionalities like automatic rebase, JJ simplifies complex tasks such as branching, merging, and resolving conflicts. With support for familiar commands, JJ promises a more efficient workflow while maintaining compatibility with Git as its underlying database.
- 7
CodeHead·21w
The Framework To Becoming A Good Programmer
Becoming a good programmer requires a systematic framework: understand problems thoroughly before coding, design solutions through decomposition, write readable code with clear naming and small functions, debug methodically using hypothesis testing, build progressively complex projects, use version control meaningfully, read production code regularly, and seek feedback aggressively. This disciplined approach builds judgment and accelerates learning more effectively than memorizing syntax or switching languages.
- 8
freeCodeCamp·1y
Essential CLI/TUI Tools for Developers
Developers extensively using terminals can enhance their productivity through various CLI/TUI tools. This selection includes tools for Kubernetes management, container monitoring, text processing, Git handling, and more. Each tool is presented with an overview, key features, and installation instructions for different operating systems.
- 9
How to Use Lazygit to Improve Your Git Workflow
Lazygit is an open-source command-line UI tool that simplifies Git commands with a user-friendly interface and keyboard shortcuts. It allows users to manage Git operations like commit, push, pull, create, and delete branches efficiently. The post provides a tutorial on installing Lazygit on various operating systems, an overview of its UI and panels, essential shortcuts, and a guide to common Git operations using Lazygit.
- 10
Spacelift·1y
GitLab vs GitHub : Key Differences in 2025
GitLab and GitHub are leading Git-hosting platforms with distinctive features. GitLab offers a fully integrated DevOps platform including CI/CD, security scanning, and infrastructure management out of the box, making it ideal for enterprises. GitHub, best known for its code hosting and collaboration capabilities, relies on third-party tools for extensive DevOps functionalities but excels in ease of use, community support, and integrations. Both platforms support AI-powered coding assistants, but GitLab's additional security and compliance features provide an edge for large organizations.
- 11
JavaScript Mastery·34w
DevOps Full Course | Build and Deploy a Scalable Production Ready API
A comprehensive DevOps course covering fundamentals through production deployment. Teaches Git version control, CI/CD pipelines with GitHub Actions, Docker containerization, Kubernetes orchestration, and infrastructure as code. Includes hands-on project building a production-ready API with authentication, database integration, monitoring, and security features using modern tools like PostgreSQL, Neon DB, and Arkjet.
- 12
Awesome·26w
Life lessons from a coding legend...
Linus Torvalds' criticism of a Meta engineer's pull request sparked debate about code quality and software development culture. The incident highlights a fundamental principle: code clarity trumps abstraction. Torvalds criticized unnecessary helper functions that add indirection without value, arguing that good code should be explicit and easy to understand. The discussion reveals how industry best practices around abstraction can sometimes conflict with simplicity, and how experienced developers often favor straightforward, readable code over clever abstractions. The incident also contrasts old-school programming culture, built on deep technical knowledge and excellence, with modern development practices.
- 13
Community Picks·1y
Git Branching Strategies: A Comprehensive Guide
Version control is essential in modern software development, and Git is the industry standard. This guide explores popular Git branching strategies, including GitFlow, GitHub Flow, GitLab Flow, Trunk-Based Development, Feature Branching, Environment Branching, Release Branching, and Forking Workflow. It details the structure and workflow of each strategy, along with their pros and cons, helping readers choose the best strategy for their team and project requirements.
- 14
Jobs·39w
Multiple GitHub Accounts — A Must-Have Skill for Developers
Managing multiple GitHub accounts on one machine requires proper SSH key configuration and Git settings. The setup involves creating separate SSH keys for each account, configuring SSH hosts with specific identity files, using Git's includeIf directive for folder-specific configurations, and organizing projects by directories. This approach prevents accidentally pushing to the wrong account and automates the switching between personal and work repositories.
- 15
The Coding Gopher·1y
How 10X Engineers Use Git
The post explains advanced Git commands like git stash, git bisect, and git submodule, detailing their uses and benefits. It also covers the git cherry-pick command, illustrating how it allows selecting specific commits from a branch and adding them to another, emphasizing its utility and potential drawbacks.
- 16
DEV·28w
Why Do You Push Code During Work Hours?" - How an Interview Question Led Me to Build a Delayed Commit Feature
A developer built a delayed commit feature for GoCommit after an interviewer questioned their GitHub commit timestamps during work hours. The tool allows developers to schedule commits outside restricted hours, addressing privacy concerns and work-life boundaries. It intercepts commits during configured work hours, presents alternative timestamps, and uses Git's native date flags to set both author and committer dates. The feature integrates with GoCommit's AI-powered commit message generator and raises questions about whether coding schedules should be public information.
- 17
bigboxSWE·29w
Extremely Underrated Programming Skills
Shell proficiency, Git workflows, and build systems are foundational skills that significantly improve developer productivity. Mastering shell commands beyond basic navigation, understanding Git operations like rebase, stash, and reflog, and comprehending build systems can save hours of development time. These tools provide speed, control, and reliability in daily development work, making them more valuable than chasing trendy technologies.
- 18
- 19
Paul Vasile·31w
If You Say “Never Do X” in Programming, I Assume You Don’t Know What You’re Talking About
A critique of absolute programming advice that uses blanket "never do X" statements. The author argues that most programming practices labeled as forbidden actually have legitimate use cases and context matters more than rigid rules. Examples include git force push, committing to main branches, and password management strategies. The piece advocates for understanding the purpose and appropriate context of tools rather than following dogmatic prohibitions.
- 20
freeCodeCamp's New Relational Databases Certification is Now Live
freeCodeCamp launched a new Relational Databases certification covering Bash scripting, SQL, and Git. The certification includes interactive lessons, workshops, labs, and quizzes across multiple modules, with five required certification projects. Students must pass a 50-question exam using an open-source exam environment that runs on laptops/desktops. The certification is free and verified, with anti-cheating measures including randomized questions, weekly attempt limits, and manual review. Exams are closed-book and timed, with one attempt per week allowed. The certification replaces portions of the previous Full Stack Developer certification.
- 21
David Heinemeier Hansson·24w
No backup, no cry
A modern approach to data management that eliminates traditional full-system backups by treating computers as disposable, stateless units. The strategy relies on distributed copies through services like Dropbox and GitHub, combined with full-disk encryption, ensuring all important data exists in multiple locations. This setup allows for quick recovery and system restoration, with configuration automated through ISO setups that can install a fully functional system in minutes.
- 22
Developer's Journey·22w
A month ago, I posted my Obsidian setup, and since then, I’ve rebuilt and refined it a lot — here’s the updated system that’s been keeping my coding + learning organized.
A developer shares their refined Obsidian vault system after a month of iteration, featuring structured folders for projects, clients, education, and logs. The setup includes templates for daily notes, client tracking, and blog posts, with integration into their coding workflow through Git and VSCode. The system consolidates coding, studying, content planning, and progress tracking into a single organized workspace.
- 23
99% of Developers Don't Get Git Rebase
Git rebase is a powerful command that rewrites commit history by replaying commits from one branch onto another, creating a linear history instead of merge commits. Unlike git merge which preserves branching structure, rebase transplants commits as if they were created on top of the target branch. The process involves finding the common ancestor, temporarily storing unique commits, and reapplying them with new hashes. Interactive rebase allows developers to squash, reorder, edit, or drop commits for cleaner history. However, rebasing shared branches is dangerous as it rewrites history and can disrupt collaborators. Best practices include only rebasing local feature branches and using clear commit messages for better code review workflows.
- 24
Michael Lynch·1y
No Longer My Favorite Git Commit
Reevaluating a previously admired detailed Git commit message, the author identifies flaws in its verbosity and information organization. They propose a revised version that presents key details upfront and includes clear external references. Emphasizing the value of personal principles in software engineering, the author encourages defining what makes a quality commit message.
- 25
Lobsters·1yEvery line of code is always documented
Every line of code is inherently documented through the project's version control history. By analyzing commit messages, developers can uncover why specific lines of code were written, making history a valuable tool for understanding and improving code. Effective use of git blame, git log, and other tools can help identify who wrote specific code, when it was added, and the reasoning behind it. Improving commit messages and avoiding unrelated changes in a single commit are stressed as important practices.
