Eight skills: discover projects across monorepos or separate repos, detect cross-boundary connections, generate Mermaid + Excalidraw + native Obsidian Canvas, deep-map how a capability flows across files/projects, load scoped session context, and keep the vault fresh as code changes.
Given an atlas manifest.json, analyzes how projects connect — HTTP/gRPC/GraphQL/WebSocket calls, message-queue publish/subscribe, shared-package imports, database connections, and environment variables that reference other services. Resolves connections across project and repo boundaries by identity, not filesystem layout. Use after map-project, or whenever the user asks how services talk to each other / wants a dependency or connection graph. Outputs graph.json (directed edges with protocol, direction, sync/async, evidence).
Takes an atlas connection graph.json (plus manifest.json) and produces clean Mermaid diagrams at multiple zoom levels — a top-level system view, a focused neighbor view per project, and optional domain-grouped views. Optimized for readability over completeness, so it never dumps every edge into one unreadable diagram. Use after detect-connections, or when the user wants Mermaid/architecture diagrams of how their projects connect.
Loads a compact, scope-aware architecture summary from an Obsidian atlas vault at the start of a Claude Code session, so the model knows how the current project connects without reading the whole codebase. Returns structured text like "Project: web-frontend. Talks to: api-gateway (HTTP), notification-service (WebSocket). Owns: auth UI, dashboard." Respects scope — given a working directory it loads just that project plus its direct neighbors, saving tokens. Use at session start, when the user asks "what does this service talk to / give me the architecture context", or to prime context before a task.
Deep-maps how a specific capability or feature flows across files and projects — e.g. "how does Hyperverge KYC work between libs/ng and core3/onboarding". Traces entry points → calls → cross-project hops → external SDKs/DBs at file/function granularity, and writes a deep-dive note with one or more Mermaid diagrams (sequenceDiagram, flowchart, and/or classDiagram — the model chooses what fits, and may emit several) plus file:line evidence. Writes to Architecture/flows/, links back to project notes via wikilinks, and never touches the system canvas. Records .atlas/flows/<slug>.json so refresh-vault can flag the flow stale when its traced files change. Use for feature/flow deep dives and "how does X work across A and B" questions — distinct from map-project (project topology). Can run standalone.
Scans one or more codebase locations and produces a structured inventory (manifest.json) of every project, service, and package. Accepts a single root path (auto-detecting Nx, Turborepo, pnpm/yarn/npm workspaces, Lerna, Bazel, Go/Cargo workspaces) or an explicit list of paths to separate repos. Use when the user wants to map/inventory/catalog a codebase or monorepo, "figure out what projects exist", or to start building an architecture atlas. First skill in the atlas pipeline; its output feeds detect-connections.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A portable pack of eight Claude Code skills that turn one-or-many codebases into a living, Obsidian-based architecture atlas.
Point it at a single monorepo (Nx, Turborepo, pnpm workspaces, Lerna, Bazel) or a handful of separate repos. It discovers the projects, works out how they talk to each other, draws the system at multiple zoom levels, writes everything into an Obsidian vault as linked notes + Excalidraw canvases, and keeps it up to date as the code changes — while feeding compact, scope-aware context back into future Claude sessions.
┌─▶ write-excalidraw (hand-drawn canvas)
map-project ─▶ detect-connections ─▶ generate-mermaid ─┤
(discover) (relate) (visualize) └─▶ write-canvas (native, file-linked)
│ (persist)
load-session-context ◀── refresh-vault ◀─┘
(recall) (maintain)
Each skill is useful on its own, but they chain through two shared JSON contracts (manifest.json and graph.json) so the whole pipeline composes cleanly. The two persistence skills are alternatives (or run both): write-canvas for a clickable native map, write-excalidraw for a free-form hand-drawn one. map-flow is orthogonal — a deep dive into a single capability, off to the side of the topology pipeline.
| Skill | Stage | Reads | Writes |
|---|---|---|---|
map-project | Discover | a root path or explicit paths | manifest.json |
detect-connections | Relate | manifest.json | graph.json |
generate-mermaid-architecture | Visualize | graph.json + manifest.json | diagrams/*.mmd |
write-excalidraw | Persist | manifest + graph + diagrams | vault notes + embedded Mermaid + summaries.json + .excalidraw.md (dagre-laid-out via a bundled converter; in-plugin conversion fallback) |
write-canvas | Persist | manifest + graph (+ notes) | .canvas files with file-linked nodes |
map-flow | Deep-dive | a capability + the files/projects it spans | flows/<slug>.md (sequence/flow/class Mermaid + evidence) + .atlas/flows/<slug>.json |
load-session-context | Recall | vault summaries.json | structured context text (stdout) |
refresh-vault | Maintain | vault + repos (git/mtime) | updated notes/diagrams/canvases + stale-flow flags + state.json |
Two granularities. The topology skills treat each project as one node (system-level map).
map-flowgoes inside projects to trace how one capability flows across files and boundaries — a separate file underflows/, linked back to the project notes, never poured into the system canvas.
Connections are resolved by project identity (package name, service name, port, URL host, queue subject), not by filesystem proximity. So a fetch(process.env.API_GATEWAY_URL) in ~/code/web resolves to the api-gateway service living in a completely separate repo at ~/work/backend. One monorepo or ten loose repos — same graph.
Everything the pipeline produces is stored under a single .atlas/ directory inside your chosen Obsidian vault:
<vault>/
└── Architecture/
├── _index.md # map-of-content: system diagram + links to every project
├── <project>.md # one generated note per project
├── System.canvas # native Obsidian Canvas: clickable, file-linked system map
├── System.excalidraw.md # editable Excalidraw, dagre-laid-out by the bundled converter
├── <domain>.excalidraw.md # optional per-domain canvases (same converter)
├── flows/ # map-flow deep dives (one capability each, linked back to the notes)
│ ├── _flows.md # index of all flows
│ └── <slug>.md # e.g. hyperverge-kyc.md — sequence/flow/class Mermaid + evidence
└── .atlas/ # machine artifacts (the pipeline's working state)
├── manifest.json # output of map-project
├── graph.json # output of detect-connections
├── diagrams/*.mmd # output of generate-mermaid-architecture
├── summaries.json # compact per-project context for load-session-context
├── flows/<slug>.json # map-flow trace state (sourceFiles + fingerprint) for staleness
└── state.json # last-generation commit/mtime for refresh-vault
npx claudepluginhub brentibanez331/ren-atlas-skills --plugin ren-atlasCreate and edit Obsidian vault files including Markdown, Bases, and Canvas. Use when working with .md, .base, or .canvas files in an Obsidian vault.
Ultra-compressed communication mode. Cuts ~75% of tokens while keeping full technical accuracy by speaking like a caveman.
Frontend design skill for UI/UX implementation
Comprehensive UI/UX design plugin for mobile (iOS, Android, React Native) and web applications with design systems, accessibility, and modern patterns
Memory compression system for Claude Code - persist context across sessions
Marketing skills for AI agents — conversion optimization, copywriting, SEO, paid ads, ad creative, and growth