Mermaid plugins

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

Generate C4 architecture documentation (Context, Container, Component, Code) from a codebase using bottom-up analysis, producing Mermaid diagrams and structured docs in a dedicated directory.

Generate and maintain comprehensive documentation from any codebase: OpenAPI 3.1 specs, Mermaid diagrams, step-by-step tutorials, Architecture Decision Records, and automated changelogs. Supports CI/CD integration and includes agents for creating developer portals and technical references.

Orchestrate AI agents across the full software development lifecycle—from market research and product analysis through architecture, implementation, sprint management, code review, testing, and retrospectives.

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

Connect Figma designs to code workflows: generate components from designs, translate designs into production code (React, SwiftUI, CSS animations), create and maintain design systems, and build Figma files programmatically via the Figma API. Includes FigJam and Slides support.

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

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

Build multi-language source code graphs for security analysis, including call graphs, attack surface mapping, blast radius, taint propagation, and complexity hotspots. Generate Mermaid diagrams, compare graph snapshots for structural diff, triage mutation testing results, and extract crypto protocol flows into ProVerif formal verification models.

Generate production-grade engineering design diagrams (architecture, sequence, delta, drift) as self-contained dark-themed HTML files with inline SVG, grounded in real repo topology via Docker, Kubernetes, Terraform, and import graph analysis.

Provides a set of general-purpose utilities for root cause analysis, database diagramming with Mermaid from SQL schemas, community story contribution, and structured project development guidance.

Convert documents between formats (DOCX, PDF, PPTX, Markdown, HTML, Word), generate Mermaid diagrams as PNGs, create professional PDFs and slide decks, produce production-grade DOCX files, consolidate redundant documentation, and turn phone photos into scanner-quality PDFs.

Manage architecture governance across projects: create ADRs, assess compliance, generate risk registers, build strategic roadmaps with Wardley maps, and produce procurement artifacts — all aligned to UK government standards via 70+ slash commands.

Guides test-first (TDD/SDD) development from planning through implementation, verification, and debugging. Analyzes codebases to reverse-engineer specs, generates requirements and test cases, runs Playwright E2E tests, detects security vulnerabilities, and produces architecture diagrams and design documents.

Plan, track, and execute development work with structured specs, task isolation, autonomous PR babysitting, and multi-model review gates — all managed through a local .flow/ directory and CLI commands.

Generate structured architecture documents and system diagrams from user requirements, covering system boundaries, components, data flow, technology choices, and risks, with Mermaid or ASCII art visualization.

Organize knowledge using memory palace techniques — build virtual spatial structures, capture research from web and PR reviews, search across palaces with semantic/spatial queries, and maintain digital garden health with automated curation and diagramming.

Provides a suite of creative writing tools for drafting, revising, outlining, character development, and editorial review, enabling writers to plan stories, generate prose, receive reader-simulated feedback, and maintain story consistency.

Design normalized database schemas via an interactive interview that outputs SQL DDL and text ERDs, and automatically generate Mermaid ERDs from existing ORM models, migration files, or live databases.

Analyze your codebase to generate a project overview, map dependencies, classify modules, and identify circular dependencies or single points of failure. Outputs text or Mermaid-format diagrams.

Analyze any codebase with parallel agents to produce structured documentation on architecture, dependencies, data flow, request flow, and APIs. Generate README with Mermaid and C4 diagrams, plus AI assistant config files (CLAUDE.md, AGENTS.md, Cursor rules) to onboard AI tools.

Create, preview, and refine Mermaid diagrams (flowcharts, sequence, class, ER, state, Gantt) with live SVG reload and save, enabling iterative diagramming workflows directly in Claude Code.

Create, edit, and export draw.io diagrams offline using a YAML-first CLI workflow. Supports architecture, flowcharts, UML, ER diagrams, and conversion from Mermaid/CSV. Also applies academic venue policies to produce publication-ready figures for papers and theses.

Analyze any open-source Git repository to generate deep architectural reports with business insights, design rationale, Mermaid diagrams, and critical evaluations. Use for studying frameworks, comparing projects, or architecture research.

Enforce a dual-review, state-machine-gated development workflow with hook-enforced code review, pre-commit checks, test coverage analysis, and fail-closed safety gates across feature development, bug fixes, and refactoring.

Generate and format Mermaid diagrams as SVG or ASCII art with 15+ themes for flowcharts, sequence, state, class, and ER diagrams, suitable for documentation and terminal output.

Extract Miro board content (diagrams, documents, specs) into local files for AI-assisted planning, and create diagrams, tables, and documents on Miro boards from code reviews, architecture analysis, or project requirements.

Automates productivity workflows across Notion, Google Workspace, Todoist, Anki, and Raindrop.io, generates and edits images via OpenAI and Gemini APIs, converts documents to Markdown, searches codebases with natural language, retrieves live library docs, renders Mermaid diagrams, and manages Redis key-value stores.

Analyze US-listed stocks with a multi-method research suite combining fundamentals, technicals, competitive moats, insider trading, institutional ownership, DCF valuation, short interest, and sector rotation — outputs structured reports with financial charts and professional HTML summaries.

Automates content creation, publishing to platforms like Substack, X, and 知识星球, and security scanning for Next.js and Python projects, while enhancing developer workflows with session management and interactive UI components.

Manage Emacs buffers and files directly from Claude Code via emacsclient, with skills for opening, highlighting, and selecting regions in files, plus diagram generation, data plotting, Xcode iOS builds, and GitHub project health analysis.

Augments Claude Code with a versatile skill pack for code quality, documentation, AI integration, git workflow automation, and frontend design. Covers Go/Neovim best practices, external AI second opinions, config extraction, CLAUDE.md auditing, UI/image generation, hypothesis testing, Mermaid diagrams, pattern detection, Socratic questioning, functional programming, command creation, and parallel workstreams.

Provides a comprehensive .NET development workflow covering architecture design, code generation, testing, security review, performance analysis, deployment, and documentation for modern C#, ASP.NET, Blazor, MAUI, and cloud-native applications.

Enforce AI-first code conventions, audit staged diffs for OWASP security issues, generate architecture docs and session summaries, and check tool-stack freshness — all via skills, hooks, and agents that complement other plugins.

Render agent findings as styled, self-contained HTML reports in the browser with dark/light themes, severity cards, Mermaid diagrams, and collapsible sections — triggered for full reports or when CLI output exceeds 40 lines.

Design user flows with Mermaid flowcharts covering happy paths, error/empty states, decision points, and friction points for product features and briefs.

Generate and maintain architecture documentation, ADRs, changelogs, system diagrams, onboarding guides, and stakeholder presentations from your codebase and conversations.

Design user flows, information architecture, wireframes, and interactive HTML prototypes for frontend applications, with usability heuristics evaluation and code-based UX scanning to map existing UI before redesign.

Design, verify, and deploy FPGA/ASIC hardware using natural language — generate RTL modules, testbenches, formal properties, and constraint files; run linting, simulation, synthesis, and place-and-route; manage IP blocks and PCB layouts.

Reverse-engineer legacy codebases into living documentation with Mermaid diagrams, business rules, and risk maps, then run multi-agent risk audits that hunt down OWASP vulnerabilities, concurrency issues, scalability bottlenecks, and chaos failure scenarios — all consolidated into an executive Confidence Report.

Automate legal project management tasks across the full matter lifecycle — setup, execution, billing, team coordination, client reporting, and close, with tools for Gantt charts, RAID logs, and budget tracking.

Search code and files with ripgrep and fd, transform JSON/YAML with jq/yq, generate diagrams from Mermaid/D2 text, process images with ImageMagick, and automate shell workflows — all from Claude Code.

Facilitate structured brainstorming sessions using the Arete cognitive protocol—guide thinking through GROUND (problem discovery), EXPLORE (divergent), DECIDE (convergent), STRESS (stress-test), and SHIP (artifact generation) phases. Includes skills for problem discovery, trade-off analysis, plan generation, and stress-testing, plus agents for research and creating Mermaid diagrams and concept explanations.

Generate Mermaid diagrams from source code analysis or text descriptions, with validation and rendering. Automatically create ER, sequence, architecture, and state diagrams from codebases, and render diagrams to SVG with customizable themes.

Structures Claude Code's workflow for development tasks: clarifies ambiguous requirements, creates design briefs and project documentation, generates HTML visualizations from repo docs, reviews code changes, commits with conventional commits, and executes implementation plans.

Automatically maintain a multi-level fractal documentation index that syncs file headers, folder indexes, and a root project index with Mermaid dependency graphs. Includes health checks, manual init/update commands, and auto-update on file changes.

Provides curated domain-specific skills for game engine development (Bevy, Godot), creative coding with shaders and algorithmic music, and domain modeling with type-driven design and diagram generation. Includes guidance for project organization, debugging, and automation.

Bootstrap and maintain AI project context by generating skills, rules, agents, commands, hooks, Mermaid diagrams, and memory files, with guided architecture exploration and learning capture.

Provides opinionated best practices and code generation for full-stack development: clean architecture patterns (DDD, Hexagonal), frontend Feature-Sliced Design, PostgreSQL/Drizzle schemas, modern JavaScript & CSS, Slack and Teams messaging payloads, and Mermaid diagrams.

Structured product-thinking discipline for AI agents — guides discovery, delivery, and strategy with evidence-gated gates, diamond phases, and 58 skills. Assesses risk, validates assumptions, audits compliance, and surfaces health metrics to keep agent-driven work aligned with outcomes.

Guides developers through creating, editing, and debugging Claude Code skills, agents, and configs while supporting context engineering, Mermaid diagram generation, and artifact uploads to ClosedLoop without consuming conversation context.

Create and manage Slidev presentations with enforced design guardrails, multi-platform diagrams (Mermaid, PlantUML, Excalidraw), LaTeX handouts, and automated slide renumbering.

Generate, edit, and animate images and videos using ComfyUI workflows directly from Claude Code — build text-to-image/video pipelines, run parameter sweeps, diagnose failures, install custom nodes, and visualize workflow graphs.

Analyze codebase architecture and generate C4 model diagrams (system context, container, component, deployment) using Structurizr DSL, with export to PlantUML, Mermaid, PNG, and SVG.

Generate UML, Mermaid, D2, Graphviz, and Kroki diagrams from text descriptions, with options to create shareable URLs or save files locally.

Generate, validate, and render D2 diagrams from source code, text descriptions, or Mermaid diagrams, with automatic diagram type detection and configurable output settings.

Orchestrates a multi-agent AI harness for React Native and Expo development, enabling autonomous feature implementation, code review, performance profiling, visual debugging, and version migration through coordinated agents and commands.

Enforces hypothesis-driven debugging and scientific methodology for software investigations, with structured templates for root cause analysis, controlled experiments, and post-investigation retrospectives.

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

Build structured Product Requirements Documents (PRDs) through guided interview-driven discovery, covering features, bug fixes, and products, with Mermaid diagrams, gap analysis, and task planning.

Guide long-form writing from research to publication using a structured creative cycle: brainstorm raw material, organize into outlines, draft section by section, edit for style and SEO, and score quality across ten dimensions. Supports multi-article content strategies and captures research as structured notes.

Orchestrates end-to-end feature development workflows from project chartering and PRD creation through implementation, code review, testing, and archival. Automates PR feedback triage, code quality audits, bug investigation, and visual diff generation for structured, repeatable development cycles.

Create structured requirements and design artifacts using the AI Unified Process methodology: entity-relationship models with Mermaid, use case diagrams with PlantUML, and formal use case specifications with actors, flows, and business rules.

Run interactive learning sessions that investigate project state, visualize code architecture with Mermaid diagrams, and tutor you through Socratic questioning on files, functions, or concepts.

Takazudo's personal plugin pack provides 100+ skills and agents for git workflows, Cloudflare development, code review, documentation writing (Japanese/English), component design, PR management, PCB design, and dev environment automation.

Converts bullet steps, ASCII art, markdown tables, and prose workflows into Mermaid diagrams for AI-facing documents, with built-in process quality methodology to improve ambiguous or incomplete processes before conversion.

Implements a complete Specification-Driven Development workflow across 8 documentation layers (BRD, PRD, EARS, BDD, ADR, SPEC, TDD, IPLAN) with automated generation, validation, audit/fix cycles, traceability enforcement, and AI agents for architecture, testing, security, code review, and CI/CD orchestration.

Generates and maintains a project documentation wiki with auto-detected architecture, ORM entity mapping, Mermaid diagrams, health checks, and cost monitoring — all driven by slash commands and specialized agents.

Orchestrates a full SDLC pipeline from backlog capture through planning, parallel task execution, code review, and goal-backward verification, using multi-agent teams and structured artifacts.

Declare and validate architecture contracts using SERVICE_MAP.yaml specs. Bootstrap service docs, audit microservice contracts for consistency, generate Mermaid diagrams from YAML, then implement changes via TDD against the spec.

Automatically generate and maintain comprehensive documentation and knowledge bases from codebases, including architecture diagrams, concept maps, module breakdowns, and project overviews. Also performs security validation, strategic analysis, and deep research, all with Mermaid diagram support.

Turns Mermaid diagrams into clickable preview links (mmd.dyu.sh) so you can share or open diagrams in a browser without copy-paste

Decompose implementation plans into file-level tasks, analyze file dependencies to group non-conflicting edits into parallel Waves for concurrent execution. Outputs Mermaid dependency graphs and directory-split TODO lists.

Generate C4 architecture diagrams (PlantUML) and Mermaid sequence, flowchart, class, and ER diagrams directly from Feature Design Documents, producing self-contained markdown or PNG outputs for system documentation.

Audits documentation against source code for drift, syncs docs after code changes, optimizes AI-facing prompts and SKILL.md files, validates GLFM/Markdown formatting, and summarizes files, URLs, and images with citation support.

Orchestrates multi-agent development workflows by decomposing plans into tasks, dispatching autonomous agents for implementation, code review, and research, and enforcing code quality and documentation conventions.

Automates AI ecosystem workflows for Baidu PaddlePaddle/ERNIE: partner registration, product certification review, social media monitoring, lead generation, technical proposal generation, and market intelligence collection across Chinese platforms.

Generate and audit visual artifacts across 11 output channels with enforced brand tokens, contrast ratios, and design principles, using a vision-model critic for quality assurance.

Pause agent execution for human-in-the-loop decisions (approval gates, design tradeoffs, multi-option picks) and render rich ANSI terminal output with diagrams, charts, code diffs, and structured layouts.

Orchestrate the end-to-end lifecycle of analytics data platforms: discovery, requirements, data modeling, ingestion, orchestration, semantic layers, dashboards, testing, deployment, and handover — with agentic audit, migration, and validation workflows for BigQuery, Snowflake, dbt, Looker, Amplitude, Fivetran, Airbyte, and more.

Turn plain-English goals into structured, evidence-driven workflows with automated phase progression, decision recording, and retrospective analysis. Generate architecture diagrams and track completion with verifiable proof.

Export Markdown to .docx, .mht, and .wordmath.docx using Windows + Microsoft Word, with support for reusable templates, LaTeX-to-Office Math conversion, Mermaid diagrams, and academic paper styling.

Conduct structured market research with competitive analysis, trend modeling, TAM/SAM/SOM sizing, and adversarial falsification, then generate reports and GitHub issues from findings

Generate comprehensive code documentation, architecture diagrams, and step-by-step tutorials from existing codebases, with automated CI/CD doc generation and AI-powered code review for quality and security.

Orchestrates a complete feature-development workflow: plan specs, DB schemas, and architecture in .spec/ files, generate code via agent teams, run parallel code reviews and security scans, verify acceptance criteria in a live browser, and batch-sync everything to Notion on task closure.

Enforce a TDD-first team workflow where every change starts with a plan and tests, then accumulates into a self-running regression suite with Slack/Discord reporting and cross-repo handoff tracking.

Provides the BMAD method for AI-driven agile development, enabling project scaffolding, product briefs, PRD validation, sprint planning, story implementation, automated testing, code review, and retrospectives, with specialized workflows for game development in Godot and Unity.

Explore and visualize Convex database schemas with an interactive table browser, Mermaid ER diagrams, and real-time metrics dashboards. Inspect documents, understand relationships, and generate schema diagrams directly from the database.

A multi-skill catalog that equips Claude Code with agentic workflows for code review, git operations, documentation, knowledge capture, and cross-tool compatibility across Claude, Codex, and Gemini CLI agents.

Generate, review, and maintain project documentation including architecture decision records, RFCs, diagrams, and READMEs with drift detection and health audits

Orchestrate multi-agent AI teams through a complete software development lifecycle using spec-driven TDD, milestone planning, quality gates, environment-aware deployment, and cross-project learning.

Author, validate, and generate Event Model DSL files in Mermaid syntax inside Markdown. Seed projects with canonical models, auto-slice using four Event Modeling patterns, validate information completeness, and produce standalone slice specifications.

Generates hand-drawn sketch-style animated architecture diagrams and flowcharts as self-contained HTML (SVG+CSS) with ink lines, watercolor blocks, doodle icons, and flowing dot animations, then exports to a seamless looping GIF.

Generate Google-SRE-style blameless postmortems from an incident tracker URL (Jira or Azure DevOps). Automatically gathers evidence from Slack, Datadog, related issues, and pull requests, reconstructs a chronological timeline with evidence tags, and writes a markdown postmortem with sections like impact, root cause, timeline, and action items.

Guide product discovery through a structured 10-phase playbook to produce a structured PRD with Mermaid wireframes, user journeys, and architecture diagrams, enabling idea validation and product shaping.

Semi-automated research assistant for academic and policy research, integrating literature review, paper analysis, Obsidian knowledge management, structured policy analysis (Bardach framework), grant writing, and publication drafting with Takshashila Institution standards.