Mermaid plugins

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.

Manage the full Azure lifecycle from Claude: provision VMs, AKS clusters, and PaaS apps; deploy with Bicep, Terraform, or azd; query costs and resources; diagnose services via AppLens and Monitor; configure AI gateways and Entra ID auth; migrate cross-cloud workloads; run compliance scans and reliability checks.

Generate Mermaid architecture diagrams from codebase components and relationships, with labeled data flows and legends, and produce technical design documents from system requirements covering overview, components, data flow, technology choices with rationale, and risks. Diagrams save to docs directory.

Automates batch photo downloads from PhotoPlus and Alltuu cloud albums, while also providing a toolkit for configuring Claude Code agents, troubleshooting service deployments (CoPaw, OpenClaw, Hermes), generating structured documentation (PDF extraction, Mermaid diagrams, paper reports), and transcribing audio/video with MLX/Whisper.

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.

Perform Five Whys root cause analysis to identify issues and solutions, generate Mermaid ERDs from SQL migrations or database schemas, and follow structured 4-step guides for problem-solving and project building through to deployment.

Deeply analyze open-source Git repositories on GitHub or GitLab to generate professional architecture reports featuring Mermaid diagrams, business insights, design rationale, and critical evaluations for studying frameworks, comparing projects, or architecture research.

Create, preview, and refine Mermaid diagrams (flowcharts, sequence, class, ER, state, Gantt) with live SVG reload and save tools for an iterative diagramming workflow inside Claude Code.

Equip Claude with skills to scan codebases for patterns and conventions, generate bold React/Astro UIs, Mermaid diagrams, and AI images; manage parallel git worktrees; hypothesize trade-offs; audit CLAUDE.md docs; apply Go/Neovim best practices; query files; and invoke external AIs for reviews.

Visualize any codebase with Mermaid diagrams showing architecture, dependencies, data flows, call chains, and class hierarchies. Detects community clusters, circular dependencies, and coupling issues to aid refactoring and onboarding.

Read, create, and update Miro boards from AI conversations — extract specs, generate diagrams (flowcharts, UML, ERD), create documents and tables, and perform visual code reviews linked to PRs/MRs.

Enforce a complete TDD-driven software development lifecycle inside Claude Code: from structured requirements elicitation and architecture design, through strict red-green-refactor cycles, automated quality gates (coverage, mutation), acceptance and system testing, to release notes and retrospective analysis.

Generate images, icons, diagrams, patterns, storyboards, and visual assets from text prompts using Gemini AI models via a local Nano Banana MCP server. Edit and restore photos, create technical diagrams with Mermaid, and handle natural language requests without Gemini CLI dependency.

Turn natural language into working hardware — generate, verify, simulate, and deploy SystemVerilog/VHDL RTL designs with AI agents that lint, formal-verify, generate testbenches, run FPGA synthesis/P&R, and flash bitstreams.

Manage the full product lifecycle from concept to launch: brainstorm and design specs, implement features with TDD, audit SEO and security, run pentests and Lighthouse, deploy with canary monitoring, and track post-ship growth metrics. Includes currency guard for live documentation.

Automate the full legal project management lifecycle — matter setup, phase-based budgeting, scope and change control, stakeholder communication, document approval workflows, RAID tracking, resource planning, and portfolio-level daily briefings — with structured outputs including Gantt charts, status reports, and lessons-learned artifacts.

Bootstraps and audits AI-ready repositories with conventions, architecture documentation, security reviews, and session summaries. Runs pre-commit security scans, diagnoses flaky tests, and maintains a context map for Claude Code and Codex CLI.

Automatically reverse-engineer legacy codebases into living architecture docs with Mermaid diagrams, then orchestrate a multi-agent risk audit that delegates parallel specialists (scalability, concurrency, chaos/SRE, security) and consolidates findings into a prioritized executive trust report.

Run structured cognitive brainstorming sessions for technical architecture, planning, and conceptual work using the GROUND-EXPLORE-DECIDE-STRESS-SHIP protocol. Generate ADRs, specs, plans, Mermaid diagrams, structured explanations, and parse Markdown plans into executable tasks with dependencies.

Structured workflow skills for coding agents: clarify ambiguous requirements, create design briefs, generate and refresh project documentation, execute implementation plans with scope control, diagnose and fix bugs, commit changes with conventional messages, review uncommitted changes, and visualize repository docs as HTML diagrams.

Automatically maintain a fractal multi-level index system that syncs file headers, folder indexes, and a project-level dependency graph (Mermaid) across 10 languages. Supports incremental updates, consistency checks with optional auto-fix, and runs on file changes or manual commands.

Generate and manage AI context artifacts (skills, rules, agents, commands, hooks) for project bootstrap, capture learnings, create Mermaid diagrams, and produce recipe sheets, guided by interactive project surveys and architecture Q&A.

Accelerate Claude Code plugin and skill development by scaffolding new skills from scratch, editing YAML configs and hooks with quick-reference guides, engineering optimal prompts using Anthropic techniques, generating Mermaid diagrams for visualization, and uploading artifacts via scripts without consuming context.

Generate and validate UML, Mermaid, D2, Graphviz, and Kroki diagrams directly in Claude Code via a remote MCP server, producing shareable view URLs for immediate visualization and review in conversations.

Orchestrate the full SDLC from idea to production with specialized agents for product discovery, architecture, TDD implementation, QA, security auditing, documentation, and deployment — all coordinated through a kanban-driven workflow with persistent project memory and quality gates.

Test AI-assisted IDEs and coding agents for 25 security vulnerability patterns across code execution, prompt injection, data exfiltration, and trust persistence by mapping attack surfaces, planning multi-stage chains, auditing source code, and exploiting interaction tiers from zero-click to trusted workspace.

Analyze your codebase to generate C4 architecture models in Structurizr DSL for system context, container, component, and deployment diagrams. Validate via Docker CLI and export renders to PlantUML, Mermaid, PNG, or SVG images.

Formalize scientific papers, textbooks, or knowledge sources into structured Gaia knowledge packages via a six-pass process: extract propositions, connect reasoning, assign priors, compile DSL to IR, then generate Obsidian vaults, Mermaid graphs, READMEs, and publish to GitHub.

Generate, edit, and animate images and videos directly in your terminal by building and executing ComfyUI Stable Diffusion workflows, with support for advanced models like Flux, WAN, Qwen, and LTX-V2

Orchestrate the full Stateless Agent Methodology (SAM) development pipeline: capture and groom backlog items as GitHub issues, discover requirements, plan features with dependency graphs, dispatch parallel agent teams for execution, run automated code reviews and forensic verification, and certify implementations against original goals.

Develop causal diagrams (DAGs) from social-science research questions, theory, or literature, and render publication-ready figures using Mermaid, R's ggdag, or Python's networkx.

Gain specialized AI expertise for Bevy ECS game development in Rust, Godot scene manipulation and interactive runtime testing, GLSL fragment shaders on Shadertoy, live-coding algorithmic music with Strudel and Pattrns, domain-driven design modeling with Mermaid diagrams, and quick references for Claude Code plugins to streamline creative coding and game projects.

Automate end-to-end development workflows in git repos: bootstrap projects, generate PRDs and designs, build/verify features via task agents, audit code hygiene across Rust/JS/Python/Go/Java/Ruby, handle PR reviews/feedback/fixes, and archive completions with structured docs.

Run structured, interview-driven PRD creation from rough ideas or bug reports — generates comprehensive Markdown documents with Mermaid diagrams, gap analysis, and task breakdowns.

Orchestrate complete AI-human writing workflows via Betty Flowers' Madman-Architect-Carpenter-Judge framework: ingest research into Markdown vaults, brainstorm raw ideas, generate Mermaid outlines, draft clear prose, apply whirlybird editing, optimize SEO, score quality across 10 dimensions, and plan multi-article strategies.

Follow the stack-agnostic AI Unified Process methodology to generate structured software requirements catalogs, entity models with Mermaid ER diagrams and validation rules, PlantUML use case diagrams, and detailed use case specifications with flows and business rules.

Develop idiomatic Go codebases with best-practice guidance on organization, errors, interfaces, concurrency; generate table-driven tests, benchmarks, fuzzing; profile CPU/memory hotspots for optimization; auto-fix lints, dead code, builds iteratively; systematically debug races, panics, deadlocks using pprof, Delve, git blame.

Interactively learn about any codebase through Socratic tutoring on files, functions, or concepts; visualize code structure and architecture with Mermaid diagrams at multiple granularities; and generate concise project briefings from git status and context to understand project state, progress, blockers, and next steps.

Retrieve and reproduce DoView Planning handbook diagrams as Mermaid blocks or PNG fallback URLs to accompany outcomes-theory answers. Triggered when user asks to see diagrams or says 'show me the picture'.

Routes documentation auditing, authoring, and optimization to specialist agents: audits docs-code drift, syncs docs after code changes, optimizes AI prompts and CLAUDE.md/SKILL.md files for Anthropic best practices, validates GLFM/Markdown formatting, and summarizes files/URLs/images with fidelity enforcement.

Run an intelligent orchestration platform that routes coding tasks to the best AI model, enforces quality through multi-model consensus with voting, and executes a full development pipeline from specification to release — including code generation, testing, documentation, security review, and infrastructure management via 46 MCP tools and specialized agents.

Enforces a complete Specification-Driven Development workflow across 8 documentation layers (BRD → IPLAN), with agents and skills to author, audit, fix, and trace artifacts, plus gates for code implementation, security review, and release governance.

Execute CLI utilities like fd/rg for file/code search, jq/yq/nushell for JSON/YAML/data processing, shell scripts for automation, ImageMagick for image conversion, Mermaid/D2 for diagram generation, binary analysis tools, project dependency installation, and AI image creation directly in your workflow.

Enforces structured software development workflows with guardrails, quality gates, and knowledge accrual. Orchestrates multi-agent reviews, generates documentation (Diataxis, ADRs, OpenAPI specs), manages work items, and runs security/penetration testing engagements.

Run structured AI-driven agile development workflows using 100+ skills and 22 agents: initialize projects, create PRDs/epics/stories/GDDs, implement code with tests via engineer/QA agents, sprint planning/status/retrospectives, architecture/design, and reviews for software or games.

Generate Mermaid/ASCII diagrams from descriptions, explain code with narratives and breakdowns, coauthor READMEs/API/architecture docs/proposals/decision records, manage ADRs/RFCs with auto-numbering/indexing, audit doc freshness/staleness/inconsistencies, ensure Diataxis structure, and review quality.

Generate and maintain project documentation including architecture diagrams, knowledge bases, and onboarding overviews using Mermaid diagrams and map-reduce analysis. Also performs security validation and strategic analysis with quantified trade-offs.

Generate product roadmaps, user stories with acceptance criteria, architecture designs, API contracts, and data models by synthesizing codebase analysis, docs, and git history. Detect context drift, prioritize features, track blockers, and critique artifacts via multi-agent orchestration for project health checks and planning.

Decompose implementation plans into file-dependency-aware tasks, automatically group into parallel-executable Waves avoiding edit conflicts, and output Mermaid dependency graphs plus directory-split TODO lists for streamlined team implementation.

Orchestrate a structured feature development workflow from requirements gathering to implementation, validation, and review, with subagent-powered planning, parallel coding, and quality checks

Generate multi-level C4 diagrams in PlantUML format (with optional PNG images and analysis) or Mermaid diagrams in Markdown from Feature Design Document Markdown files, automating visualization of system architecture and components directly from specs.

Enforce microservice architecture rules by defining contracts in SERVICE_MAP.yaml, then auto-generating Mermaid diagrams, validating code conformance, and blocking changes that violate the spec.

Orchestrate multi-agent AI workflows that decompose high-level development plans into sequential tasks, dispatch researcher, coder, and reviewer agents to explore codebases, implement features, perform code reviews for security and quality, and verify spec alignment using supervisor loops and composable skills.

Provides a library of reusable AI agent skills for automating business tasks including competitive intelligence monitoring, lead qualification, proposal generation, and content creation, with integrations for Baidu's PaddlePaddle and ERNIE platforms.

Generate professional diagrams from text prompts, automatically routing to optimal formats like SVG for precise visuals, Mermaid for flowcharts and git graphs, D2 for architectures, or Excalidraw for sketches, while applying consistent design principles for color, typography, and accessibility across all outputs.

Generate visuals across 11 channels including raster, SVG, web, interactive, video, terminal, diagrams, and infographics while enforcing brand tokens, 8:1 contrast minimum, custom dimensions, and style guides. Critique produced PNG/JPG/SVG/PDF artifacts with a vision-model agent that evaluates design principles (Tufte/Bertin/Gestalt), channel anti-patterns, and brand compliance, providing evidence-based PASS/NEEDS REVISION/FAIL verdicts.

Adds human-in-the-loop decision gates and rich terminal rendering to agent workflows. Pause execution for structured approvals, free-text input, or markdown review, and display diagrams, charts, code diffs, and callouts as formatted ANSI output.

Export Markdown files to Word (.docx) using a Windows + Microsoft Word pipeline, with support for templates, LaTeX-to-Office Math conversion, Mermaid diagrams, and academic paper styling.

Turn plain-English goals into tracked, evidence-driven workflow phases with status diagrams, plain-language decisions, retrospectives, and regression-aware improvement suggestions for Claude Code and Codex.

Execute a structured 3-phase Drupal development workflow—Research patterns and requirements, Architecture design with SOLID/DRY enforcement and Mermaid diagrams, Implementation via TDD cycles—using agents, skills, and commands that validate code standards, security gates, and task progress before completion.

Visualize and explore Convex database schemas with an interactive browser, Mermaid ER diagrams, and real-time metrics dashboards to browse tables, inspect documents, and understand relationships.

Accelerate AI-assisted development with a skills catalog for agentic CLIs: enforce Python/uv conventions, generate PRs from diff context, resolve merge conflicts, scaffold cross-tool agent skills, create structured GitHub issues, render Mermaid diagrams, audit code for production readiness, and capture session learnings into AGENTS.md.

Implement OpenSpec methodology in Claude Code projects: bootstrap structure, generate bounded change proposals with designs and tasks, execute via gated implementations with AI reviews and tests, manage persistent context across sessions, perform retrospective analysis, anonymize PII, and orchestrate 50+ cognitive tools for workflow automation.

Run fully autonomous AI coding sessions that generate step-by-step plans, execute tasks with self-critique and best practices, enforce file policies to prevent clutter, block risky commands via safety guards, manage tmux for isolated testing, and export refined plans.

Author, validate, and generate Event Model DSL files in Mermaid syntax within Markdown — auto-slicing from canonical patterns, seeding from a hotel-booking example, and checking information completeness by tracing UI/read model fields back to events and commands.

Build a Korean technical knowledge base by recording Q&A on math, topology, ML, and domains as categorized Markdown files with Mermaid diagrams in docs/qa/, merging them into a single CONCEPTS.md reference with TOC, listing entries in tables with filters and stats, and generating professional READMEs, API docs, and guides via templates and style rules.

Generate Google-SRE-style blameless incident postmortems from a tracker URL. The agent gathers evidence from Slack, Datadog, and pull requests, builds a chronological timeline with evidence tags, and writes a markdown document with summary, impact, timeline, root cause, and action items.

Run end-to-end guided product discovery on an idea through 10 phases, producing a structured PRD with Mermaid wireframes, user journeys, and architecture diagrams for validation and shaping.

Orchestrate end-to-end project development with a gated release pipeline: manage ideas, tasks, releases, documentation, test coverage, and automated subagent workflows across any tech stack.

Test voice agents from Retell, VAPI, LiveKit, Bland, and Telnyx using CLI commands: simulate LLM conversations, evaluate metrics with pass/fail reports, transcripts, and fix suggestions. Export definitions to Mermaid flowcharts, Python code, or other formats; convert between platforms; manage agent databases.

Analyze codebases with grep and glob tools to generate Mermaid diagrams visualizing architecture: flowcharts for processes, sequence diagrams for interactions, class diagrams for structures, ER diagrams for data models, and state diagrams for behaviors.

Automate executive director workflows for trade associations and nonprofits by analyzing organizational documents, scoring automation potential, generating LangGraph-based multi-agent workflows, and deploying specialized agents for communications, compliance, finance, membership, board meetings, and social media.

Draw UML and architecture diagrams from real code with a 3-tier gated pipeline that audits business correctness, diagram-code alignment, and notation quality before rendering, plus an adversarial auditor that cross-module verifies diagrams against actual code with file:line evidence.

Run spec-driven PDCA DevOps sprints with role-based AI agents that clarify requirements, generate PRDs/specs/diagrams, manage Markdown sprint boards, scaffold projects/tests, perform code reviews/security audits/QA, trace execution flows, create PRs/releases, and orchestrate isolated git worktree executions.

Generate visual-first explanations of codebases, architectures, and comparisons using ASCII diagrams or Mermaid graphs, with responses that begin with a diagram and add prose only for nuance.

Generate PNG images from Mermaid diagram source code and embed them in Markdown documents, automating diagram creation and documentation updates.

Automate full feature workflow: create Notion-synced .spec/ tasks, generate specs/DB/arch diagrams, build/review Java backend code with Agent Teams, verify acceptance in Chrome browser, batch sync completions to Notion with Git commits.

Run an AI-guided PCB design pipeline from a KiCad project — interview-driven specification, architecture planning, SKiDL circuit coding with ERC validation, part sourcing via JLCPCB, datasheet collection, and modular code assembly with user approval gates.

Run structured 5-phase AI workflows on projects or features: initialize with codebase scans, brainstorm requirements and designs, handoff to multi-agent teams for TDD execution, verify compliance and coverage, then debug post-ship issues—all with progress tracking and git isolation.

Integrate 14 curated skills and hooks into Claude Code to automate test detection/running/fixing across JavaScript/Python/Go/Rust/Java/Ruby/Elixir/PHP, generate Mermaid diagrams for code visualization, refactor to OO/FP styles, roast design flaws, review performance/DB schemas/cloud costs, proofread docs, analyze coverage gaps, and enforce security guardrails before/after edits.

Orchestrates AI-driven multi-agent development workflow across multi-repo projects, from story refinement and requirements analysis to code implementation, review, testing, and PR creation, with automated guardrails and human approval gates.

Review documentation, prose, and code for quality issues using parallel agents that check content accuracy, style consistency, markdown formatting, and AI writing tropes, while enforcing writing style rules and blocking risky shell or git commands.

Generate Mermaid diagrams from prompts to visualize class models, sequence diagrams, flowcharts, ERDs, C4 architecture, git graphs, and Gantt charts for software documentation, design, and process overviews.

Create interactive web-based slide decks for technical presentations, talks, and workshops using Slidev. Author with Markdown, embed Vue components, add syntax-highlighted code, animations, interactive demos, LaTeX equations, and Mermaid diagrams directly in your workflow.

Validate project documentation quality by linting Markdown formatting and naming, checking broken and orphan links, verifying glossary terms and synonyms, detecting contradictions and gaps, and auditing completeness. Apply interactive fixes, run in batch mode, and generate Mermaid graphs for reviews via skills and commands.

Generates wiki-style documentation for a codebase through a phased workflow: scans repository structure, designs a table of contents, produces Markdown docs with Mermaid diagram validation, and supports incremental updates to keep docs in sync with code changes

Design scalable system architectures using structured frameworks, generate C4 diagrams and data flows in Mermaid, write ADRs, evaluate tech trade-offs, break projects into sprints and tasks, analyze codebases for organization and flows with diagrams, and review feature specs for readiness with scores and feedback.

Provides a comprehensive .NET development assistant for Claude Code that handles the full lifecycle of .NET projects: scaffolding, coding with C# and ASP.NET Core, debugging, testing, CI/CD, UI development across Blazor/MAUI, AI/ML integration, and code review with specialized agents for architecture, security, performance, and documentation.

Generate Today I Learned (TIL) notes in Obsidian from Claude sessions, capturing architecture insights, code snippets, lessons learned, Mermaid diagrams, and frontmatter tags for organized documentation.

Auto-invalidate stale LSP caches in Claude Code when files are edited, keeping hover, definitions, references, and diagnostics fresh without manual restarts. Validates Mermaid diagrams and frontmatter after write/edit operations to catch syntax errors early.

Orchestrate cross-model AI consensus audits on code changes using quorum protocol with advocate/devil's advocate/judge roles, enforcing 5 gates via 26 MCP CLI tools and 115 agents for deterministic verification of code quality, security, performance, docs, RTM/FVM across TypeScript/Go/Python/Rust/Java projects.

Interactively create technical specifications for new features or projects: gather requirements, explore codebases, run planning interviews, draft Mermaid diagrams, iterate with expert review. Review specs using expert personas to identify gaps, risks, verify against repositories, discuss resolutions, and apply updates.

Generate lean Vietnamese PRDs via interviews, convert them to Gherkin .feature files with structured BDD scenarios in Rule blocks, create interactive low-fidelity HTML wireframes annotated with business rules, and implement features from Gherkin into step definitions and business logic code.

Generate and insert Mermaid diagrams into READMEs by analyzing your project's codebase, dependencies, and flows — covering architecture, data models, and sequences.

Embed LaTeX formulas, Desmos graphs, Mermaid diagrams, and TikZ visuals into Obsidian notes using simple code blocks to enhance documentation with interactive math and precise drawings. Invoke the agent to scan markdown files and automatically replace ASCII art with these professional embeds for clearer comprehension.

Automate end-to-end project workflows with parallel Claude agents: discover codebase structure, tech stack, and architecture; generate PRDs, phased plans, and task breakdowns; execute implementations; produce READMEs, API docs, and guides; run code quality assessments and STRIDE security reviews.