Git Workflow plugins

Communicate with Claude Code in an ultra-compressed style that cuts token usage ~75% while preserving technical accuracy, with compressed sub-agents for code review, git commits, file editing, and code exploration.

Automate comprehensive PR reviews with specialized agents that analyze code quality, test coverage, error handling, type design, comments, and simplification, producing a categorized issues summary with critical findings, suggestions, strengths, and an action plan.

Automate multi-agent code reviews on GitHub pull requests, auditing CLAUDE.md files, detecting bugs, analyzing git history and prior PRs, reviewing code comments, and scoring issues by confidence level to prioritize fixes.

Manage Python projects via structured tracks for features, bugs, refactors: initialize context artifacts like product.md and tech-stack.md, create detailed specs and phased plans, implement tasks with strict TDD workflow using pytest coverage and git commits, monitor status, revert commits, and validate artifacts for consistency.

Enforce code quality and security checks after every change, automate git commits and pushes with conventional messages, generate structured task checklists, guide incremental refactoring, and apply systematic debugging—all within Claude Code.

Automate Git workflows by cleaning up gone remote branches and worktrees, intelligently staging changes with generated commit messages, and creating new feature branches with pushes and GitHub PRs via simple commands.

Automates OSS maintenance workflows: changelog generation, conventional commits, PR management, structured documentation, advanced Git operations, and code review handling.

Guards bash commands with version control checks so operations only run inside a tracked directory, and auto-detects VCS/project config on session start.

Manage GitLab projects by accessing repositories, creating and reviewing merge requests, monitoring CI/CD pipelines, handling issues, and updating wikis through remote API integration with a personal access token.

Generate self-contained HTML visual explainers for code diff reviews, implementation plans, slide decks, diagrams, and project recaps — with factual verification against git history and one-click deployment to Vercel.

Perform AI-powered code reviews on GitHub and GitLab pull requests by connecting to Greptile API. View and resolve review comments directly within Claude Code. Query indexed repositories for code search, codebase Q&A, and context retrieval to accelerate development workflows.

Provides 20 Chinese-language skills for Claude Code and compatible AI coding tools, enabling structured brainstorming, TDD, debugging, code review, git workflows, MCP server development, and multi-agent task execution with Chinese-language conventions for commits, documentation, and team communication.

Use AI to generate conventional commit messages from staged Git changes. Analyzes code diffs to classify updates as feat, fix, refactor, chore, or docs, then crafts standardized messages with proper prefixes for consistent Git history, changelogs, and automation compatibility.

Execute 175 slash commands to automate git workflows like branching/PR creation/issue syncing with Linear, code quality reviews/refactors/fixes, test generation/setup/coverage, CI/CD pipelines, security/performance audits, documentation generation, project scaffolding/setup, and deployments across JS/TS/Python/Go/Rust/Svelte stacks.

Analyze local Git branches and worktrees to categorize them as merged, squash-merged, superseded, or active work; group related branches; review and safely delete unnecessary ones with user approval before any changes.

Research any topic via web search, analyze findings, and automatically create structured GitHub issues with titles, summaries, key points, recommendations, source links, labels, and assignees. Turn investigations into trackable tickets for security vulnerabilities, APIs, features, or technical explorations using skills or CLI commands.

Generate AI-powered conventional commit messages from staged Git changes: auto-classifies feat/fix/docs types, detects scopes/breaking changes, matches project commit history style. Preview the message, confirm, and auto-commit in one workflow.

Automate code review workflows: request design or security reviews for commits or branches, apply suggested fixes inline, and iterate review-fix loops until passing.

Run a terminal dashboard for GitHub pull requests to monitor status, CI/CD progress bars, bot comments, file changes, and merge PRs directly with squash or rebase options.

Transform calendar events into automated meeting briefings, standup notes, and workflows enriched with git commits and PR context. Process ICS files, JSON feeds, or manual input to streamline prep for meetings and standups.

Generate AI-powered conventional commit messages by analyzing your current git diff, select from concise, detailed, or comprehensive options, and execute the git commit instantly.

Orchestrate parallel agent workflows across isolated tmux-managed git worktrees: spawn agents, monitor their status as tmux window names update in real time, and merge worktree branches with conflict resolution.

Integrate GitHub Spec-Kit CLI into a 7-phase constitution-based spec-driven development workflow for features, managing .specify/specs/ directories through Constitution, Specify, Clarify, Plan, Tasks, Analyze, and Implement phases.

Set up production-ready Unity projects in one slash command, creating industry-standard folder structures, installing URP and Input System packages, applying optimized settings, adding core C# scripts and editor tools, plus Git configuration.

Claude Code skills for multi-agent workflows: visual planning, autonomous execution with minimal interruptions, documentation-first implementation, cross-agent review and merging, usage budget management, and interactive PR/commit recaps

Automate aiobotocore GitHub workflows for botocore syncing: bump versions with pyproject.toml bounds and CHANGES entries, classify bumps and override drifts, port sync tests to async pytest counterparts, create PRs with templates and checklists, synthesize PR reviews into asked/done/outstanding action plans, detect Pyright errors, and post inline code quality findings.

Review diffs, files, and documents with inline annotations in a terminal TUI overlay for git, hg, and jj repositories

Automate Git workflows with slash commands to create conventional commits with pre-checks, generate PRs from changes, fix GitHub issues/PR comments automatically, manage worktrees for open PRs, update branch names descriptively, and review PRs from multiple perspectives.

Automate team workflows using slash commands to triage GitHub issues, balance workloads, plan sprints, generate standup reports, analyze retrospectives, map dependencies, estimate tasks, review architecture, and migrate projects between GitHub and Linear, pulling insights from git history and team data.

Write, review, and submit Strapi documentation from within Claude Code — research coverage gaps, generate outlines and pages, run style/code/pedagogical audits, then branch, commit, push, and open a PR with a Vercel preview link.

Run iterative development loops where Claude implements plans from structured Markdown and Codex independently reviews progress, with web research and second opinions from Gemini or Codex, enforcing acceptance criteria and git workflow until quality goals are met.

Run slash commands to systematically debug errors, analyze code quality/security/performance in files/directories/repos, intelligently refactor code, safely clean git branches, explore architecture scenarios, generate work logs from commits, and convert issues to tasks.

Set up CI/CD pipelines for GitHub Actions, GitLab, or Jenkins; containerize apps with Dockerfiles, docker-compose, and Kubernetes manifests; automate changelogs in Keep a Changelog format; prepare semantic releases; deploy hotfixes; and rollback deployments via slash commands.

Automate full pull request creation in one command: generate a new branch from unstaged changes, format files with Biome, split into logical commits with descriptive messages, push to remote, and submit the PR complete with summary and test plan.

Run comprehensive PR reviews using specialized agents that analyze code quality, test coverage, error handling, type design, comments, and simplification. Produces categorized issue summaries with critical, important, suggestions, strengths, and action plans.

Manage projects end-to-end with Product as Code (PAC) slash commands: initialize repos with framework setups, generate JTBD/PRD/PRP docs, create/track epics/tickets/status in YAML, validate structure, run health checks, simulate timelines, track milestones from GitHub/Linear, manage todos, and sync to Linear.

Review recent Git changes for code quality, security, performance, testing, and documentation issues. Get actionable feedback with line-by-line comments to catch problems early in your workflow.

Generate conventional git commits with descriptive messages and emojis by analyzing changes, running pre-commit checks, auto-staging files, and suggesting atomic splits to follow project standards.

Automate conventional Git commits with AI-generated messages and optional co-authoring, push to remotes with auth retries, configure user identities and project scopes from git-agent, and update .gitignore with project-specific rules while preserving customs.

Orchestrate Claude Code workflows with agent teams, custom skills, and event-driven hooks — automate build/test cycles, security reviews, code generation, git operations, and project planning from within Claude Code.

Operate a solo dev company with AI agents: delegate research, development, marketing, analysis tasks; triage brain dumps via Eisenhower matrix; manage projects/goals in Mission Control JSONs; generate daily/weekly plans, brainstorm ideas, plan/ship features with git integration.

Bidirectionally sync GitHub issues and pull requests with Linear tasks, bulk import issues, resolve conflicts interactively or via strategies, set up automation workflows with GitHub Actions and webhooks, manage cross-references, and monitor sync health and performance.

Automate Red-Green-Refactor TDD cycles: select first unchecked tasks from todo.md, plan using CLAUDE.md guidance, create git branches, implement code, check off completed tasks, and commit changes to streamline repetitive development workflows.

Generate and update project documentation via slash commands: create architecture docs with C4/Mermaid, onboarding/migration/troubleshooting guides, dbt model YAML, Keep a Changelog entries; analyze git changes/GitHub issues for explanations and README updates.

Orchestrate complex developer task workflows via CLI commands: plan executions with agents, search and manage tasks across statuses, sync status with git commits, log progress to Jira/GitHub/Obsidian, generate reports, and resume interrupted orchestrations.

Prime Claude with comprehensive project context via slash commands that load READMEs, git-tracked files excluding ignores, directory structures, and specialized docs, while auto-building markdown reference summaries in /ref for optimized AI-assisted development workflows.

Manage Git worktrees for parallel development: create isolated worktrees on new branches outside the main repo without stashing changes, and clean up finished ones by removing safe (merged, no uncommitted changes) directories, pruning references, and reporting removed/kept items.

Execute end-to-end Git Flow workflows by starting feature, bugfix, or hotfix branches from clean up-to-date bases with pushes, GitHub issue linking, and next-step guidance, then finishing them through merges to develop/main, checks, PR creation, optional auto-merges/tags, and branch cleanup with completion summaries.

Automatically implements fixes for GitHub PR review comments using context-aware patches: runs tests on changes, commits and pushes to the branch, then outputs a summary of the PR status, addressed comments, and modifications.

Generate customer-friendly changelogs from git commit history by scanning repositories, categorizing changes into features fixes and more, filtering noise like merge commits, and rephrasing technical details into clear release notes for users.

Automate end-to-end bug fixing on GitHub: provide a bug description to instantly create a tracked issue, spin up a dedicated feature branch, receive step-by-step guidance to implement and test the fix, then auto-commit, push, and open a linked pull request ready for review and merge.

Run structured AI coding sessions with permanent progress gates, knowledge extraction, multi-agent orchestration, and automated validation loops that compound learnings across sessions.

Follow Spec Driven Development workflows to build features systematically: generate testable specs from descriptions, create dependency-ordered task plans, analyze artifacts for quality and consistency, execute phased TDD implementations with progress tracking, and convert tasks to GitHub issues.

Index a codebase into five knowledge layers (graph, git, docs, decisions, code health) and use MCP tools to query architecture, assess code health, identify dead code, score defect risk, and manage architectural decisions — enabling safe refactoring and informed pre-merge review.

Automate GitFlow workflows: start feature, hotfix, and release branches with version bumps and pushes; finish them by running tests, updating changelogs, merging to main/develop, tagging versions, pushing changes, and creating GitHub releases.

Generate intelligent conventional commit messages by semantically analyzing staged Git changes, review them, and auto-commit if approved. Parse Git history since last release to categorize commits, suggest next version, and generate/append Keep a Changelog markdown.

Automate semantic version management by analyzing git changes to bump major/feat/fix versions, update files and CHANGELOG.md, commit, and tag releases. Execute full release workflows: verify CI/CD, generate changelog, create GitHub releases, publish packages, update docs, and notify stakeholders.

Review GitHub pull requests from the CLI with structured analysis for correctness, security, performance, maintainability, and testing coverage. Get a verdict, severity-rated findings table, and summary. Verify quality checklist including clear description, passing CI/tests, no secrets/issues, and up-to-date branch before approving and posting a review comment.

Generate and update CHANGELOG.md files directly from git history by parsing conventional commits. Groups changes by type (feat, fix, etc.) and version, formatting in Keep a Changelog style. Specify ranges with --from and --to flags for targeted releases.

Automates full feature development from spec to PR: create feature branches, implement incrementally with tests and self-review, generate change summaries; or complete partial features by assessing gaps, coding missing pieces, hardening, adding tests/docs, running suites, and reporting status.

Provide a GitHub issue number to automatically fetch details, analyze the problem and root cause, implement a minimal code fix on a new feature branch, create a pull request with 'fixes #N' reference to close it, and receive a summary of changes and modified files.

Rebase your current feature branch onto the latest upstream branch, automatically resolve conflicts, run the full test suite, and get a detailed report on branch status, rebased commits, and resolved conflicts.

Detect affected packages in monorepos from git changes to generate targeted build/test/lint/deploy commands, and synchronize versions across packages by analyzing commits, applying semver bumps, updating deps/lockfiles, generating changelogs, and auto-committing/tags.

Automate advanced git commit workflows: analyze changes to stage safe files, generate conventional commit messages, commit and push to remote branches. Safely amend recent commits by verifying safety, push status, and force-push needs, with detailed output on hash, message, and files.

Generate detailed changelog entries from git commits and merged PRs since the last release tag. Automatically classify changes into categories, craft user-facing descriptions with PR links and contributor credits, and prepend the new section directly to CHANGELOG.md for quick release documentation.

Pinpoint bug-introducing commits via git bisect with automated testing, then run interactive debugging sessions to reproduce runtime issues, identify root causes, apply minimal fixes, verify changes, add tests, and generate structured summaries.

Create structured GitHub issues interactively by prompting for bug/feature/task details, applying templates, labels, milestones, and projects via API. Triage open issues by filtering unlabeled/stale ones, assessing priority/impact, detecting duplicates, suggesting labels/assignees, and generating prioritized backlogs.

After every git commit, automatically prompts Claude to suggest learning exercises based on the commit content, turning version control activity into a skill-building opportunity.

Automate comprehensive pull request reviews from six expert perspectives—product manager, developer, QA, security, DevOps, and UI/UX designer—delivering targeted feedback, issue detection, and actionable improvement suggestions before merging code.

Automate complete PR workflow from commit to production: run pre-flight checks, create PR, monitor CI status and reviews until resolved, merge, deploy to Railway/Vercel/Netlify, perform health checks, and validate.

Automate GitHub project workflows: create structured issues following TDD principles with labels/templates/duplicate checks; generate PRs after git validation, lint/test/build/security scans, and issue linking; resolve issues via isolated worktrees, TDD implementation, quality gates, and auto-closing PRs.

Automate legal document processing, audio/video transcription, web scraping, and case management with a skill suite for OCR, PDF manipulation, contract review, patent drafting, git workflow, and legal research, tailored for Chinese legal professionals.

Work with Power BI Project (PBIP) files, TMDL, and PBIR formats directly — rename cascades, validate project structure, fix semantic model metadata, and edit report JSON schemas in source-controlled repos.

Automates GitHub and Git workflows — commit creation, PR submission, PR review, and review comment resolution — using slash commands and agents that handle staging, branching, conventional commits, and gh CLI operations.

Set up SAP Business Application Studio (BAS) on SAP BTP: create dev spaces and subscriptions, connect to Git repos and external systems via destinations/Cloud Connector, deploy MTA apps to Cloud Foundry, configure Node.js/Java/Python runtimes, manage tasks/CI-CD, and troubleshoot connectivity.

Automate Git-powered coding workflows: generate atomic conventional commits from changes, push to feature branches and create/update PRs, clean merged/stale branches, fetch organized PR comments, generate/update READMEs and changelogs, maintain CLAUDE.md docs, and set up GitHub Actions for Claude Code—all with AI agents for audits.

Sync your local Claude configuration — CLAUDE.md instructions and permissions allowlist — from a GitHub repository, and refresh those instructions into the current conversation context.

Orchestrate full-cycle development for Python, Rust, TypeScript projects: brainstorm ideas into specs and plans, initialize repos with GitHub Actions CI/CD, Makefiles, pre-commit hooks; execute implementations via TDD, progress tracking, checkpoints, and iterative code polishing with multi-LLM war rooms.

Analyze git history to automatically generate detailed changelogs categorizing commits into features, bug fixes, performance optimizations, and more. Produces formatted markdown files with change summaries, impacts, and deployment notes for quick release documentation.

Automatically analyze recent git changes across code files, configs, APIs, and databases to update your CLAUDE.md file, documenting new features and updates while preserving existing core content.

End Claude Code sessions with /wrap: multi-agent pipeline analyzes git status, session history, and logs to propose non-duplicate CLAUDE.md/context.md updates, automation skills/commands, structured TIL learnings, prioritized follow-ups, and executes selected actions like quick commits.

Automate secure Git workflows: scan changes, stage safe files excluding secrets/builds/lockfiles, commit with style-matched messages, push to GitHub, and create PRs, confirming each step with the user while blocking force-pushes.

Automatically find, reproduce, investigate, and fix bugs in your codebase. Default careful mode ensures thorough testing before changes; --fast mode creates a hotfix branch from production, applies minimal fix, and ships a GitHub PR for emergencies.

Align GitHub initiatives with repo data by generating status dashboards, health metrics, and markdown digests from issues/PRs. Enforce standardized release gates via checklists, automate issue creation with templates, closure analysis from commits, and label reorganization into type/priority/effort groups.

Blocks dangerous commands and prevents data leaks by enforcing branch-based restrictions on Edit/Write tool calls and normalizing bash output. Protects secrets with runtime action evaluation and a trust registry across 20 detection rules.

Automate end-to-end maintenance of open-source GitHub repositories: triage issues, review pull requests, analyze contributor activity, generate reports, and propose actions to keep projects healthy.

Orchestrates structured development workflows from idea to PR merge: clarifies ideas, brainstorms and documents designs, creates git branches/worktrees, plans and executes tasks via subagents with TDD, systematic debugging, automated code reviews, verifications, and git integration.

Monitor Claude Code session costs and efficiency in real-time like htop, with breakdowns by git branch or PR, model pricing comparisons, spending analytics for custom periods, interactive web dashboard for trends and history, budget alerts, and CSV/JSON exports.

Automate Git release workflows: inspect commits since the last tag in an interactive, author-aware table with git show details, then create releases via semver bump detection, PR/commit-based changelog generation, preview, tagging, and publishing to GitHub, GitLab, or Gitea.

Automate GitHub PR reviews for architecture, tests, and scope; interactively annotate git diffs, apply AI fixes in feedback loops until approved; enforce concise writing style for issues, PRs, commits, and reviews without AI-speak.

Automate Git-centric development workflows: generate conventional commit messages from changes, prepare PRs with quality gates and self-reviews, fix review feedback across steps from triage to validation, consolidate ephemeral docs into permanent ones, update tests and tutorials, bump versions with changelogs, and manage dependencies in Python/JS/Rust/Go repos.

Use GitHub CLI to create standardized pull requests via a step-by-step guide that enforces title conventions, follows PR templates, applies best practices, and provides copy-paste command examples.

Review recent Git changes for code quality, security, performance, testing, and documentation issues. Receive actionable feedback with line-by-line comments to refine code before merging.

Automate conventional git commits by analyzing changes for descriptive, emoji-prefixed messages that follow project standards, running pre-commit checks, auto-staging files, and suggesting atomic splits for cleaner history.

Automatically analyze GitHub Pull Request suggested changes using gh CLI: categorize comments, plan and apply fixes, test updates, and refresh the PR to resolve reviewer feedback.

Automatically analyze git diffs from main to generate descriptive branch names with semantic prefixes, rename your current branch to enforce naming conventions, and update remote branches seamlessly.