Archify Architecture Diagram Skill
Turn system and process descriptions into interactive, exportable technical diagrams.
The files show that the skill primarily generates local HTML/SVG and disclose its dependency-free packaging, export behavior, and local-storage theme preference. No malware, credential theft, covert exfiltration, or destructive default is evident. However, user confirmation, sensitive-data handling, permission boundaries, rollback, and dependency provenance are not fully specified, and installation relies on external npx, so points were deducted.
The documentation defines doctor, demo, render, validate, and check workflows, while CI claims Node 20/22 coverage, packaged smoke tests, and invalid-input checks. This review was static and did not execute them; test-file contents and complete abnormal-input behavior are not provided, so the score remains conservative.
The name, audience, diagram modes, trigger phrases, input dialects, and output format are clearly described. Mermaid boundaries, non-editor positioning, and CJK text measurement are also stated. However, Chinese-language documentation is limited, and the workflow assumes Node, a modern browser, and partially optional browser capabilities; environment fit and non-fit boundaries are not fully evidenced.
The material includes structured setup, usage, references, examples, limitations, version information, CHANGELOG/ROADMAP references, MIT licensing, attribution to the upstream project, and contribution guidance. Maintenance ownership, a durable update path, and version consistency still depend largely on repository processes, and only one skill source file was in scope, so points were deducted.
The stated goal is to turn plain-language or Mermaid structure into a directly openable, exportable standalone HTML file. Multiple modes, examples, and export formats make the core value clear. However, no independently verified generated artifacts or execution results are available in this static review, and diagrams may still require manual layout review, so the score is below the static ceiling.
CI configuration, version metadata, example paths, validation commands, and archive-freshness checks provide limited auditable evidence. Because nothing was executed and the test-suite contents, third-party run results, and cross-source corroboration are absent, the score is limited.
- This review only covers the supplied static files; the CLI, tests, and browser exports were not executed, so claimed rendering, validation, and multi-format export remain unconfirmed in the target environment.
- Before using external npx installation or possible Google Fonts loading, verify network, supply-chain, and organizational policies; offline use depends on packaged files and local font fallbacks.
- For real systems, PII, or security boundaries, users should manually verify diagrams and should not treat generated output as authoritative facts or a security audit.
What does this skill do, and when should you use it?
Archify is an Agent Skill for Claude, Codex CLI, and opencode that turns plain-language or Mermaid descriptions into architecture, workflow, sequence, data-flow, and lifecycle diagrams. It produces a self-contained HTML file with dark/light themes, navigation features, and PNG, JPEG, WebP, and SVG export. Its renderer-backed workflow uses typed JSON specifications, schema validation, layout checks, and HTML/SVG artifact checks. The CLI requires Node.js; Claude.ai ZIP uploads are generally supported, subject to sandbox support for Node.js.
It reads system, process, or Mermaid requirements and, when needed, repository evidence; authors a typed JSON specification for one of five diagram modes; runs schema, layout, and artifact checks with node bin/archify.mjs validate; and uses deliver to create a self-contained HTML artifact. The generated viewer provides theme switching, pan/zoom, search, relationship tracing, and PNG/JPEG/WebP/SVG export.
- A software engineer needs a runtime architecture map based on an actual repository, including dependencies and trust boundaries.
- A platform team needs to communicate cloud resources, network topology, security boundaries, and service connections.
- An API team needs to explain request sequences, cache misses, asynchronous traces, and return paths.
- A data team needs to document ETL/ELT pipelines, PII boundaries, lineage, and downstream consumers.
- A DevOps team needs to show CI/CD stages, approval gates, rollback paths, or incident runbooks.
- An engineering team needs to document task, deployment, or agent-run states, retries, waits, and terminal outcomes.
What are this skill's strengths and limitations?
- Covers five technical diagram types: architecture, workflow, sequence, data flow, and lifecycle.
- Produces a dependency-free, self-contained HTML artifact that can be shared directly.
- Includes dark/light themes, interaction features, clipboard PNG copy, and four export formats.
- Provides schema, layout, and post-render HTML/SVG checks before delivery.
- Semantic technology labels such as `aws.lambda`, `postgres`, and `kafka` can guide visual categorization and layout.
- The authoring workflow depends on the agent creating and iterating JSON specifications; it is not an automatic Mermaid parser.
- The complete CLI workflow requires Node.js plus shell and filesystem access.
- WebP export and image clipboard copy depend on browser support.
- The supplied material does not provide independent test results, a platform coverage matrix, or execution evidence.
- Claude.ai Project Knowledge supports architecture mode only and cannot execute code.
How do you install this skill?
For a global installation, run npx skills add tt-a1i/archify -g. For a temporary Codex session, run npx skills use tt-a1i/archify@archify --agent codex. The README also documents ZIP-based installation for Claude.ai, Claude Code, Codex CLI, and opencode. No additional installation is required inside the skill package.
How do you use this skill?
After installation, prompt the agent with a concrete request such as: Use archify to draw a sequence diagram: User opens a page, the frontend calls the API, the API verifies JWT, reads Redis, falls back to Postgres on cache miss, and returns JSON. For repository analysis, use: Analyze this repository, then use archify to create an architecture diagram of its runtime components, data flow, external dependencies, and trust boundaries. Validate a candidate with node bin/archify.mjs validate <type> <candidate.json> --quality showcase --json, then use deliver for the final HTML.
How does this skill compare with similar options?
Compared with Mermaid, Archify focuses more on agent-directed layout, themeable self-contained HTML, interaction, image/SVG export, and validation. Mermaid input is re-laid out by the agent rather than automatically parsed; the repository explicitly says an automatic Mermaid parser route was not retained.