Git plugins

Enforce a structured TDD workflow with parallel task execution, isolated git worktrees, and systematic code review. Guides root cause investigation before fixes, verifies tests and linters pass before claiming completion, and dispatches subagents for independent tasks like fixing multiple test failures simultaneously.

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

Provides a structured engineering workflow: transforms ambiguous ideas into PRDs and GitHub issues, designs module APIs, refactors code via vertical-slice TDD, diagnoses bugs, resolves git conflicts, and produces documentation like ADRs and domain glossaries.

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.

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 a comprehensive PR review that delegates to specialized agents for code quality, test coverage, error handling, type design, comment accuracy, and code simplification, producing a categorized issues summary with critical items, suggestions, strengths, and an action plan.

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 repeatedly feeds the same prompt back to itself, enabling incremental iterative improvement across multiple cycles until a task is completed.

Guides feature development through architectural analysis, codebase exploration, and automated code review, while maintaining project documentation via CLAUDE.md audits, session learnings, and custom skill creation with eval benchmarking.

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.

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.

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.

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

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.

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.

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.

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.

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.

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.

Delegate code review, investigation, and complex coding tasks to OpenAI's Codex within Claude Code, with support for adversarial reviews, background job management, and readiness checks.

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

Manage an AI-supervised issue tracker with persistent task memory, dependency graphs, and compaction recovery, enabling multi-session coding workflows via simple CLI commands.

Run structured engineering workflows — standups, code reviews, architecture decisions, incident response, debugging, and technical documentation — with optional integrations for GitHub, Notion, Slack, Asana, Linear, Jira, PagerDuty, and Datadog.

Manage tasks in TASKS.md with Active/Waiting/Someday/Done sections, sync with GitHub Issues, and connect to project management tools (Linear, Jira, Asana, Monday.com, ClickUp), Notion, and Slack. Build persistent memory for people, projects, and internal terms.

Debug GitHub Actions failures by analyzing logs, identifying breaking commits, and finding fix PRs. Clone conversations to branch experiments or halve token usage. Generate HANDOFF.md for agent handoffs and review chats to improve CLAUDE.md. Fetch Reddit content when WebFetch is blocked.

Trace execution flows, analyze blast radius, and search codebases using a knowledge graph. Index Git repos, trace bugs through function callers/callees, assess code change impact, review pull requests with risk detection, and safely refactor with dry-run previews.

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.

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.

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.

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.

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.

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.

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.

Full-cycle development workflow for solo developers: project scaffolding, multi-agent collaboration (Cursor PM & Claude Code), CI/CD automation, auth/payments setup, code reviews, release management, and cross-session memory.

A collection of 23 skills for deconstructing books and papers, generating styled visuals, writing structured essays, and performing deep philosophical or strategic analysis — all within Claude Code.

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.

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.

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.

Semi-automated research assistant for academic literature review, paper writing, and project knowledge management. Integrates with Zotero and Obsidian to search papers, extract writing patterns, generate structured manuscripts, manage citations, and produce conference materials. Also includes general-purpose development tools for code quality, debugging, Git workflows, and project scaffolding.

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.

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.

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.

Implement a structured, spec-driven development lifecycle with AI agents: discuss requirements, research, plan, execute code, verify, and manage milestones. Includes multi-model plan review, automated code review, test generation, UI auditing, project documentation, and session handoff for continuous AI-assisted development.

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.

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

Orchestrate multi-agent workflows with budget-aware task delegation, cross-agent plan review, autonomous execution, and visual recaps from git diffs or PRs. Enforces docs-first research and provides clear status indicators for long-running or parallel agent tasks.

Build and deploy data portals with PortalJS — scaffold a portal from a brief, add datasets and resources, create charts and interactive maps, connect a CKAN backend, harvest datasets from open-data platforms, define schemas, deploy to Cloudflare static hosting, and audit data quality.

Extends Claude Code with spec-driven development workflows: autonomous long-running tasks, multi-agent deep research, structured feature planning with EARS requirements and constitution-based specs, GitHub issue fixing and PR review, skill benchmarking and creation, image generation, and session learning capture.

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

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.

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.

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.

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

Persist and retrieve project context across Claude Code sessions by saving architectural decisions, bug fixes, and design patterns to a searchable memory store, indexing your codebase for automatic context, and searching past sessions for prior work and preferences.

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.

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.

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.

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.

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.

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

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 — plan, implement, debug, review, commit, and create PRs — using specialized agents that investigate issues, generate implementation plans, run validation loops, and execute multi-aspect 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.

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.

Enforce a structured, repeatable SDLC workflow across AI coding agents — from requirements and design through implementation, testing, code review, and release — with persistent memory, multi-agent coordination, and verification gates.

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

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.

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.

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.

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.

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.