Documentation plugins

Programmatically create, edit, and manage Obsidian vaults: handle Markdown notes with wikilinks, embeds, and properties; build Bases for note databases with views and formulas; design Canvas diagrams with nodes and edges; search tasks, reload plugins, inspect DOM, capture screenshots, and extract clean Markdown from web pages.

Fetch up-to-date documentation, API references, and code examples for libraries, frameworks, SDKs, CLI tools, and cloud services via Context7 CLI. Quickly access syntax, configurations, migrations, setups, and debugging info during coding tasks. Manage AI coding skills, install/search/generate/remove/suggest them, and configure Context7 MCP.

Generate complete C4 architecture documentation—Context, Container, Component, and Code levels—via bottom-up analysis of your codebase. Specialized agents analyze code structure, synthesize higher-level views, map to deployment units, document APIs, and produce Mermaid diagrams, outputting everything to a C4-Documentation/ directory.

Generate investor-ready startup business analyses: calculate TAM/SAM/SOM market sizing, build 3-5 year financial models with cohort revenue, cash flow, burn rate, and scenarios; analyze competitive landscapes and team structures; benchmark metrics like CAC/LTV and ARR; produce full business case documents.

Unlock pro-level BMad workflows: analyze project states for skill recommendations and next steps, orchestrate multi-agent roundtables and debates for diverse insights, distill documents losslessly, shard large Markdown files, refine LLM outputs via advanced elicitation, review prose and structure, index directories, and audit code adversarially to uncover edge cases and omissions.

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.

Fetch up-to-date, version-specific documentation, API references, and code examples for libraries like React, Next.js, Vue, Prisma, and Supabase directly into your LLM context using Context7 skills, commands, agents, and MCP server. Query via /context7:docs <library> [query] or IDs for precise lookups on setup, usage, and APIs.

Optimize websites for search engines by analyzing content for E-E-A-T, readability, keyword cannibalization and duplication; validating schema.org data with impact scores; generating outlines, topic clusters, calendars, and full SEO-optimized articles with metas and FAQs.

Create and present interactive Slidev slide decks from Markdown, embedding Vue components, syntax-highlighted code, animations, LaTeX equations, Mermaid diagrams, and live demos for technical talks, code walkthroughs, tutorials, and conferences.

Design scalable backend architectures with CQRS, event sourcing, projections, sagas, Clean/Hexagonal/DDD patterns, and microservices; document decisions using ADRs; generate diagrams and analyze dependencies in modern stacks.

Delegate product strategy, legal reviews, licensing implementation, project management, UX research, business analysis, and operational tasks to 12 specialized AI subagents, streamlining non-coding workflows for software development and business growth.

Act as an editorial creative director to generate converting interactive portfolios for devs and creatives, p5.js generative art from algorithmic philosophies, refined marketing copy via clarity sweeps, visual design manifestos in Markdown/PDF/PNG, Python-powered brand voice and SEO analysis, and production-grade distinctive frontend UIs with DFII evaluation.

Automate office document workflows by creating, editing, analyzing DOCX/PPTX/PDF/XLSX files, processing Google Sheets/Slides via OAuth-enabled Python CLI, extracting text/tables to Markdown/CSV/JSON/Pandas, converting formats, and enforcing Excel standards for reports.

Generate structured PRDs, epics, feature specs, implementation plans with Mermaid diagrams, technical spikes, and GitHub issues from high-level ideas or requirements. Automate task creation, updates, and organization for SaaS projects in TypeScript/Next.js monorepos with Docker deployments.

Maintain open-source repositories with Claude Code skills that generate conventional commits featuring feat/fix types, issue references, and AI co-authorship; produce Markdown READMEs, changelogs, and docs; execute advanced Git operations like interactive rebase, cherry-pick, bisect, and worktrees; conduct structured code reviews; and handle PR creation workflows.

Generate Product Requirements Documents (PRDs) interactively by answering questions on feature goals, users, and scope, structuring them into user stories with acceptance criteria and non-goals, then convert to prd.json format for autonomous execution by the Ralph agent system.

Pull version-specific documentation and code examples from source repositories directly into your LLM context using Upstash's Context7 MCP server. Enable AI context persistence via vector storage, embeddings management, and semantic retrieval for precise, up-to-date assistance during development.

Debug GitHub Actions workflow failures by analyzing logs for root causes, flakiness, breaking commits, and fix PRs. Clone full or half conversations to new sessions for token-saving experimentation on alternatives. Generate HANDOFF.md summarizing project goals, progress, and next steps. Fetch Reddit content via Gemini CLI in tmux bypassing 403 blocks. Review conversation history to suggest CLAUDE.md improvements.

Build knowledge graphs from any codebase to visualize architecture, query dependencies and relationships, analyze git diffs/PR impacts, explain files/modules, generate onboarding guides and domain flows, plus interactive dashboard and guided tours.

Query local markdown notes, docs, and knowledge bases using lexical, vector, hybrid, and intent-aware searches via CLI or MCP server to retrieve precise information instantly. Automate end-to-end project releases by validating and updating CHANGELOG.md, installing git hooks, bumping versions in package.json, committing changes, creating tags, pushing to GitHub, and monitoring CI workflows.

Automate product management workflows: generate feature specs, PRDs, roadmaps, sprint plans, and stakeholder updates tailored to audiences. Synthesize user research into prioritized insights, review metrics with trends, and produce competitive briefs. Brainstorm ideas conversationally. Pull real-time data from 16+ tools including Jira, Linear, Amplitude, Notion, Figma, Slack via MCP integrations.

Use slash commands and skills to generate product strategy canvases (strategy, business model, lean, startup), market analyses (SWOT, PESTLE, Porter's Five Forces, Ansoff Matrix), value propositions, pricing strategies, and monetization plans in markdown for PM workflows, team alignment, and business validation.

Generate PRDs, OKRs, outcome roadmaps, user stories, job stories, sprint plans, release notes, and stakeholder maps. Run pre-mortems for risk analysis, retrospectives for team feedback, prioritization frameworks, meeting summaries, and test scenarios with dummy data to manage agile product execution workflows.

Streamline full engineering workflows: generate standups from git/PR activity, run code reviews and debugging sessions, create architecture ADRs and test plans, manage incidents with PagerDuty/Datadog, produce deployment checklists and technical docs. Integrates natively with GitHub, Jira, Linear, Slack, Notion via MCPs for seamless tool access.

Open PDFs from URLs, paths, or arXiv in an interactive viewer to annotate sections collaboratively via screenshots, fill forms with live visual feedback, add signatures and stamps on approval, then download the marked-up document for contracts and approvals.

Streamline business and devops operations by generating SOPs with RACI matrices and flowcharts, leadership reports, risk assessments, vendor evaluations, compliance trackers, capacity forecasts, process optimizations, runbooks, and change requests. Connect to Jira, Slack, Notion, ServiceNow, Asana, and more for integrated workflow management, ticketing, and collaboration.

Query natural language searches across enterprise tools like Slack, Jira, Notion, Asana, Gmail, Microsoft 365, and docs. Decompose intents into sub-queries, search sources in parallel, synthesize coherent answers with citations, confidence scores, and digests of activity.

Triage support tickets by prioritizing and routing; research customer context across HubSpot, Intercom, Jira, Slack, Notion, and other tools; draft professional responses, escalation briefs, and publish-ready knowledge base articles from resolutions.

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.

Execute a production-grade academic research pipeline in Claude Code: deep research, outline generation, paper drafting, literature reviews, peer review simulation, revisions with response letters, citation checks, venue disclosures, format conversions (LaTeX, DOCX, PDF, Markdown), and finalization for scholarly publishing.

Draft customized NDAs and privacy policies with jurisdiction clauses, compliance checklists, and legal review flags. Review PM resumes against best practices, tailor them to job descriptions with keyword alignment and gap analysis, and proofread text for grammar, logic, and flow issues with categorized fixes.

Generate self-contained HTML pages visualizing git diffs, code reviews, implementation plans, project recaps, diagrams, slide decks, and fact-checked docs. Compare plans against codebase, analyze changes with architecture views, and deploy visuals to Vercel for sharing.

Build and maintain a compounding Obsidian wiki vault as Claude's persistent knowledge base: bootstrap vault from description, ingest files/URLs/images/web research, create visual canvases/databases/notes, query answers from vault, lint for issues, roll up summaries, automate git commits across sessions/projects.

Migrate Lodash code to es-toolkit in JavaScript and TypeScript projects by replacing imports and comparing APIs to shrink bundle sizes, get function recommendations matching your needs or code with imports examples and docs, and follow tailored setup guides for Node.js Bun Deno and browsers to optimize performance.

Build Claude Code plugins by replicating demonstrated skills, legacy commands, and MCP server structures. Copy SKILL.md layouts, frontmatter options like name-description-argument-hint-allowed-tools-model, argument parsing, tool integrations (Read, Glob, Grep, Bash), reference templates, and content best practices for quick extension development.

Discover brand materials from Notion, Slack, Confluence, Gong, Figma, and more; distill into structured, LLM-ready guidelines; enforce consistent voice on AI-generated sales, marketing content like emails, proposals, and posts via generation, validation, and refinement.

Transform academic papers, articles, and concepts into structured Org-mode notes, visual PNG infographics/sketchnotes, critical essays, Q&A chains, paper lineages, word breakdowns, roundtable debates, and city research reports. Manage and sync Claude skills with maps and Git pushes.

Plan product launches by generating GTM strategies that identify beachhead segments, ideal customer profiles, growth loops, optimal motions across inbound/outbound/PLG, phased timelines with metrics, and sales-ready competitive battlecards using web research.

Merge multiple dbs-save diagnosis snapshots into a single shareable Markdown report for projects, featuring sections on user issues, conclusions, rejected paths, open problems, next steps, and an archive index. Trigger with /dbs-report or phrases like '出报告' for easy sharing and archiving.

Automate AI/ML academic research pipelines in Obsidian vaults: bootstrap project KBs, ingest papers from Zotero/arXiv/web into Sources/, synthesize literature reviews/gaps/method taxonomies, analyze experiments with stats/figures/reports, draft NeurIPS/ICML papers/rebuttals, manage note lifecycles/registry/index with git workflows.

Extract full design languages from any website URL into Tailwind configs, shadcn/ui CSS vars, Figma variables, React themes, DTCG tokens, and motion/voice specs. Generate WCAG audits, graded report cards, head-to-head battle pages, style remixes, theme recolors, brand guidelines books, and shippable design system bundles.

Generate editorial-quality technical and product diagrams—including architecture, flowcharts, sequences, ER models, timelines, and swimlanes—as standalone HTML files with inline SVG, customizable via style guide extracted from your brand website.

Query local knowledge base directories for answers to questions, navigating layered structures via data_structure.md. Search and process Markdown/TXT files with grep and read; handle PDFs and Excel sheets using pdfplumber and pandas for retrieval tasks.

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.

Run 10 AI agents to fully automate Obsidian vault management: triage Gmail/Hey emails and inbox notes, extract deadlines from Google Calendar, transcribe audio into structured notes, audit and defragment vault structure, generate weekly agendas, evolve knowledge graph, and handle multilingual inputs.

Research and contribute to the Model Context Protocol (MCP) specification by searching GitHub PRs, issues, and discussions across the modelcontextprotocol org using gh CLI and GraphQL with variant terms for prioritization and history dives, plus remote access to official docs, guides, and resources at modelcontextprotocol.io.

Persist coding knowledge across Claude Code sessions with Supermemory: capture architectural decisions, bug fixes, design patterns, and details from conversations into searchable project memory. Index codebase for ecosystem-aware context, search past implementations and preferences, manage config and auth for team reuse.

Create and edit Obsidian vault files directly, including Markdown notes (.md), Bases (.base), and Canvas (.canvas) files. Use a local stdio MCP server running Node.js to handle Quarto Markdown (QMD) documents as subprocess without needing secrets.

Query official Microsoft docs via MCP server or mslearn CLI to fetch concepts, tutorials, quickstarts, API references, verified code samples, limits, and best practices for Azure, .NET, M365, Windows, and Power Platform. Generate hybrid agent skills with dynamic lookups and troubleshoot SDK errors during coding or debugging.

Generate Mermaid diagrams including flowcharts, sequence diagrams, ERDs, C4 architecture, state machines, and Gantt charts directly from natural language descriptions of systems, workflows, or specifications to create visualizations for technical documentation.

Generate OpenAPI specs and Pact consumer contracts from API code, designs, or schemas to enable consumer-driven contract testing, documentation, code generation, verification tests, and CI/CD setup.

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.

Generate tailored legal documents like NDAs, freelancer agreements, privacy policies, and terms of service by scanning websites or apps for data practices. Review contracts via multi-agent analysis for risks, compliance gaps (GDPR/CCPA), missing protections, plain-English summaries, and negotiation proposals. Audit sites for regulatory adherence with scored reports and remediation roadmaps.

Scan complex codebases using perspectives like overall architecture, request lifecycle, and data flow to auto-generate recursive Mermaid diagrams. Launch an interactive web viewer to explore them locally and push docs to the cloud for sharing.

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.

Generate interactive, deployment-ready API documentation from OpenAPI specs, existing codebases, or live endpoints. Produce runnable examples in curl/JS/Python/Go, authentication guides, error references, and versioning support for quick sharing on Vercel or Netlify.

Scan your codebase and configurations to generate audit-ready Markdown compliance reports for PCI DSS, HIPAA, SOC 2, GDPR, and ISO 27001. Assess security controls, identify gaps, and produce project documentation using the 'crg' shortcut or embedded playbook.

Automate management of container registries like Docker Hub, AWS ECR, GCP Artifact Registry, and Azure ACR by handling tagging, lifecycle policies, replication, vulnerability scanning, and access controls. Generate standardized Markdown documentation with YAML metadata, features, examples, and invocation details for DevOps registry tools from a simple name and description.

Introspect PostgreSQL, MySQL, SQLite, and MongoDB schemas to generate Markdown documentation and interactive HTML reports with ERD diagrams, relationships, indexes, constraints, views, procedures, and data dictionaries for onboarding, audits, and compliance.

Deploy specialized AI agents to synthesize research from academic papers, web sources, and GitHub repos with citations; generate API docs, OpenAPI specs, and SDKs; transcribe, analyze, and optimize podcasts; modernize legacy code across React, Python, Java; build and link knowledge graphs; orchestrate multi-agent pipelines for complex tasks.

Generate professional Statements of Work (SOWs) for AI automation projects using a detailed markdown template that structures scope, deliverables, timeline, and pricing sections for quick client proposals.

Generate Mermaid diagrams to visualize and document software: class/domain models, API sequence flows, process flowcharts, database ERDs, C4 architecture, git graphs, Gantt charts, and more.

Automate Atlassian workflows by converting Confluence specs into Jira backlogs with epics and tickets, triaging bugs through duplicate searches and issue creation, extracting action items from notes into assigned tasks, generating JQL-powered status reports for Confluence, and searching across Jira, Confluence, Bitbucket, and docs.

Drive spec-driven development from one SPEC.md file: compress specs into caveman encoding (~75% token reduction), implement tasks via plan-execute loops with verification and commits, detect code-spec drift by invariants/interfaces/tasks, backprop bugs with root causes/invariants/tests/fixes.

Build, diagnose, upgrade, and proactively maintain research-backed knowledge systems via natural conversation, leveraging TFT-grounded architecture recommendations, vault health checks across 8 categories, interactive tutorials, and methodology queries from a 249-claim research graph.

Automate TechSmith Snagit screen captures and Camtasia video rendering/editing via Windows COM API and CLI using PowerShell or pywin32 Python scripts. Set up CI/CD pipelines, local dev loops with testing, error handling, performance tuning, security basics, and production checklists for documentation workflows and video production.

Develop features interactively from idea to implementation: generate EARS requirements, design documents, and task lists in .kiro/specs/, then execute tasks with focused coding assistance and actionable advice.

Automate comprehensive project management: audit health and permissions, generate architecture/user docs and roadmaps, handle git workflows/PRs/releases, test UX/onboarding/responsiveness via browser, consult multi-AI models, and post team updates with feedback triage.

Transform vague project requirements into actionable Product Requirements Documents (PRDs) through interactive dialogue, guided by systematic questions on functionality, tech stack, scope, and business context, with a 100-point clarity score to ensure precision before coding begins.

Polish English in CS/ML academic papers using section templates for abstracts, intros, methods, phrase banks, vocabulary suggestions, and 2-3 alternatives per revision to refine research writing quickly.

Run interactive interviews to transform high-level feature plans into detailed specifications covering implementation, UI/UX, tradeoffs, and edge cases, with responses automatically written back to your plan file.

Automate enterprise architecture governance and vendor procurement for UK projects: generate diagrams, ADRs, HLD/DLD reviews, roadmaps, Wardley maps, compliance assessments, strategies, and procurement docs from context; research AWS/Azure/GCP services, gov repos, vendors via agents and slash commands.

Act as an AI partner for Product Managers in Claude Code: prepare meeting agendas and role-plays, draft PRDs and briefs, generate stakeholder updates and weekly plans, audit codebases, conduct competitive analyses, prototype tools and dashboards, query databases for insights, critique ideas, design experiments, review metrics, with security hooks.

Equip AI coding assistants with 21 specialized skills to build, configure, and deploy Nuxt 4+ apps, covering authentication with Better Auth and Drizzle, styled UIs via Nuxt UI and Tailwind, content management with Nuxt Content v3, SEO modules, custom module development, NuxtHub databases, and Vue 3 patterns for rapid full-stack prototyping.

Clone GitHub repos of unfamiliar libraries and query an AI research agent to explore source code and docs, instantly answering API and usage questions like 'How do I use X?'

Generate and sync application design documents and tech stack documentation by analyzing codebase, package.json, git history, configs, and deployment details via interactive Q&A on project stage, priorities, and evolutions. Installs via shadcn-style registry with postinstall hooks for Claude AI.

Generate detailed, sectionized implementation plans for complex features from markdown spec files. Gepetto conducts research, simulates stakeholder interviews, synthesizes findings, creates plans, and refines through multi-LLM reviews. Resume and iterate from existing files for thorough pre-implementation analysis.

Automate end-to-end blog production: plan topic clusters and editorial calendars, generate SEO-optimized multilingual posts with AI citations, audit for E-E-A-T/quality/ cannibalization via Google APIs, add images/charts/schema/audio, repurpose for social, and sync CMS taxonomies using 28 skills and 5 agents.

Build scalable design systems by generating tokens, component specifications, documentation templates, naming conventions, icon systems, and pattern libraries. Audit for WCAG accessibility, consistency, token coverage, and theming support using dedicated skills and commands.

Orchestrate multi-agent workflows to review code for quality, security, performance, and architecture; generate structured documentation; debug and fix bugs iteratively; refactor with plans and tests; implement features with code and integration guides; create test strategies; and optimize bottlenecks with benchmarks.

Automate team workflows using slash commands to triage GitHub issues, balance workloads, plan sprints, generate standup reports, analyze retrospectives, map dependencies, estimate tasks, review architecture, and migrate projects between GitHub and Linear, pulling insights from git history and team data.

Start guided vibe sessions for project goals to track incremental development with plain-language progress summaries that hide technical diffs, logs, and noise. Advance steps one at a time, toggle verbose/learning/pause modes, and get jargon-free updates, verifications, next actions, and micro-explanations for non-technical pairing or oversight.

Search and read Apple's 405,000+ developer documents offline, covering iOS/macOS/visionOS APIs, SwiftUI/UIKit views, Foundation/Combine, HIG guidelines, Swift Evolution proposals, and code samples for rapid reference during development.

Generate structured design case studies, rationales, presentations, and UX copy for portfolios and stakeholders; create adoption strategies for design systems; audit design tokens in CSS code and Figma files for consistency, coverage, and gaps.

Automate office productivity workflows: generate Chinese PRDs via guided interviews and templates, draft patent applications with prior art search, create Feishu/Lark documents, and perform browser automation for web navigation, interaction, data extraction, and testing.

Deploy pre-built rules, skills, and commands to Claude Code for enforcing best practices across Go, Java, Python, frontend frameworks, Redis, and Bash; automate project setup with tech stack detection, generate technical docs and DOCX copyright filings, craft conventional commit messages, perform code reviews/optimizations, and patch tools for enhanced caching/web search.

Automate Chinese research paper workflows: brainstorm topics and structures interactively, synthesize literature from PubMed/arXiv with BibTeX, generate Python data visualizations/stats code using matplotlib/seaborn/scipy, draft evidence-driven chapters, peer-review with checklists, polish bilingual text, and compile publication-ready LaTeX with journal templates.

Manage projects end-to-end with Product as Code (PAC) slash commands: initialize repos with framework setups, generate JTBD/PRD/PRP docs, create/track epics/tickets/status in YAML, validate structure, run health checks, simulate timelines, track milestones from GitHub/Linear, manage todos, and sync to Linear.

Automatically capture corrections and repeating patterns from Claude Code sessions to update CLAUDE.md files across project tiers and generate reusable skill commands. Review learning queues with previews, manage with dry-runs, and hook into session events for ongoing self-learning.

Automatically generate a README.md by analyzing your project's files: detect languages/frameworks like JavaScript/Python/Rust/Go, extract metadata/installation/usage info, and add badges plus table of contents.

Automate pre-development workflows for large-scale project rewrites, migrations, refactors, and overhauls. Analyze full codebase architecture and dependencies, decompose into phased task plans with Mermaid diagrams, effort estimates, and acceptance criteria; generate structured docs, track progress via MASTER.md, create sub-SKILLS, and execute isolated tasks with tests.

Prime Claude with comprehensive project context via slash commands that load READMEs, git-tracked files excluding ignores, directory structures, and specialized docs, while auto-building markdown reference summaries in /ref for optimized AI-assisted development workflows.

Design REST API architectures with endpoint planning, Express.js routing, and validation; implement GraphQL servers using Apollo with schemas and playground; generate OpenAPI specs, request/response examples, and interactive docs from code analysis; set up hosting and CI/CD for API documentation.

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.

Initialize and maintain AI-driven project documentation in an llmdoc/ folder structure: use /llmdoc:init to bootstrap dirs/files/index.md/overview via codebase investigation; run /llmdoc:update after changes to reflect impacts, update stable docs in must/, guides/, reference/, and sync index.

Streamline UI/UX design operations by facilitating structured critiques with feedback rounds and action items, generating developer handoff specs including measurements assets QA checklists and notes, planning 5-day sprints with schedules and testing criteria, establishing review gates and team workflows with roles cadences and Figma Git versioning strategies via skills and slash commands.