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.

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.

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.

Simulate multi-persona event storming and domain storytelling to model bounded contexts; generate ADRs, C4 diagrams, context maps, and architecture docs from codebases; analyze against TOGAF, Zachman, cloud frameworks; enforce .NET fitness functions and resilience patterns; detect over-engineering and validate principles.

Generates Mermaid diagrams visualizing codebase architecture, dependencies, data flows, call chains, class hierarchies, community-detected module boundaries, and workflows — helping developers understand, document, and analyze system structure for onboarding, PR reviews, and refactoring

Read, create, and update Miro board content directly from Claude — extract board specs to local files, add diagrams from text or Mermaid/PlantUML, create markdown documents and structured tables, and generate code review boards from pull requests or local changes.

Design, verify, synthesize, and deploy RTL with natural language — from SystemVerilog/FPGA codegen and linting to formal verification, simulation, place-and-route, and bitstream flashing, all orchestrated by AI agents

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

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.

Orchestrates full software development workflow from idea to production using specialized agents for product management, architecture, coding, QA, security, documentation, and deployment, with persistent memory and automated quality gates.

Ship web projects faster with an integrated workflow that plans, builds, tests, deploys, and monitors your application. Includes automated SEO audits (39 rules + AI visibility), penetration testing, code reviews, Lighthouse performance fixes, changelog generation, deployment pre-flight checks, and post-ship growth tracking.

Set up and maintain AI-ready repositories with repo conventions, architectural documentation (MADR ADRs, architecture diagrams), automatic git diff narration for code reviews, pre-commit security scanning for OWASP Top 10 vulnerabilities, flaky test diagnosis, stack freshness enforcement, and session summaries — designed for Claude Code and Codex workflows.

Design and visualize event-driven architectures for complex distributed systems using Event Modeling, Event Storming, CQRS, Event Sourcing, and Saga patterns. Generate Mermaid swimlane diagrams, facilitate interactive modeling sessions, assess architecture fit, and plan projections, versioning, orchestration, and compensating actions.

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 across 10 programming languages, keeping documentation and code structure always consistent.

Design contract-first APIs via OpenAPI 3.1, AsyncAPI 3.0, and Protocol Buffers from natural language requirements. Author formal specifications for systems, algorithms, and behaviors using TLA+, SysML, UML diagrams, state machines in Mermaid/PlantUML, and Use Case 2.0 templates for verification and modeling workflows.

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.

Generate standardized technical documentation for architecture (arc42/C4 with Mermaid), decisions (ADRs/RFCs), operations (runbooks), onboarding, and API portals. Automate docs-as-code pipelines integrating Git workflows, CI/CD, linting, and deployment best practices.

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.

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.

Run a complete SDLC pipeline where AI agents handle architecture, code review, QA, and security compliance across 50+ regulated domains, requiring only two human decisions per feature.

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.

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.

Generate and edit images and videos inside Claude Code using ComfyUI — build, visualize, and debug Stable Diffusion and Flux workflows, run parameter sweeps, diagnose failures, and orchestrate multi-step pipelines like portrait editing or story-to-video.

Create Wardley Maps from value chains to visualize component evolution, dependencies, and strategic positioning in technology contexts. Analyze evolution stages, assess organizational doctrine maturity, and identify competitive plays for decisions like buy vs build or orchestration strategy.

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.

Build and refine Product Requirements Documents (PRDs) through structured interactive interviews covering problem context, users, features, tech stack, business goals, UX, risks, and testing. Generate Markdown files with Mermaid diagrams for products, features, and bug fixes; analyze gaps in existing PRDs.

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.

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.

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.

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.

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

Audit documentation against code for drift, sync docs after code changes, optimize CLAUDE.md and SKILL.md prompts, validate GLFM/Markdown formatting, and summarize files, URLs, or images with source-attributed citations.

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.

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.

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.

Orchestrate multi-agent workflows with guardrails for systematic software engineering: design architectures, enforce quality via adversarial reviews, audit security/compliance, generate docs/diagrams/tests, track work across sessions, and accrue persistent knowledge in markdown artifacts.

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.

A personal collection of Claude Code skills, commands, and agents for automating development workflows: git operations, PR management, code review, CI/CD setup, documentation generation, and hardware design tasks.

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

Orchestrates a structured feature development workflow from requirements gathering through design, planning, parallel implementation, code review, validation, and testing, with automated checks at each stage.

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

Pause agent execution to collect human input for decisions, approvals, and reviews, then render markdown with diagrams, charts, and syntax highlighting as rich ANSI terminal output.

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.

Orchestrate multi-agent development teams where Claude Code spawns parallel sub-agents in isolated git worktrees, coordinates them via a 4-layer architecture (Master→Manager→Conductor→Agent), and automatically merges completed PRs. Includes session trace analysis, retrospection, DuckDB-powered metrics queries, and task lifecycle management.

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.

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.

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.

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.

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.

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.

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.

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.

Orchestrates the full AI-assisted SDLC workflow: from raw requirement clarification, spec generation, and design decisions through implementation planning, parallel task execution, verification testing, and code review — all within structured Git branches and Markdown SSOT documents.

Automate the full project lifecycle from idea generation through release management using an 8-skill framework. Scaffold projects, manage tasks and proposals, generate documentation with Mermaid diagrams, enforce test coverage, and guard against destructive git commands and hardcoded secrets — all driven by subagent orchestration and a gated release pipeline.

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.

Analyze executive director responsibilities for trade associations and nonprofits, score automation potential with a 6-factor algorithm, generate production-ready LangGraph workflows with agents, and deploy to dev/staging/production environments with monitoring and rollback.

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 PNG images from Mermaid diagram source code and embed them in Markdown documents, automating diagram creation and documentation updates.

Automates KiCad PCB design using SKiDL — conducts design interviews, generates architecture docs, sources parts from JLCPCB, writes and validates SKiDL circuits, runs ERC, and exports netlists through a gated multi-agent pipeline.

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.

Reviews technical and prose documents for content accuracy, style consistency, and artifact quality using parallel agent evaluations, while enforcing writing rules and blocking destructive commands.

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.

Generate and maintain local wiki-style documentation for your codebase via a phased pipeline: scan repository structure, design table of contents, produce Markdown pages with Mermaid diagrams, validate syntax and files, create overviews, and perform incremental updates after changes. Run full workflow, structure-only, or single phases; outputs to ./docs/wiki/. Ideal for project overviews or post-refactor syncs.

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.

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.

Enforces team-wide coding standards (Alibaba Java, Effective Dart, universal rules), mandatory design documentation with Mermaid diagrams before coding, and maintains knowledge graphs for architecture, business logic, and code coordinates to prevent architectural decay and ensure traceability across projects.

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.

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.

Enforce test-driven development workflows with automated RED/GREEN/REFACTOR cycles, architecture decision records, and C4-modeled diagrams to guide software design and validation.

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.

Orchestrate a structured PRD/TDD/test-case authoring, subsprint planning/execution, and ADO sync workflow. Includes a local Markdown wiki viewer/editor to browse and edit docs directly from the project folder.