Git plugins

A structured engineering workflow system that guides developers through the full lifecycle of building software: grilling ideas, designing interfaces, writing specs, planning work, implementing with TDD, reviewing code, debugging, and refactoring — all with opinionated, plug-and-play skills that replace vibe coding with disciplined process.

Equip AI coding agents with production engineering skills to handle full dev lifecycles: refine ideas to specs, implement via TDD slices, run tests/debug, perform multi-axis code reviews, optimize perf/security, automate CI/CD, and execute ship checklists.

Generate comprehensive documentation, code explanations, and tutorials from existing codebases, with automated doc generation via CI/CD and integrated AI-powered code review for quality and security.

Guides completion of a development branch by verifying tests, detecting the environment, and presenting structured options for merging, creating a pull request, or cleaning up

Resolve in-progress git merge or rebase conflicts by analyzing history, understanding intent, and preserving both changes where possible, with automated verification after resolution.

Analyze code for smells, SOLID violations, and technical debt; generate prioritized refactoring plans and automate legacy codebase modernization with context-aware restoration and AI-powered code review.

Guide feature development through codebase exploration, architecture design with implementation blueprints, and automated code review that surfaces only high-priority issues from unstaged changes.

Create isolated development workspaces using git worktrees for branching and feature isolation

Master essential developer skills including Git workflows, SQL optimization, error handling, code review, E2E testing, authentication, debugging, and monorepo management with Nx, Turborepo, and Bazel.

Establish a disciplined coding workflow combining planning, conventional commits, incremental code quality improvements, automated linting and auditing, and systematic debugging for Node.js, TypeScript, and Python projects.

Simplify Git workflows by staging, committing, pushing changes, and creating pull requests with automated commit messages derived from diffs and recent history, plus cleanup of local branches removed on remote.

Structures development into a repeatable workflow: define project context (product, tech stack, workflow), break work into tracked units (features, bugs, refactors) with specs and plans, then implement via TDD red-green-refactor cycles with git integration and status tracking.

Automate performance analysis, test coverage review, and AI-powered code quality assessment across PRs and codebases using multi-agent reviews, static analysis tools, and observability agents for scaling, caching, and load testing.

Delegate expert-level code reviews, security audits, penetration tests, QA automation, accessibility compliance checks, performance optimizations, chaos engineering, and compliance validations to specialized sub-agents across codebases, infrastructure, and systems.

Automates open-source maintenance workflows including changelog generation, conventional commits, branch naming, pull request creation, code review, and documentation templates following Sentry engineering practices.

Automate PR creation, code review, and description generation with AI-powered analysis, static analysis, and security scanning. Generate onboarding playbooks for new team members.

Automate GitHub issue resolution with root cause analysis and PR creation, generate daily standup notes from git, Jira, and Obsidian, and optimize development workflows and tooling.

Create, review, and manage GitHub issues, pull requests, repositories, and code directly from Claude Code using GitHub's full API.

Automate OSS maintenance workflows: generate changelogs, enforce conventional commits, manage git history with rebase and bisect, review code changes, and produce documentation templates.

Orchestrate a full autonomous engineering pipeline from planning through PR creation, with multi-agent code review, browser testing, documentation management, and design verification against Figma.

Search local markdown knowledge bases, notes, and wikis before resorting to web search, and automate changelog validation, git hooks, and release cutting.

Run source-grounded paid-media audits, generate creative assets, plan budgets, design experiments, and apply capability-gated campaign changes across Google, Meta, YouTube, LinkedIn, TikTok, Microsoft, Apple, Amazon, Reddit, Pinterest, Snapchat, and X.

Generates a personal Claude Code usage and impact report from local session transcripts and git history, showing what you shipped, which projects it went to, and each project's share of your usage.

Master advanced Git workflows including interactive rebase, cherry-picking, bisect, worktrees, and reflog for clean history management and recovery from any situation.

Multi-LLM orchestration that automates the full development lifecycle — research, design, code review, testing, security auditing, and documentation — by routing tasks across multiple AI providers (Gemini, Codex, Ollama, Copilot) with structured workflows and quality gates.

Manage complex development workflows with AI-driven task orchestration: parse PRDs into structured tasks, auto-implement with code generation and testing, analyze dependencies and complexity, and coordinate multi-agent execution for ambitious projects.

Generate self-contained HTML pages for visual explanations including diagrams, architecture overviews, diff reviews, implementation plans, slide decks, and project recaps, with automatic verification against source code and git history.

A 145-skill bundle automating CRM, marketing, project management, file operations, social media, design, documentation, and development workflows via Composio/Rube MCP integrations, plus specialized skills for AI agent coordination, code analysis, and media processing.

Delegate full-stack development workflows to Claude via 213 specialized agents, commands, and skills: refactor code, generate tests/deployments/Dockerfiles/K8s manifests, audit security/performance, document APIs/onboarding, orchestrate Git ops, and apply patterns across JS/TS/Python/Rust/Go/Java stacks.

Enables end-to-end product management execution: aligns OKRs with company strategy, creates structured PRDs, user stories, and backlog items, plans sprints with capacity and risk analysis, facilitates retrospectives, maps stakeholders on a power/interest grid, runs pre-mortem risk analyses, and generates release notes, test scenarios, and meeting summaries from transcripts or rough notes.

Run multi-agent code optimization, content drafting, or research sessions where parallel subagents compete in isolated git worktrees, evaluated by metrics or LLM judges, with automatic winner merging.

Automatically generates user-facing changelogs from git commit history by categorizing changes and translating technical commits into customer-friendly release notes

Automates Claude Code operations with pre/post hooks for agent assignment, code formatting, session management, Git integration, and memory coordination across swarm agents.

Scan your codebase for vulnerabilities at a chosen effort tier, with every finding challenged by a verification agent before being reported. Surviving findings are turned into targeted, agent-verified patches that you review and apply when ready.

Conduct end-to-end academic research with AI/ML: literature discovery from arXiv/Zotero, paper ingestion into an Obsidian knowledge base, experimental analysis with statistical rigor, publication-ready figure/writing/rebuttal generation, and knowledge management across sessions.

Perform AI-powered code review on Git changes using the OCR CLI from Alibaba, with deterministic file selection and rule resolution, detecting bugs, security vulnerabilities, performance problems, and code quality issues — line-level comments and optional auto-fixes included.

Get AI-driven code review on Git diffs with concurrent per-file analysis, codebase search, and deep context awareness. Supports workspace changes, branch ranges, and single commits. Optionally let it autonomously apply high-confidence fixes.

Generates personalized coding tutorials from your own project code, then tests your knowledge with spaced-repetition quizzes. Optionally syncs tutorial files to a private GitHub repository.

Automate Kubernetes deployments with GitOps workflows using ArgoCD and Flux for declarative infrastructure management and continuous reconciliation

Generate structured engineering documents and analyses for code reviews, incident postmortems, API docs, architecture decisions, system design, runbooks, CI/CD, SLOs, database migrations, security threat models, and more — all from natural language prompts in Claude Code.

Orchestrate multi-agent development workflows with skills for collaborative design, autonomous coding via OpenAI, multi-agent research, GitHub issue fixing and PR review, image generation, session handoffs, and browser automation via Chrome DevTools.

Orchestrate 51 specialized AI agents to automate development workflows: code generation and review, quality audits, deployment coordination, research, documentation, and project cleanup across any stack.

Ask questions about your codebase's structure, patterns, and content — Repomix packs local or remote repositories so you can query the generated output for insights.

Define and execute feature work using a Spec-Driven Development methodology—plan tracks, implement tasks, enforce code quality, revert changes via Git, and monitor project progress.

Automates the full PRP (Plan, Review, PR) development workflow: from product requirements and implementation plans to autonomous build loops that ship features end-to-end, with integrated code review, debugging, and git operations.

Develop, debug, publish, and maintain Obsidian plugins with full lifecycle support — from scaffolding and CI/CD to performance optimization, security hardening, and vault management.

Automate overnight development sessions with Git hooks that enforce test-driven development, allowing Claude to autonomously implement features, run tests, debug failures, and deliver a morning handoff report with all tests passing.

Manage the full lifecycle of CodeRabbit AI code review across GitHub and GitLab: install, configure, deploy organization-wide, tune review quality, handle incidents, and monitor effectiveness. Includes merge gate setup, cost optimization, security scanning, and migration from other tools. 24 skills covering setup, operations, and maintenance.

Generate AI-powered wiki documentation for any code repository, including hierarchical catalogues, Mermaid-rich architecture diagrams, audience-tailored onboarding guides, deep research via code path tracing, and deployable VitePress sites with automated GitHub Pages workflows. Analyze git history for changelogs and produce LLM-friendly docs.

Manage and run regression test suites across releases, mapping tests to bug tickets, detecting flaky tests, and analyzing change impact to prevent breaking existing functionality.

Generate conventional commit messages from staged git changes using AI analysis of diffs, with automatic type classification, breaking change detection, and confirmation before committing. Follows the Conventional Commits specification format (type(scope): description).

Generate conventional commit messages by analyzing staged Git changes to standardize version control history.

Blocks destructive git and filesystem commands before execution using configurable guard scripts, with guided setup for user-level, project-level, and shareable GitHub-scoped rulebooks.

Security-focused differential review of code changes (PRs, commits, diffs) with git history analysis, blast radius estimation, and test coverage checks

Provides a suite of developer tools for code review, skill creation, and knowledge management, including git-based code quality audits, guided skill file generation, and structured wiki building from documents.

Manage and optimize Windsurf IDE, from initial setup and migration to advanced Cascade configurations, troubleshooting AI issues, deploying via Netlify/Vercel, automating CI/CD with GitHub Actions, enforcing security policies, and standardizing team workflows.

Manage and execute deployment rollbacks with safety checks across Kubernetes, ECS, Lambda, and cloud VM deployments. Detects failures via monitoring and health checks, reverts to stable versions, verifies success, and generates rollback configurations.

Manage GitHub pull requests directly from the terminal — view CI/CD progress, bot comments, file changes, and merge with one command.

Generates conventional commit messages from git diff using AI, with three verbosity levels, and commits the selected message.

Orchestrate complex multi-stage deployment pipelines across dev/staging/prod with Kubernetes and CI/CD platforms, implementing strategies like blue-green, canary, and rolling updates.

Redirects GitHub API URLs and curl/wget commands to the authenticated gh CLI, eliminating credential exposure and ensuring consistent API access during development workflows.

Enforce a repeatable SDLC workflow with memory, structured phases, multi-agent coordination, and verification gates for AI coding agents.

Analyze and clean up local git branches and worktrees by categorizing them as merged, squash-merged, superseded, or active work, with user confirmation gates.

Enforces Sentry's engineering and documentation standards across code review, git workflow, security auditing, and project documentation. Automates PR descriptions, commit messages, branch naming, and SRED submission prep while scanning for vulnerabilities in Django, GitHub Actions, and agent skills.

Automates code review workflows using roborev, including branch/commit review, design review, look-ahead detection of temporal leakage, automated fixing of review findings, and an iterative review-fix loop until all reviews pass.

Record, transcribe, and search meetings and voice memos to build a searchable memory of conversations. Analyze transcripts for talk-time, decisions, and commitments; generate pre-meeting briefs, post-meeting summaries, and weekly digests.

Query your codebase using natural language by building a local knowledge graph from your repository, with CLI commands to scaffold multi-agent projects, initialize environment configs for LLM providers, and refresh indexed data.

Orchestrate parallel Claude Code agents in isolated git worktrees with tmux window status updates, supporting multi-branch development, PR generation, and conflict resolution.

Audit local Git state to find and recover lost work, verify merges, and safely clean up branches, stashes, worktrees, and duplicate clones before deletion

End-to-end documentation workflow for Strapi: research coverage gaps, generate outlines, draft pages, review for style/code/UX consistency, and open PRs with proper git conventions.

Review diffs, files, and documents with inline annotations in a TUI overlay, supporting git, hg, and jj repos

Installs a unified AI coding assistant configuration system with rules, skills, and commands to enforce coding standards, automate code reviews, commit messages, project setup, and generate documentation across multiple languages and frameworks (Go, Java, Python, TypeScript, Vue, etc.).

Walk through code files sequentially, create markdown issue specifications staged in git, log work summaries, and delegate browser-based UI testing to a dedicated Chrome DevTools agent.

Manage Windsurf IDE and Cascade AI agent configurations across the full development lifecycle — automate CI/CD pipelines, enforce code quality, generate tests, debug errors, secure dependencies, set team policies, and orchestrate multi-file refactoring.

Orchestrates full-stack development workflows with specialized agents for code review, debugging, refactoring, testing, security auditing, and documentation across any software project.

Run a multi-agent security and quality assurance team that audits REST APIs for OWASP vulnerabilities, reviews git diffs for code quality and security, debugs production incidents, generates automated tests, and optimizes performance — all delegated as autonomous sub-agents.

Automates large-scale development workflows with spec-driven planning, structured deep discussions for problem analysis, and findings-first code reviews of uncommitted changes, date-range commits, or branch diffs.

Evidence-driven repository setup, environment diagnosis, and safe Git workflow for Claude Code, detecting actual stack from project manifests, preserving local work during sync, diagnosing session start issues, and providing guarded commit, push, conflict resolution, and history cleanup.

Clone, update and analyze competitor repositories to produce evidence-based competitive intelligence with file:line citations from local code and sourced market-landscape claims.

Perform authorized security testing, bug bounty hunting, and penetration testing across web, API, mobile, cloud, infrastructure, and smart contract environments. Includes reconnaissance, exploitation, authentication testing, and reporting automation.

Brainstorm feature ideas, then sweep conversation results into tasks on a kanban board. Decompose work and orchestrate across git worktrees for automated task management.

Automate a structured GitHub bug-fix workflow: from issue creation, branch management, conventional commits, and auto-fixing PR feedback, through multi-perspective PR review and CI pipeline fix loops.

Run team collaboration workflows directly from Claude: review architecture, analyze decision quality, map dependencies, estimate effort, triage issues, plan sprints, generate standup reports, balance workloads, capture session learnings, and manage CLAUDE.md files

Scan GitHub repository history for secrets, API keys, PII, and private domains/IPs, then safely rewrite history to remove them with backup and verification. Includes safety checks before force pushes to prevent accidental data exposure.

Guides you through the full lifecycle of contributing to third-party open-source repositories on GitHub — from discovery and CONTRIBUTING compliance to minimal-diff implementation, AI-assisted PR disclosure, conflict resolution, and maintainer interaction.

Automate project health audits, permission management, dev sessions, team updates with feedback triage, GitHub releases, multi-model AI second opinions, git workflows, UX audits, responsive layout testing, and browser automation across the full development lifecycle.

Automates multi-dimensional PR review using specialized agents that analyze code comments, test coverage, error handling, type design, code quality, and code simplification against git changes. Consolidates findings into a prioritized action plan.

Standardize the entire design-to-development workflow with structured design critiques, QA checklists, handoff specs, review gates, sprint planning, team workflows, and version control for design files and tokens.

Map and document any codebase by orchestrating parallel AI subagents that analyze architecture, file roles, dependencies, and navigation, outputting a structured CODEBASE_MAP.md that updates incrementally via git or scans.

Offers slash commands for systematic debugging, code quality analysis, architecture exploration, and git workflow automation — including branch cleanup, Linear task generation from TODO markers, and worklog creation from commits.

Run Arbor's hypothesis-tree research workflow inside Claude Code using your own model — no API key. Orchestrates autonomous research loops with idea trees, git worktrees, guarded merges, evaluation, and report generation.

Orchestrate multiple AI agents across Claude Code, Codex, Gemini, and other platforms to automate software development tasks including architecture, coding, review, testing, deployment, and documentation.

Guide usage of SAP Business Application Studio on SAP BTP, including setting up subscriptions and dev spaces, connecting to external systems, deploying MTA applications, managing Git repositories, and configuring runtime versions for Node.js, Java, and Python.

Manage git-flow branching model with automated feature, bugfix, and hotfix branch creation and completion, including PR creation, pre-merge checks, and cleanup.

Manage Git worktrees for parallel development: create worktrees for separate branches and clean up finished ones by removing merged branches and pruning stale references, with safety checks.

Run a systematic second-pass code review on all changed files, catching logic errors, security flaws, and common mistakes with severity ratings before committing.