Git Workflow plugins

Reduce Claude Code token consumption by ~75% using ultra-compressed communication and delegation to compressed-output subagents for code review, editing, and exploration.

Persists Claude Code context across sessions using a local memory database, enabling the agent to recall past work, decisions, and bugfixes. Includes tools for codebase exploration, architectural analysis, GitHub triage, release automation, and project timeline digests.

Run comprehensive PR reviews using specialized agents that analyze code quality, test coverage, error handling, type design, comment accuracy, and code simplification, producing a categorized issues summary with 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.

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.

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.

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.

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

Run an autonomous engineering pipeline from ideation through PR: brainstorm requirements, plan, implement, simplify, review, test, commit, push, open PR, and watch CI until green. Also debug errors, run QA passes, generate release notes and marketing copy, and compound team knowledge with structured solution docs.

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.

Enhances AI-assisted development for Chinese-speaking teams by providing structured workflows for planning, coding, testing, debugging, code review, and Git management, all adapted to Chinese conventions and domestic platforms.

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 and fix workflows for Git branches using roborev — request design or security reviews, automatically fix failing findings, and run iterative review-fix loops until passing.

Parallelize Claude Code tasks across isolated git worktrees with tmux integration, managing creation, monitoring, and merging of worktree agents via workmux CLI.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

Automate comprehensive PR reviews by running specialized AI agents that analyze code quality, test coverage, error handling, type design, and comments, then produce a categorized summary of issues and strengths.

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.

Understand your codebase's architecture, ownership, risk hotspots, and technical debt through layered indexing (graph, git, docs, decisions, health) and nine MCP tools — enabling informed refactoring, pre-merge risk scoring, and dead code cleanup.

Extends Claude Code with a modular framework of agents, commands, and skills to automate test-driven development, code review, security scanning, dependency management, documentation sync, git workflows, and build fixing across multiple languages.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Orchestrate AI coding agents through a structured RPI (Research-Plan-Implement-Validate) lifecycle with persistent knowledge flywheel, git-backed task graphs, multi-agent coordination, and automated validation gates for quality, security, and drift detection.

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.

Deliver end-to-end product management workflows through structured skill chain execution — from customer discovery, problem framing, and sprint facilitation to release management, governance audits, and stakeholder communication, all orchestrated by sub-agents with human-in-the-loop checkpoints.

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.

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 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.

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 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.

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.

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 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.

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.

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.

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.

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.

Automates the full GitHub development workflow — creating conventional commits from staged changes, generating and reviewing pull requests, resolving PR review comments, and managing GitHub CLI authentication — all through agent-driven commands and slash commands.

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.

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 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.

Generate, audit, and commit Foldkit apps with TypeScript and Effect — scaffold programs from natural language, validate architecture and conventions, and create Conventional Commits with changeset enforcement.

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.

Manage Claude Code sessions with a taxonomy-structured, git-versioned memory system that enables branch isolation for different contexts, path-based recall of past interactions, and time-travel auditing for debugging and reproducibility.

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.

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.

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.

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 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 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 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 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.

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.

Fetch GitHub issue details via URL or ID to generate a structured technical specification, including requirements summary, implementation approach, detailed step-by-step plan, test plan, files to modify, and success criteria for efficient task planning.

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 guided steps for implementation and testing, then auto-commit changes, push the branch, and open a linked pull request ready for review and merge.

Generate detailed implementation plans from GitHub issues, outlining files to change, project overviews, function signatures with descriptions, and test cases with coverage targets to kickstart coding workflows.

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 full pull request creation from local changes: generate new branch, format files with Biome, split into logical commits with descriptive messages, push to remote, and submit PR complete with summary and test plan.

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.

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.