awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
xirong avatar

xirong/my-git

0
View on GitHub↗
7,396 stars·2,490 forks·Python·MIT·34 viewsgithub.com/xirong/my-git↗

My Git

my-git is a comprehensive framework and reference guide for Git version control administration, repository governance, and software release management. It provides a structured approach to managing the software development lifecycle, from initial feature branching to final production deployment.

The project distinguishes itself through a specialized AI-assisted development framework. This includes workflows for managing AI-generated code via automated diff reviews, intent-based commit splitting, and governance models for multi-agent coordination and session isolation using worktrees.

The codebase covers a broad surface of engineering practices, including CI/CD pipeline automation, enterprise repository governance, and advanced recovery procedures for restoring lost commits or purging sensitive data. It further details collaboration patterns such as trunk-based development, stacked pull requests, and tiered approval systems.

The repository serves as a technical reference and instructional manual for implementing standardized branching strategies and repository security policies.

Features

  • AI Assisted Development - Provides a specialized framework for managing AI-generated code via stacked pull requests, automated diff reviews, and agent governance.
  • Repository Governance Standards - Provide standards for branch protection and release management to maintain stability and security.
  • Worktree Session Isolation - Uses Git worktrees to create separate directory instances for different AI tasks to prevent file overwrites.
  • Git-Integrated AI Workspaces - Optimizes the development lifecycle by applying strategies for assisted reviews and commit splitting within Git workflows.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI
  • AI Code Reviewers - Analyzes code diffs to isolate relevant changes and split commits by intent to ensure software quality.
  • AI Development Workflows - Defines Git practices and review workflows for managing AI-generated code via stacked pull requests and governance.
  • AI Agent Prompting Instructions - Defines machine-readable instructions and constraints to standardize the behavior and environment setup of AI agents.
  • Peer Review Enforcement - Implements governance policies that mandate specific human reviews and owner approvals before merging code.
  • Repository - Establishes branch protection and organizational rulesets to secure the main codebase.
  • Branch Management - Offers a framework for managing local and remote branches, including history rewriting via rebasing and stashing.
  • Branch Permission Management - Prevent direct pushes to critical branches and enforce the use of short-lived feature branches.
  • Worktree Managers - Checks out multiple branches into separate directories to enable simultaneous development and multi-agent execution.
  • Review Pipeline Sequences - Sequence self-review, automated scanning, and human judgment to ensure architectural alignment and risk acceptance.
  • Branching Strategies - Provides a detailed guide on implementing industry-standard branching strategies like Trunk-Based Development, Gitflow, and GitHub Flow.
  • Branching Workflows - Adopt standardized version control strategies to manage feature isolation and releases.
  • Change Tracking - Implements systems for auditing and tracking the history of modifications to identify the purpose and timing of changes.
  • AI-Generated Code Analysis - Evaluates AI code changes by verifying intent, checking behavioral boundaries, and identifying risk signals.
  • Behavioral Risk Scanning - Scans diffs using specific prompts to identify behavioral regressions and compatibility risks in AI-generated code.
  • Code Review Frameworks - Evaluate pull requests using a structured sequence of checks covering goals, behavioral changes, and security risks.
  • Code Review Practices - Apply systematic review processes, including review categories and standards, to maintain long-term code health.
  • Pipeline Configurations - Integrate branch protection and merge queues to maintain main branch stability in high-volume environments.
  • Commit Recording - Provides low-level operations for recording staged changes into the local project history with author metadata.
  • Developer Productivity - Optimizes developer efficiency through the use of Git worktrees for parallel tasks and advanced history recovery.
  • AI Merge Governance - Prevents AI-generated code from merging without human approval and enforced code owner reviews.
  • Contribution Templates - Establish templates for pull requests, issue reports, and commit messages to maintain consistent communication across teams.
  • Local Version Control Basics - Offers foundational instructions for tracking file changes and recording history using local version control.
  • Parallel Workspace Management - Implements a system for managing multiple simultaneous branches via separate directories to enable parallel development.
  • Staging and Commit Interfaces - Provides a structured workflow for staging code modifications and recording them with descriptive commit messages.
  • Git Collaboration Workflows - Offers a comprehensive manual for managing version control, branching strategies, and collaboration patterns.
  • Governance Standards - Maintain engineering standards through defined workflows, branch protection, and ownership assignments.
  • Organizational Policy Enforcement - Implements unified rules across multiple repositories to prohibit force-pushing and ensure consistent branch protection.
  • Temporary Work Storage - Save uncommitted changes to a temporary storage area to switch to urgent tasks.
  • Repository Governance Tools - Enforces consistent naming conventions, push behaviors, and security baselines across multiple repositories.
  • Automated Commit Splitting - Breaks down massive AI-generated changes into smaller, logical commits to improve human review accuracy.
  • Intent-Based Splitting - Divides massive automated changes into smaller logical units based on functional categories for human verification.
  • Version Control Workflows - Organize feature development, code reviews, and merges using established patterns like GitHub Flow or Trunk-Based Development.
  • CI/CD Pipeline Integrations - Integrates automated quality checks, linting, and security scanning directly into the pull request and deployment process.
  • AI Generation Verifications - Utilizes structured checklists as quality gates to evaluate security risks and maintainability of AI-generated code.
  • Branch Merging Strategies - Defines standardized methods and workflows for integrating changes from different development branches.
  • Branch Protections - Secures critical branches using mandatory status checks and push restrictions to maintain mainline stability.
  • Branch-Based Isolation - Establishes the practice of using separate branches to isolate features and experiments from the main codebase.
  • Feature Branch Initializations - Provides a standardized process for initializing feature branches to ensure a clean starting state.
  • Staging Areas - Details the use of staging areas to prepare and group specific modifications before committing.
  • Versioned Snapshotting - Defines the process of staging specific modifications and recording them as permanent project snapshots.
  • Branch and Tag Permissions - Control the creation, deletion, and updating of branches and tags to prohibit force pushes.
  • AI-Generated Code Validation - Validates AI-authored changes by requiring original intent documentation and manual verification of modified files.
  • Enterprise Repository Security - Establishes engineering standards through unified rulesets, code ownership, and organizational branch protection.
  • AI Agent Permissions - Defines controls and minimum permissions for autonomous AI agents using branch prefixes and scoped access.
  • Secret Security - Provides best practices and utilities for scanning repositories for sensitive data and securing credentials.
  • Diff Review Interfaces - Provides a centralized diff review interface for consolidating and verifying changes proposed by multiple AI agents.
  • Intent-Based Commit Splitting - Implements a workflow to split massive automated changes into small, intent-based commits for improved version control.
  • AI Version Control Patterns - Establishes version control patterns specifically for AI-generated code to ensure changes remain reviewable.
  • Approval Governance Models - Implement a tiered approval system where general reviewers assess quality and designated owners verify long-term impact.
  • Automated Risk Scanning - Analyzes code diffs using predefined prompts to identify behavioral regressions and security vulnerabilities.
  • Collaborative Workflows - Coordinate the sequence from issue creation to deployment to ensure stable software delivery.
  • AI-Assisted Development - Implements a comprehensive framework for integrating AI agents into the development lifecycle using automated reviews and commit splitting.
  • Release Branching Strategies - Select a branching model based on team size and release needs to organize environment-based deployments.
  • Git Version Control Standards - Provides a comprehensive guide for organizing team collaboration using branching strategies, merge queues, and repository protection.
  • Mainline Integration Strategies - Defines structured approaches for integrating task-specific branches into the main line of development.
  • Merge Requirement Governance - Provides guidelines for mandating pull requests, status checks, and linear history for protected branches.
  • Multi-Agent Coordination Frameworks - Uses specialized branching strategies and worktrees to coordinate multiple AI agents developing features in parallel.
  • Production Release Separation - Separate integrated code from live code using a dedicated production branch for validation.
  • Standards & Rule Enforcement - Applies a consistent set of branch and tag rules across an organization to maintain engineering baselines.
  • Release Management - Coordinates versioned deployments using release branches, hotfixes, and automated changelog generation.
  • Release Management Guides - Provides a structured approach to managing versioned releases, hotfixes, and production deployment pipelines.
  • Release Management Strategies - Organize development and urgent hotfixes using distinct branch roles to support fixed release cycles.
  • AI-Powered Reviews - Implements AI-powered reviews to analyze diffs for behavioral risks and security issues before human approval.
  • Automated Code Review - Automates the initial scanning of code diffs to detect bugs and style inconsistencies before human review.
  • AI Agent Integrations - Integrates AI agents and pair-programming tools into the development lifecycle to automate reviews and change management.
  • Coding Guidelines - Defines checklists and template fields for generated code to ensure human verification and tool attribution.
  • Development Environment AI Integrations - Integrates AI-generated code via worktrees and refined diff reviews to manage parallel agent modifications.
  • Code Review Tools - Integrate with platforms to review diffs, behavioral changes, and test sufficiency before merging code.
  • Version Support Branching - Create dedicated stable branches for specific versions to support long-term maintenance and client deployments.
  • Security and Vulnerability Scanning - Includes automated processes to detect leaked secrets, outdated dependencies, and insecure code patterns.
  • Review Guidelines - Establish review guidelines to ensure high-value feedback and prevent pull requests from stalling.
  • Release Change Logs - Provides standards for creating changelogs and release notes with key changes and upgrade instructions.
  • Version Control Undo Operations - Provides instructions for reverting files to previous states and canceling staged changes to recover from errors.
  • Code Slicing - Divides large machine-generated changes into smaller engineering units for better review and rollback.
  • Commit Decomposition Strategies - Break large changes into incremental commits to reduce cognitive load and ensure each change has one goal.
  • Safe Commit Reversals - Provides methods for safely rolling back public commits using inverse commits to avoid history conflicts.
  • Secret-Focused History Analysis - Provides procedures for auditing version history specifically to locate and remove leaked credentials.
  • Dependent Commit Stacks - Represent large features as a dependency graph of small, interdependent commits to maintain review quality.
  • Code Quality and Verification - Defines methods for validating modifications through reproducible tests and explicit manual verification steps.
  • Incremental Release Strategies - Deconstruct long-term developments into incremental merges and use feature flags to control visibility.
  • History Linearization - Enforces a flattened commit timeline through rebasing or squashing to ensure a clean project audit trail.
  • Git Error Recovery - Provides a playbook for moving commits from incorrect branches to intended targets without data loss.
  • Git References - Provides a technical reference for advanced Git operations, including worktrees, reflogs, and history sanitization.
  • Last Commit Undo Operations - Explains how to undo the most recent commit while preserving the working tree changes.
  • Merge Reversions - Provides a structured approach to reverting changes introduced by specific merge commits.
  • Automated Issue Resolvers - Automates the analysis of task tickets to modify code and create pull requests for small fixes.
  • Large Repository Optimizations - Apply techniques to accelerate cloning and checkout in massive codebases to reduce infrastructure bottlenecks.
  • Local-to-Remote Repository Publishing - Details the process of pushing local commits to a remote repository to initiate the pull request and review cycle.
  • Merge Conflict Resolution - Fix discrepancies between competing code changes to successfully merge branches.
  • Automated Reviewer Assignment - Direct pull requests to specific owners based on files changed and enforce approval requirements for high-risk directories.
  • Review Quality Standards - Implement standards for request size and review quality to reduce bottlenecks and improve merge speed.
  • Reference Log Recovery - Explains how to use the Git reference log to recover missing commits and deleted branches.
  • Release Procedure Templates - Create structured templates for release notes and hotfix procedures to manage production deployments and versioning.
  • Force Push Recoveries - Provides a workflow to identify and restore the correct commit after a destructive remote force-push.
  • Remote Branch Restorations - Offers techniques to restore remote branch states after accidental deletions caused by force-pushes.
  • Remote Repository Synchronization - Guides the connection and synchronization of local repositories with remote hosting services.
  • Shallow Cloning - Explains the use of shallow, partial, and sparse checkouts to optimize repository retrieval and disk usage.
  • Repository Performance Optimizations - Applies specialized practices to reduce time spent on cloning and checking out large repositories.
  • Uncommitted Change Reversions - Provides guidance on discarding local modifications and reverting files to their last committed state.
  • Versioning Mistake Recoveries - Outlines how to restore lost commits and correct mistakes like incorrect resets.
  • Version Control Recovery Playbooks - Provides a playbook for resolving merge conflicts, recovering lost commits, and scrubbing secrets from history.
  • Commit Cherry Picking Tools - Details the use of cherry-picking to transfer specific commits between branches.
  • Work Stashing - Details the use of stashing to temporarily store uncommitted changes and clear the working directory.
  • Working Tree Restorations - Provides methods for restoring files in the working directory to their last committed state.
  • Automated Merge Queues - Verifies the combined state of multiple pending changes as a group to prevent regressions in high-volume environments.
  • Integration Stability Verification - Uses required checks and merge queues to validate that the main branch remains stable after merging.
  • CI Workflow Automations - Develops reusable workflows and configuration-as-code strategies to automate testing and deployment within the PR process.
  • Change Rollback Mechanisms - Documents strategies for reversing changes using Git reverts and data compensation plans.
  • Security Scanning Integrations - Integrates vulnerability and secret scanning into the push and pull request stages of the pipeline.
  • Auditability Workflows - Track configuration and infrastructure changes through pull requests and peer reviews to ensure auditability.
  • Emergency Hotfix Execution - Provides a structured approach to deploying urgent production fixes with mandatory rollback plans.
  • Trunk-Based Versioning Workflows - Merge small and frequent updates into a single branch to enable large-scale collaboration and faster integration.
  • Review Feedback Classifiers - Categorize comments into blocking, suggestion, or optional levels to distinguish critical issues from stylistic preferences.
  • Merge Queues - Verify that multiple requests pass integration as a combined group before merging into the main branch.
  • Release Managers - Creates traceable and rollback-capable workflows using automated checks to streamline software deployment.
  • Release Pipeline Establishment - Integrates commit linking, manual approval checkpoints, and post-release verification into the deployment process.
  • Release Tracking - Ensures deployments are explainable through the use of trackable versions, tags, and release notes.
  • Software Release Orchestration - Coordinates release windows, emergency hotfixes, and the flow of code from version control to deployment.
  • Local-Remote Branch Synchronizers - Describes the process of synchronizing local branches with their remote counterparts via fetch and push.
  • Mainline Synchronizations - Details the process of synchronizing working branches with the latest main codebase to prevent integration conflicts.
  • Commit History Management - Details techniques for cleaning and organizing commit history through squashing and message modification.
  • Data Recovery Procedures - Provides detailed procedures for restoring lost commits and files using internal version control logs.
  • History Purging - Provides utilities for the permanent removal of sensitive files or secrets from the entire commit history.
  • Git Command Snippets - Catalog essential commands and practical patterns to increase efficiency when interacting with a version control system.
  • Change Reversion - Implements strategies for undoing committed changes on shared branches to maintain a linear history.
  • Quality Standards - Standardize pull requests by enforcing single-problem focus, clear behavioral titles, and detailed risk descriptions.
  • Stacked Pull Request Managers - Decomposes large feature sets into a dependency graph of small interdependent pull requests to maintain review quality.
  • Implementation Strategies - Organize large features into a sequence of dependent, small pull requests to maintain reviewability.
  • Code Reviewer Assignment - Assign specific users or teams to directories using ownership files to automate reviewer assignments.
  • Credential Leak Prevention - Provides mechanisms to detect and block the accidental exposure of secrets during the push phase.
  • Repository Path Protections - Limit rules and protections to specific file paths or metadata to control access to sensitive code.
  • Environment-Scoped Secret Management - Implements branch-based security policies to isolate sensitive deployment credentials from AI-generated code.
  • Secret Scrubbing - Provides procedures for scrubbing compromised credentials from the commit history using filtering tools.
  • Sensitive Data Purging - Provides specialized methods for the permanent deletion of secrets and credentials from the entire commit graph.
  • AI Assisted Code Auditing - Inspects automated contributions to detect silent behavioral changes and superficial test coverage.
  • Change Volume Management - Provides a system to review, split, and verify large volumes of AI-generated updates to reduce integration risks.
  • Tiered Approval Systems - Implements a permission system where general reviewers assess quality and designated owners verify architectural impact.
  • Change Decompositions - Break oversized updates into smaller units like refactoring, behavioral changes, and documentation to reduce risk.
  • Automated Refactoring Workflows - Routes AI-generated or script-based batch changes through standard collaboration workflows and rate-limited merges.
  • Configuration Validation - Run automated checks on formats and semantics during the pull request process to prevent deployment risks.
  • Input Standardization - Use predefined templates for pull requests and issues to ensure authors provide necessary context and evidence.
  • Open Source Governance - Structure the contribution process using RFC models, maintainer trees, and two-stage review systems.
  • Standardized Metadata Templates - Provide reusable templates for pull requests, issues, and AI reviews to ensure consistent documentation quality.
  • Project Progression Tracking - Provides a methodology for reviewing commit logs and history to understand overall project progression.
  • Public History Corrections - Provides a playbook for correcting errors on shared branches using revert operations to avoid rewriting history.
  • Repository Auditing - Provides techniques for inspecting commit history and reference logs to diagnose repository issues.
  • Model Selection Guides - Guide the selection of collaboration models like Gitflow or GitHub Flow to coordinate team contributions.
  • VCS Error Resolution Playbooks - Provides a comprehensive playbook for undoing mistakes, recovering lost commits, and scrubbing secrets.
  • Quality Gates - Runs linting, unit tests, and builds automatically on every change to verify minimum quality standards.
  • Merge Change Validations - Provides a framework for validating that branches are clean of secrets and build artifacts before integration.
  • Git Tutorials and Guides - Comprehensive collection of learning materials for version control.
  • Version Control - Curated collection of Git commands and best practices.
  • Git Resources - Collection of Git learning materials and resources.

    • Star history

    Star history chart for xirong/my-gitStar history chart for xirong/my-git

    How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

    Frequently asked questions

    What does xirong/my-git do?

    my-git is a comprehensive framework and reference guide for Git version control administration, repository governance, and software release management. It provides a structured approach to managing the software development lifecycle, from initial feature branching to final production deployment.

    What are the main features of xirong/my-git?

    The main features of xirong/my-git are: AI Assisted Development, Repository Governance Standards, Worktree Session Isolation, Git-Integrated AI Workspaces, AI Code Reviewers, AI Development Workflows, AI Agent Prompting Instructions, Peer Review Enforcement.

    Which projects share features with xirong/my-git?

    Projects with overlapping indexed features include: isomorphic-git/isomorphic-git — Isomorphic-git is a full implementation of the Git version control system written in JavaScript. It serves as a… qodo-ai/qodo-cover — Qodo Cover is an engineering governance platform and AI-powered assistant designed for automated code review and unit… anc95/chatgpt-codereview — ChatGPT-CodeReview is an AI-driven code analysis tool and bot that uses a large language model to automatically review… progit/progit2 — This project is a comprehensive educational resource and guide for learning the Git version control system. It serves… awesome-skills/code-review-skill — This project is a specialized instruction set for AI coding agents designed to perform structured, language-specific… missing-semester/missing-semester — The Missing Semester is a free, open-source educational curriculum designed to bridge the gap between theoretical…

    Projects sharing features with My Git

    These projects share indexed features with My Git. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
    • isomorphic-git/isomorphic-gitisomorphic-git avatar

      isomorphic-git/isomorphic-git

      8,259View on GitHub↗

      Isomorphic-git is a full implementation of the Git version control system written in JavaScript. It serves as a programmatic client library that allows developers to perform core version control operations without requiring a system-level Git binary installation. The library is designed as an isomorphic codebase, meaning it runs identically across both client-side web browser environments and server-side Node.js runtimes. It achieves this by using a filesystem-agnostic storage model and a pure JavaScript implementation of the Git core logic and the Smart HTTP protocol. The project covers a c

      JavaScript
      View on GitHub↗8,259
    • qodo-ai/qodo-coverqodo-ai avatar

      qodo-ai/qodo-cover

      5,444View on GitHub↗

      Qodo Cover is an engineering governance platform and AI-powered assistant designed for automated code review and unit test generation. It utilizes an abstract syntax tree codebase knowledge graph to map dependencies and architectural relationships, allowing it to analyze pull requests and enforce organizational coding standards. The system distinguishes itself through a multi-agent analysis pipeline that performs architectural reasoning and identifies bugs beyond the immediate diff. It features a model context protocol server to expose codebase intelligence to external tools and can automatic

      Pythonagentsaitest-automation
      View on GitHub↗5,444
    • anc95/chatgpt-codereviewanc95 avatar

      anc95/ChatGPT-CodeReview

      4,445View on GitHub↗

      ChatGPT-CodeReview is an AI-driven code analysis tool and bot that uses a large language model to automatically review pull request diffs and post feedback on code changes. It functions as a system for detecting bugs and suggesting improvements in source code. The tool provides a containerized runtime for deployment as a background process or through a GitHub Action. Users can customize the analysis behavior, style, and technical depth by adjusting model parameters and system prompts. The system handles automated code review workflows by triggering analysis via webhooks and CI pipelines, upd

      JavaScript
      View on GitHub↗4,445
    • progit/progit2progit avatar

      progit/progit2

      6,522View on GitHub↗

      This project is a comprehensive educational resource and guide for learning the Git version control system. It serves as a technical documentation source for a textbook that explains the fundamentals, advanced workflows, and internal architecture of Git. The project is structured as a multi-format e-book, with source files designed to be compiled into various digital publication formats, including HTML, PDF, EPUB, and Mobi. It utilizes a dedicated build pipeline to generate and validate these documents. The content covers a broad range of version control capabilities, including history manip

      CSS
      View on GitHub↗6,522
    Compare all 30 related projects→