Best of Git — January 2026

1. 1
   Article

   Wix Engineering·18w

   Why I Stop Prompting and Start Logging: The Design-Log Methodology

   The Design-Log Methodology addresses the "Context Wall" problem in AI-assisted coding by maintaining version-controlled markdown documents that capture design decisions before implementation. Instead of repeatedly explaining architecture to AI, developers create immutable design logs in a ./design-log/ folder that document problems, questions, answers, and implementation plans. The AI reads these logs first, asks clarifying questions in the document, and only codes after design approval. This approach transforms AI from a code generator into an architectural partner, enabling simple prompts, preventing context drift, and creating traceable implementation history.

   242

   11
2. 2
   Article

   Lobsters·15w

   Why there’s no European Google?

   Europe hasn't produced tech giants like Google or Facebook, but has created fundamental infrastructure that powers the modern internet. The World Wide Web (HTTP/HTML), Linux, Git, Mastodon, VLC, and LibreOffice are all European inventions released as open source common goods rather than privatized for profit. European success is measured by long-term contribution to humanity rather than short-term wealth creation, with technologies designed to benefit everyone through copyleft licensing. This approach has produced lasting infrastructure that will outlive any individual company.

   231

   34
3. 3
   Article

   Towards Data Science·16w

   Maximum-Effiency Coding Setup

   A developer shares their optimized coding workflow centered around Claude Code in the Warp terminal. Key techniques include using Git worktrees to run multiple AI agents in parallel without conflicts, creating slash commands for repetitive prompts, maintaining a low threshold for delegating tasks to agents, and always using frontier models despite higher costs. The setup organizes work by folders in Warp tabs with split panes for concurrent agents, switching to Cursor only for critical infrastructure requiring manual control.

   78

   4
4. 4
   Article

   Hacker News·15w

   I made my own git

   A developer built a simplified version control system from scratch to understand git's internals. The implementation uses SHA-256 hashing (instead of git's SHA-1) and zstd compression (instead of zlib) to store file objects, tree structures, and commits. The project demonstrates how git works as a content-addressable file store, with commits referencing tree objects that contain file hashes. Key features include recursive directory traversal, object compression/decompression, commit generation with parent tracking, and checkout functionality. The hardest part was parsing the custom object formats, which could be improved by using structured formats like JSON or YAML.

   77

   4
5. 5
   Article

   Hacker News·15w

   Introducing Lix: A universal version control system

   Lix is a universal version control system that can diff any file format, including binary files like Excel, PDF, and DOCX. Unlike Git's line-based diffs, Lix understands file structure and shows semantic changes (e.g., 'price: 10 → 12' instead of 'line 4 changed'). Built on top of SQL databases, it provides version control through virtual tables queryable via SQL. Originally developed for inlang localization infrastructure, Lix addresses Git's limitations with binary and structured files, making it particularly useful for AI agent workflows where changes to non-text files need human review. Currently available for JavaScript with Python, Rust, and Go SDKs planned.

   74

   4
6. 6
   Article

   Planet Python·15w

   The missing 66% of your skillset

   Senior developers need more than just programming language expertise. The ecosystem around Python—including dependency management (uv), Git workflows, testing (pytest), quality control (Ruff, type checkers), CI/CD automation (GitHub Actions), deployment (Docker, Cloud), and CLI proficiency (Makefiles)—comprises roughly two-thirds of professional skillset. Mastering these tools differentiates engineers from scripters and helps developers escape tutorial hell.

   70

   1
7. 7
   Article

   RUBYLAND·16w

   How I Read A Pull Request

   A systematic approach to reviewing pull requests using the journalist's 5 Ws and H framework. The process covers when to review (start of day, between meetings, after submitting your own PR), what to look for based on PR intent, understanding your motivation as a reviewer, considering the author and audience, and a specific reading order: title/description first, then tests (test-driven review), followed by implementation alphabetically, and finally a big-picture pass to verify goals and overall structure.

   70

   9
8. 8
   Article

   Lobsters·17w

   How I use Jujutsu

   Jujutsu (JJ) is a version control system that uses Git as a backend but offers a different mental model. Unlike Git, JJ has no staging area—changes are automatically tracked, and you create commits first, then fill them with changes. The workflow emphasizes easy manipulation of commits through commands like rebase, squash, split, and edit. JJ maintains an immutable operation log that enables safe experimentation with undo/redo capabilities. It uses bookmarks instead of branches and integrates seamlessly with Git remotes, allowing teams to use Git while individuals use JJ. The author shares their most-used commands, custom configurations, and workflow patterns developed over three months of daily use.

   42
9. 9
   Article

   daniel.haxx.se·16w

   My first 20,000 curl commits

   Daniel Stenberg, creator of curl, reached his 20,000th commit to the curl repository, representing 53% of all commits in the project. Over 25 years since the first git commit in 1999, he has committed on 59% of all days, averaging 2.1 commits daily. The project now has 1,431 contributors total, with 16 having made over 100 commits. Stenberg's share of total commits has been gradually decreasing as more contributors join, which he views positively. At his current pace of 800 commits per year, he projects reaching 30,000 commits around 2038.

   40

   5
10. 10
    Article

    Metadata·15w

    Welcome to Town Al-Gasr

    A satirical allegory about distributed systems and autonomous agents gone wrong. Through the fictional town of Al-Gasr, the piece critiques common anti-patterns in system design: multiple sources of truth, lack of testing disguised as confidence, political decision-making over engineering principles, and eventual consistency taken to absurd extremes. The narrative lampoons organizational dysfunction, where ministries supervise each other in circles, failures are rebranded as victories, and the system maintains three simultaneous leaders for 'high availability.' It's a cautionary tale about what happens when governance, accountability, and technical rigor collapse in autonomous systems.

    29

    2
11. 11
    Article

    Cursor·17w

    Best practices for coding with agents · Cursor

    Cursor's coding agents can autonomously complete multi-file refactors and iterate until tests pass. Effective usage requires planning before coding (using Plan Mode), managing context strategically, and customizing behavior through Rules (static instructions) and Skills (dynamic capabilities with hooks). Key workflows include test-driven development, parallel agent execution across worktrees, cloud agents for delegated tasks, and Debug Mode for complex bugs. Success depends on writing specific prompts, providing verifiable goals through tests and linters, and carefully reviewing AI-generated code.

    27
12. 12
    Article

    The New Stack·18w

    Linus Torvalds Gets Candid About Windows, Workflows, and AI

    Linus Torvalds discusses his low-stress workflow managing Linux development, crediting a predictable 20-year-evolved process built around Git and consistent release schedules. He shares his friendly view of Microsoft's shift to cloud services running Linux, expresses confidence in Linux's thousand-person development community, and addresses AI's role in programming. While acknowledging AI as both a bubble and transformative tool, he believes it will enhance productivity rather than replace programmers, with AI-assisted code reviews expected to integrate into Linux kernel development soon. He maintains compilers remain the biggest historical productivity gain in programming.

    19

    3
13. 13
    Article

    Atomic Spin·17w

    How to Get a Job Without An Internship

    Getting a developer job without an internship is achievable by showcasing transferable skills from any work experience, building personal projects with good Git practices, attending career fairs and meetups, and maintaining an active LinkedIn presence. The key is demonstrating you can work well with others, manage time effectively, and show up consistently—the same attributes internships convey to recruiters.

    16
14. 14
    Video

    Google for Developers·15w

    Developer jargon IRL be like…

    A humorous take on developer terminology used in everyday situations, playing on the double meaning of 'push' as both a physical action and a Git command for uploading code changes to a repository.

    15

    3
15. 15
    Article

    Lobsters·18w

    How Github monopoly is destroying the open source ecosystem

    A university professor teaching open source strategies discovered that 237 out of 238 students contributed to GitHub-hosted projects despite being taught about alternatives like GitLab, Codeberg, and Sourcehut. After being temporarily blocked from GitHub while grading, the professor realized students weren't just choosing GitHub projects—they couldn't imagine looking elsewhere. The centralization has made non-GitHub projects invisible to new developers. The solution: requiring students to contribute to projects they actually use rather than randomly browsing GitHub.

    13

    1
16. 16
    Article

    .NET Blog·17w

    How We Synchronize .NET’s Virtual Monorepo

    The .NET team built a Virtual Monolithic Repository (VMR) that aggregates source code from dozens of standalone repositories into a single git repository for unified builds. The VMR uses a custom two-way synchronization algorithm based on git patches to keep changes flowing between product repositories and the monorepo. The synchronization evolved through three stages: tarball-based Source Build, read-only VMR-lite with one-way sync, and finally a writable VMR with bidirectional flow. The team encountered challenges with conflicting changes, branch lifecycle mismatches, and metadata corruption, ultimately settling on a rebase-based approach that handles conflicts interactively. This infrastructure now powers .NET SDK builds starting from .NET 10 Preview 4.

    12
17. 17
    Video

    TechWorld with Nana·17w

    3 Git Workflows Every Developer Should Know (And When to Use Each)

    Git workflows have evolved significantly over the past decade to match modern deployment practices. Git Flow, once the industry standard, uses multiple long-lived branches (main, develop, feature, release, hotfix) and works well for versioned software like mobile apps but adds overhead for continuous delivery. GitHub Flow simplifies this with a single main branch that's always deployable, making it ideal for web applications with frequent deployments. Trunk-based development represents the current best practice for high-performing teams, where developers commit directly to main (or use very short-lived branches) and rely on feature flags, extensive automated testing, and CI/CD pipelines to maintain stability. The evolution reflects improvements in tooling—automated testing, CI/CD, and feature management—that make faster integration possible. Teams often use hybrid approaches, and the right choice depends on your product type, team maturity, test coverage, and deployment frequency.

    11
18. 18
    Article

    ByteByteGo·14w

    EP200: HTTP/2 over TCP vs HTTP/3 over QUIC

    HTTP/3 solves TCP head-of-line blocking by moving multiplexing from the application layer into the transport layer using QUIC over UDP. While HTTP/2 multiplexes streams over a single TCP connection (causing all streams to block when one packet is lost), HTTP/3 gives each stream independent ordering and recovery. The newsletter also covers Cursor's agentic coding system using MoE, speculative decoding, and context compaction for 4× speed improvements; Git's internal architecture with blobs, trees, commits, and tags stored in the .git directory; NAT's port mapping mechanism for sharing public IPs; and building computer vision apps with Ring APIs.

    10