Git plugins

Enforces a structured TDD workflow with parallel task execution, code review, and root-cause debugging. Guides brainstorming into validated specs, creates isolated git worktrees for feature branches, and runs verification checkpoints before merging or committing.

Cut ~75% of tokens in Claude Code conversations by speaking like a caveman, compressing memory files, commits, PR reviews, and delegating tasks to specialized subagents for surgical code edits, read-only code location, and diff review.

Enables a disciplined engineering workflow inside Claude Code with skills for planning, debugging, refactoring, TDD, code review, documentation, issue triage, git safety, prototyping, and article writing.

Persists Claude Code context across sessions by automatically capturing observations, then retrieving them via natural language queries in future conversations. Includes a suite of project-management skills: codebase onboarding, architectural analysis, PR monitoring, release automation, and knowledge-base Q&A powered by stored memory.

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.

Run comprehensive PR reviews using specialized agents for code quality, test coverage, error handling, type design, code comments, and simplification. Generates a categorized issue summary with critical, important, and suggestion items.

Audit and improve CLAUDE.md quality, create custom skills with eval benchmarking, implement features with architectural guidance and code review, and capture session learnings to refine workflows.

Audit CLAUDE.md files across repositories by discovering them with find, evaluating quality against rubrics, generating reports, and applying targeted improvements after approval. Capture learnings from Claude Code sessions to propose concise updates to CLAUDE.md or .claude.local.md files with user approval.

Run Claude in a continuous self-referential loop that feeds the same prompt back after each attempt, enabling iterative refinement until task completion. Track token usage across sessions.

Orchestrate swarms of specialized AI agents to automate end-to-end software development: plan features, implement code with Rails/Python/TS patterns, conduct multi-perspective reviews for architecture/security/performance, resolve todos/PR feedback in parallel, run browser/iOS tests, sync Figma designs, generate docs/videos, and ship PRs.

Run multi-perspective code reviews across architecture, security, performance, and best practices, including git-based PR analysis with specialized agents for vulnerability scanning and architectural integrity.

Generate production-ready stateful CLI harnesses for GUI applications from local paths or GitHub repos, implementing Click CLI with REPL/JSON support, pytest unit/E2E tests, and docs. List installed harnesses, refine coverage gaps, run tests to verify functionality, and validate against standards.

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.

Delegates product strategy, legal/licensing, business analysis, project management, UX research, content marketing, customer success, technical sales, technical writing, and WordPress development to specialized AI agents

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 end-to-end feature development: explores codebase to map dependencies, patterns, and execution paths; designs architectures with blueprints, data flows, and build sequences; implements code changes; reviews for bugs, security vulnerabilities, and quality issues using high-confidence filtering.

Build and manage cloud infrastructure and deployment pipelines with AWS serverless, Docker, Kubernetes, Terraform, and CI/CD workflows, including environment setup, containerization, GitOps, and production deployment strategies.

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.

Implement a complete QA and testing workflow: set up A/B tests with hard gates, automate browser testing with Playwright/Puppeteer, enforce code review checklists and TDD, debug systematically, and fix failing tests using pytest patterns.

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.

Delegate complex coding, debugging, and root-cause analysis tasks to OpenAI's Codex CLI from within Claude Code, with structured code reviews that challenge implementation choices and tradeoffs against git history.

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.

Manage AI-supervised issue tracking with CLI commands that create, organize, and close tasks while maintaining context across conversation sessions. Track dependencies, decisions, and epics; compact old issues via semantic summarization; discover ready tasks and let an autonomous agent claim and complete them.

Forces high-agency, exhaustive problem-solving when Claude detects frustration, repeated failures, or passive behavior — applying structured debugging, proactive investigation, and role-based engineering personas (P7–P10) inspired by Chinese tech corporate culture. Includes agents for task decomposition, code execution, review gates, and verification loops.

Debug GitHub Actions failures by pinpointing root causes, identifying breaking commits, and scanning for fix PRs. Clone or half-clone Claude conversations to branch experiments or cut token usage. Generate HANDOFF.md summaries for agent handoffs. Fetch Reddit content when WebFetch is blocked. Review conversations to suggest CLAUDE.md improvements.

Index git repositories into a knowledge graph for execution flow tracing, blast radius analysis, and augmented search. Trace bugs, analyze change impact, review pull requests, and safely refactor code using static analysis and graph-powered insights.

Run structured multi-LLM workflows across the Double Diamond process — research, scope, implement, and deliver with autonomous agents, code review, security audits, and TDD enforcement, all orchestrated via Claude Code.

Spawn parallel AI subagents in isolated git worktrees to compete on tasks like code optimization, refactoring, test writing, or bug fixing. Evaluate results using pytest metrics or LLM judging on git diffs, rank agents, and merge the top performer into your base branch.

Turns any Claude conversation into a persistent, self-organizing Obsidian wiki vault with hybrid retrieval, methodology-based filing (LYT/PARA/Zettelkasten/Generic), automated research loops, canvas management, pre-commit auditing, and health checks — enabling compounding knowledge that survives across sessions and projects.

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.

Manage AI-driven development workflows with hierarchical task trees, dependency graphs, automated subtask expansion, PRD-to-task parsing, status tracking, and intelligent task orchestration via natural language commands.

Autonomously optimize code files by measurable metrics through iterative experiments: set up target file, eval command, and loop intervals (10min-monthly); AI edits code, commits to git branches, evaluates with Python, keeps improvements. Resume, run manually, or check dashboard status.

Run engineering workflows — standups, code reviews, ADRs, incident response, deployment checklists, and debugging — by connecting to GitHub, Jira, Linear, Slack, PagerDuty, Datadog, and other dev tools.

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.

Automate personal productivity by combining task management, memory of people and projects, and sync across email, calendar, chat, and project trackers like Jira, Asana, Linear, and GitHub Issues.

Install 124 ready-to-use Claude Code skills to automate 50+ third-party services including CRMs (HubSpot, Salesforce), PM tools (Jira, Asana), analytics (GA4, Mixpanel), cloud storage (Google Drive, Dropbox), GitHub/Vercel deploys, doc/PDF/image processing, React artifact building, design generation, and dev productivity tasks via Rube MCP/Composio integrations.

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.

Learn coding skills interactively with personalized tutorials and spaced repetition quizzes drawn from your own codebase. Use /teach-me for lessons, /quiz-me for practice with feedback, track progress, and sync tutorial data to a private GitHub repo.

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 a structured Plan/Work/Review workflow for solo developers, automating project initialization, task planning, code implementation with quality guardrails, CI/CD setup, deployment, and cross-session memory management. Integrates multi-agent collaboration (Cursor PM, Codex reviews) and browser automation for full-cycle contract development.

Mark up and refine AI-generated plans interactively in a UI, annotate markdown files, messages, and git changes for review, share for team collaboration, browse plan archives, and automate workflows with plan mode hooks.

Generate complete AI-powered wiki sites from git repositories as dark-mode VitePress static sites with Mermaid diagrams, source citations, hierarchical catalogues, audience-tailored onboarding guides, changelogs, deep research reports, and codebase Q&A. Export to Azure DevOps Wiki or deploy via GitHub Actions to Pages.

Implement Trail of Bits handbook security testing workflows: fuzz Rust, Python, C/C++, Ruby code with AFL++, libFuzzer, cargo-fuzz, Atheris; instrument AddressSanitizer; run static analysis via Semgrep, CodeQL; generate coverage reports, dictionaries, and bypass obstacles for vulnerability detection.

Automate the full lifecycle of academic research projects from literature discovery and review to experiment analysis, manuscript drafting, and reviewer rebuttals, while also offering code quality checks, git workflow enforcement, and project scaffolding for software development.

Provides 20 Chinese-language skills for Claude Code and 18 other 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.

Apply Maoist dialectical reasoning and strategic frameworks to software development: prioritize tasks via contradiction analysis, resolve trade-offs, investigate unknowns, self-criticize completed work, and bootstrap projects from zero resources using phased warfare tactics.

Run a complete AI-assisted coding workflow with self-correcting memory, persistent FTS5-indexed research wikis, auto-research loops, multi-LLM council deliberation, and 8 specialized agents that coordinate parallel sessions, enforce quality gates, audit context costs, and capture learnings across every session.

Build multi-language code graphs to map call graphs, attack surfaces, blast radius, taint propagation, privilege boundaries, and complexity hotspots for security audits. Visualize architecture with Mermaid diagrams, compare snapshots across git commits for evolution analysis, triage mutation testing survivors, generate crypto test vectors, diagram protocols, and project SARIF findings onto graphs.

Crystallize vague project requirements into executable Seed specifications through Socratic interviews, then run, evaluate, and iteratively refine them with three-stage verification, drift detection, and evolutionary loops.

Analyze local and remote GitHub repositories using Repomix CLI to explore code structure, search for patterns, and answer questions about components, architecture, and content.

Quickly pack local or remote GitHub repositories into AI-optimized formats (XML, Markdown, JSON, plain) with compression, file filters, git diffs/logs, and clipboard copy using simple slash commands.

Build and orchestrate advanced Claude Code agentic workflows by creating meta-prompts, subagents, hooks, MCP servers, slash commands, and skills; execute hierarchical plans, run autonomous coding loops, apply expert debugging and productivity frameworks like 5 Whys or Eisenhower Matrix, and audit components for compliance and quality.

Run a complete AI-assisted software development workflow inside Claude Code: structured planning, context engineering, milestone management, code review, automated testing, and documentation — all governed by spec-driven and meta-prompting principles.

Orchestrate autonomous multi-agent sprints to develop full features from specs.md: agents handle architecture, parallel implementation of Next.js frontends and Python/FastAPI backends, CI/CD setup, automated testing, UI QA, reviews, and iterative convergence with structured reports and git safety.

Migrate React Native apps to newer versions by applying incremental diffs, updating iOS/Android configs, resolving CocoaPods and Gradle changes, and handling breaking API updates

Generate 35 structured engineering artifacts — postmortems, runbooks, ADRs, PR descriptions, changelogs, SLO docs, threat models, test strategies, database plans, and onboarding guides — from rough notes, logs, or specs, following established SRE and software engineering conventions.

Streamline end-to-end Obsidian plugin development and vault management: scaffold projects with TypeScript setups, implement UI views/events/data handling, optimize performance/security, establish local dev loops/CI/CD/release pipelines, migrate content, and troubleshoot errors using 24 specialized skills.

Build interactive web UIs for MCP servers and Claude Desktop apps using guided Claude Code skills. Add UIs to existing servers via Apps SDK, convert web apps to hybrid MCP format with shared code and tool registration, create new apps from React/Vue/Svelte templates with Vite bundling, or migrate OpenAI Apps SDK projects.

Configure, deploy, optimize, troubleshoot, and integrate CodeRabbit AI code reviews across GitHub and GitLab repositories. Automate CI merge gates, cost tuning, security policies, local dev loops, performance monitoring, migrations from other tools, and webhook handling using 24 targeted skills.

Automatically discover and hierarchically load AGENTS.md files across project directories into Claude's agent context, merging instructions with conflict detection and caching for specialized behaviors without manual setup. Sync all agent contexts into CLAUDE.md under organized sections with backups and summaries.

Run code reviews on uncommitted changes, branch diffs, or specific commits using external LLM CLIs (OpenAI Codex, Google Gemini), with an optional bundled MCP server for direct tool access.

Scaffold production-grade Claude Code plugins with marketplace integration, validate structure and schemas, audit for security vulnerabilities and best practices, and automate semantic version bumps across manifests and catalogs using auto-invoked skills and interactive commands.

Automate spec-driven development workflows with AI agents that fix GitHub issues, review PRs, generate images, translate content, and extract YouTube transcripts. Includes hooks for token usage monitoring and MCP for browser automation via Chrome DevTools.

Automate overnight software development by configuring Git hooks for TDD enforcement with tests and lints, then run Claude autonomously for 6-8 hours to build features that pass all checks by morning.

Generate multi-stage CI/CD pipelines in YAML for GitHub Actions, GitLab CI, Jenkins, and CircleCI. Automate workflows covering linting, testing, Docker image builds/pushes, security scans, and gated deployments to staging/production on Kubernetes.

Accelerate Atomic Agents app development through a guided 7-phase workflow: delegate schema design, agent and tool creation, architecture planning, codebase analysis, and code review to specialized AI sub-agents for scalable multi-agent LLM systems.

Integrate OpenEvidence medical AI for clinical decision support in healthcare SaaS: run evidence-based queries, drug interactions, DeepConsult syntheses; automate auth setup, rate limiting, caching, RBAC, monitoring, CI/CD pipelines, Docker deploys, and production checklists in TypeScript/Node.js/Python projects.

Combine multiple Git repositories into unified archives for AI-powered codebase analysis, with built-in security scanning and file search capabilities.

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.

Track regression tests across code releases by mapping git commits to pytest or Jest tests, tagging markers for suites, flagging coverage gaps, generating pass/fail reports with flaky detection, viewing history, and enforcing runs in CI/CD pipelines.

Manage environment configurations and secrets across dev/staging/prod deployments using .env files, Kubernetes ConfigMaps/Secrets, and AWS SSM. Audit values, encrypt secrets with sops, validate schemas, detect drift, and run promotion workflows. Generate secure, scalable DevOps setup code for Docker, Kubernetes, Terraform, AWS, and GCP infrastructure.

Generate test reports by parsing JUnit XML, Jest JSON, pytest results, and coverage data into Markdown/HTML formats with metrics, failures, slowest tests, trends, and CI annotations. Aggregate results across frameworks for summaries and exports in HTML, PDF, or JSON.

Generate production-ready GitOps workflows for Kubernetes using ArgoCD or Flux, creating manifests, sync policies, multi-environment promotions, RBAC configurations, notifications, and CI/CD integrations for secure, scalable continuous deployments.

Persist code context and reasoning across Claude Code sessions by saving architectural decisions, bug fixes, and design patterns to project memory, then querying past sessions via natural language search.

Perform security reviews of pull requests, commits, or code diffs using git history for context, blast radius estimation, test coverage checks, and markdown report generation.

Automate the entire PRP workflow from planning to pull request: generate implementation plans, execute changes with validation loops, investigate issues, create PRs, and run multi-agent code reviews.

Master Cursor IDE AI workflows using 30 guided skills: install and authenticate, configure custom models and rules, optimize indexing and performance, automate Composer for multi-file refactoring and scaffolding, troubleshoot errors, manage teams with SSO, and audit compliance.

Generate read-only Markdown discrepancy reports validating messaging consistency—including tone, terminology, versions, and structure—across HTML-based websites (WordPress, Hugo, Next.js, React, Vue, etc.), GitHub repositories, and local documentation, with severity levels and fix suggestions.

Use Claude to manage Granola AI meeting notes workflows end-to-end: automate installations and upgrades, integrate with GitHub/Linear/Slack via Zapier for action items, optimize costs/performance/security, export data, troubleshoot issues, and deploy enterprise setups with RBAC/observability.

Orchestrate multi-agent coding workflows with context-aware task decomposition, parallel subtask execution, automated code review, and TDD test generation.

Orchestrate a full BMAD agile workflow with role-based AI agents (PO, Architect, SM, Dev, QA) to build projects from descriptions. Handles repo scanning, interactive requirements and architecture design, sprint planning, automated coding with tests, QA validation, code reviews, and user approval gates for production-ready delivery.

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.

Automate development workflows by walking through code files line-by-line in VSCode or Vim, logging timestamped work sessions with file changes in daily Markdown, generating detailed issue specs staged in Git, engaging in adaptive Socratic quizzes for learning, and delegating UI validation tasks to a browser agent using Chrome DevTools.

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.

Equip Windsurf AI IDE with 30 Cascade skills to automate code generation, debugging, testing, multi-file refactoring, CI/CD workflows, Docker setups, Git integrations, security configurations, and enterprise onboarding, streamlining full dev lifecycles.

Master Windsurf AI IDE with 30 skills to automate Cascade multi-file coding workflows, troubleshoot IDE issues, optimize performance and costs, configure enterprise RBAC/security/CI gates, deploy to Netlify/Vercel, and scale for large teams/monorepos.

Orchestrate complex test workflows across Jest, Vitest, pytest, Playwright, and Cypress with parallel execution, test sharding, dependency management, flakey retries, affected test selection, and result aggregation in GitHub Actions or GitLab CI. Generate optimized configs for CI/CD pipelines.

Safely manage and execute rollbacks for Kubernetes, ECS, Lambda, and cloud VM deployments. Automatically detect failures via monitoring and health checks, revert to stable versions, verify recovery success, generate reports, and create templated documentation for rollback configurations.

Scan your codebase and Git history for exposed secrets like API keys, passwords, tokens, and credentials using pattern matching and entropy analysis. Receive detailed reports pinpointing file locations, secret types, severity ratings, and step-by-step remediation guidance to secure your project fast.

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.

Orchestrate multi-stage deployment pipelines across dev, staging, and prod environments using Kubernetes and CI/CD platforms like GitHub Actions and Jenkins. Apply strategies such as blue-green, canary, and rolling updates. Generate production-ready pipeline configurations, setup code, and documentation tailored to Docker, Terraform, and AWS infrastructure.

Orchestrate multi-agent AI workflows in Claude Code: track work via convoys and beads, deploy polecat/crew agents, merge via refinery, install/monitor with gt/bd CLI for AI-powered software factories.

Automate Lucidchart diagram creation and management in Node.js/TypeScript apps via API: import shapes/lines from .lucid/JSON/CSV, link data dynamically, export PNGs, handle auth/errors/rate limits/webhooks, with CI/CD setup, Docker deployment, local dev loops, debugging bundles, security checklists, and prod optimizations.

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