Git Workflow plugins

Switch to caveman mode in Claude Code sessions to slash 75% token usage with terse, accurate technical communication. Delegate to subagents for surgical 1-2 file edits, read-only code location, diff/PR reviews; generate compressed git commits, memory files, review comments, and track token stats via commands.

Equip Claude with 13 targeted skills to run disciplined bug diagnosis loops (reproduce-minimize-hypothesize-instrument-fix-regression-test), prototype designs via throwaway terminal/UI apps, triage and vertically slice GitHub issues, enforce TDD red-green-refactor cycles, generate structured PRDs, grill plans against domain models, and deepen codebase architecture for testability and AI navigation.

Organize complex multi-step projects and research tasks with persistent Markdown files (task_plan.md, findings.md, progress.md) for planning, progress tracking, and knowledge storage. Auto-creates files, recovers context after /clear or across sessions in AI coding assistants like Claude Code, Cursor, Continue. Multilingual: Arabic, German, Spanish, Chinese.

Automate comprehensive PR reviews on git diffs or pull requests using specialized AI agents that analyze code quality, test coverage, error handling, type design, comments, and simplification opportunities. Get categorized issues summary with criticals, importants, suggestions, strengths, and action plan.

Persist compressed memory of Claude Code sessions, codebase reads, Git actions, and PR progress across interactions. Query historical knowledge for priming new sessions, generating phased plans, structural searches, architecture audits, timeline reports, and automating merges or semantic releases.

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 automated linting (ESLint, Ruff), type checking (tsc, mypy), and security audits (npm audit, bandit) after code changes in Node.js/TypeScript/Python projects; debug systematically in four phases; generate atomic task checklists; refactor incrementally with Kaizen principles; auto-stage, commit conventionally, and push to GitHub.

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.

Generate structured PRDs, epics, feature specs, implementation plans with Mermaid diagrams, technical spikes, and GitHub issues from high-level ideas or requirements. Automate task creation, updates, and organization for SaaS projects in TypeScript/Next.js monorepos with Docker deployments.

Maintain open-source repositories with Claude Code skills that generate conventional commits featuring feat/fix types, issue references, and AI co-authorship; produce Markdown READMEs, changelogs, and docs; execute advanced Git operations like interactive rebase, cherry-pick, bisect, and worktrees; conduct structured code reviews; and handle PR creation workflows.

Manage GitHub repositories directly from Claude Code by creating issues, handling pull requests, reviewing code, searching repos, and accessing the full GitHub API via natural language.

Build knowledge graphs from any codebase to visualize architecture, query dependencies and relationships, analyze git diffs/PR impacts, explain files/modules, generate onboarding guides and domain flows, plus interactive dashboard and guided tours.

Query local markdown notes, docs, and knowledge bases using lexical, vector, hybrid, and intent-aware searches via CLI or MCP server to retrieve precise information instantly. Automate end-to-end project releases by validating and updating CHANGELOG.md, installing git hooks, bumping versions in package.json, committing changes, creating tags, pushing to GitHub, and monitoring CI workflows.

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 pages visualizing git diffs, code reviews, implementation plans, project recaps, diagrams, slide decks, and fact-checked docs. Compare plans against codebase, analyze changes with architecture views, and deploy visuals to Vercel for sharing.

Build and maintain a compounding Obsidian wiki vault as Claude's persistent knowledge base: bootstrap vault from description, ingest files/URLs/images/web research, create visual canvases/databases/notes, query answers from vault, lint for issues, roll up summaries, automate git commits across sessions/projects.

Automate Git worktree management for parallel AI agent workflows using Worktrunk CLI integrated with Claude. Create/remove worktrees on session events, track active AI (🤖) and chat (💬) sessions in wt list, generate LLM commit messages, configure project hooks (post-merge, pre-commit), and edit configs via guided prompts.

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.

Run a persistent Letta agent that monitors Claude Code sessions, accumulates context from events like SessionStart and UserPromptSubmit, and delivers proactive guidance or automates GitHub PR creation via hooks on Stop and PreToolUse events.

Run AI code reviews on uncommitted changes, branch diffs, or specific commits using OpenAI Codex CLI or Google Gemini CLI. Analyzes git diffs via bash scripts. Launches bundled Codex MCP server as subprocess for direct LLM tool access.

Orchestrate self-correcting AI coding workflows with multi-agent teams in parallel git worktrees, persistent FTS5-indexed SQLite research wikis, auto-research loops, quality gates, and multi-LLM councils to decompose large refactors, debug issues, build features, and manage sessions across Node.js, Python, Rust, Go projects.

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.

Intercept GitHub URL fetches and curl/wget commands in sessions, redirecting them to your authenticated gh CLI for seamless GitHub API access and operations without manual authentication or tool switching.

Equip Claude Code, Cursor, and 17 similar AI tools with 20 Chinese skills (14 translated + 6 original) to enforce TDD workflows, systematic debugging, design-first planning, Chinese git conventions for Gitee/Coding.net, structured code reviews, parallel multi-agent task execution, and automated verification before commits—tailored for Chinese developers building production code.

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.

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 structured AI-guided SDLC workflows for full feature cycles—from requirements gathering and design reviews to implementation, TDD, testing, code reviews, and refactoring—using persistent project memory for reusable knowledge and specialized AI skills for debugging, security audits, and complexity analysis.

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.

Generate production Go CLIs from OpenAPI specs or API descriptions, then polish for verification, agentically review command outputs, score against benchmarks, regenerate with template updates, run retrospectives for improvements, and publish to a shared GitHub library via automated PRs.

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.

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.

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.

Autonomously execute complex development tasks by generating structured ralphex plans from GitHub/GitLab issues, markdown, or interactive prompts, importing external plans, smart-merging configs, and launching CLI with progress monitoring, mode selection, and iteration limits.

Automate spec-driven development workflows in Claude Code using skills and agents to fix GitHub issues end-to-end, review PRs, generate EARS specs and task lists, orchestrate multi-agent research, create custom slash commands, document breakthroughs, and integrate AI image generation/editing.

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.

Manage Linear issues, projects, teams, milestones, initiatives, and labels from the command line. Create, update, delete, view, and comment on issues; automate workflows with git/jj integration and GraphQL access for terminal-based issue tracking.

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.

Orchestrate parallel AI agents across git worktrees with workmux CLI: spawn tasks, monitor statuses in tmux window names, automate rebases with conflict resolution, commits, PR generation and opening, and multi-agent coordination for merges.

Review unstaged git changes interactively, stage precise intended work with patch mode, split into logical semantic commits, and generate verified Conventional Commits messages for clean, professional git history.

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.

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.

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 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 Sentry-specific development workflows using 25 specialized AI skills and 2 agents: perform code reviews for quality/security/performance in React/Django, create/manage git branches/PRs/commits per conventions, audit vulnerabilities, generate docs/blog posts, optimize prompts, and mentor new engineers on infrastructure.

Decompose feature discussions into kanban tasks on agtx board, spawning git worktrees, branches, and tmux sessions for parallel coding agents to produce reviewable PRs. Brainstorm ideas in guided chats, then sweep outcomes to tasks without leaving the conversation.

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.

Launch iterative RLCR development loops from structured plans: Claude implements code with git commits and progress tracking, while Codex independently reviews for quality, feasibility, and acceptance criteria until completion or max iterations. Includes draft-to-plan refinement, repo validation, PR auto-fixes, and web research.

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.

Enforce SPARV workflow (Specify→Plan→Act→Review→Vault) in git repos: blocks commits without staged Change Manifest or evidence artifacts, warns on pushes to unreachable registries or drifted CCKN, audits Stops for dishonest completion, with bash execution and PreToolUse blocks.

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.

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.

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.

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.

Automate comprehensive PR reviews on git diffs or pull requests using specialized agents that analyze code quality, test coverage, error handling, type design, comments, and simplification. Receive categorized summaries of critical issues, important fixes, suggestions, strengths, and actionable plans.

Supercharge Claude Code sessions with oh-my-zsh-style framework: automate TDD cycles, git workflows from init to PR/merge, code verification/build/test pipelines, security/threat scans, doc syncing, agent orchestration, and LLM benchmarking across JS/TS/Python/Go/Rust projects using 11 agents, 33 commands, 24 skills.

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.

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.

Automate GitHub repository community management: analyze health from issues/discussions/cadence, generate prioritized triage reports for backlogs, launch RFC debates/polls/proposals, compose/post announcements from changelogs/git changes, post codebase-informed replies to unanswered issues/discussions. Portable across repos via dynamic discovery.

Launch a TUI overlay in tmux, zellij, or kitty to review diffs, files, and documents with inline annotations in git, hg, or jj repositories. Capture and manage annotations during code reviews, plus configure themes, keybindings, and usage.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Build resilient Claude Code plugin ecosystems with shared infrastructure patterns that enable file-to-markdown conversion across formats, git state recovery and platform detection, service registry with quotas and auth, input sanitization, error handling, risk tiering, supply-chain audits, structured logging, testing standards, action scoring, documentation conventions, and automated plugin maintenance via commands and protective hooks.

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

Automate stacked branch and pull request workflows via GitHub CLI extension: create, push, rebase, sync dependent branches; navigate and visualize PR stacks for incremental code reviews.

Automate full GitHub workflows: generate semantic commits from staged changes with README updates, create standardized PRs with formatted titles/bodies/links, review PRs for bugs/security/performance/best practices, resolve review comments by fixing code or drafting responses, prune gone branches, and configure GitHub CLI auth via agents/commands/skills.

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.

Execute a gated software engineering workflow powered by 20+ skills and agents: plan complex tasks, build with TDD and design checklists, pass automated reviews and sanity gates, debug via scientific method, refactor safely, and commit via git worktrees only after verification.

Automate conventional git commits for dotfiles and config changes, grouping by component with intelligent analysis of diffs. Access companion agents to split jj commits logically, analyze PR feedback patterns across repos, manage Jira issues via CLI, search session histories with FTS5, run tmux commands, generate self-reviews from GitHub/Jira activity, and handle Go testing or taskwarrior tasks.

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.

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.

Conduct evidence-based code reviews, feature prioritization with RICE/WSJF/Kano scoring, git change analysis, workflow error detection, and overengineering prevention; generate structured reports, GitHub issues, and quality gates for roadmaps and handoffs.

Launch autonomous agents to fully orchestrate GitHub repo development lifecycles: scan issues, plan, implement code, run tests/docs reviews, create PRs with zero human input. Enforce token budgets/context limits, monitor sessions, auto-recover crashes via watchdog daemon across macOS/Linux.

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.