json-canvas
by MarsWang42json-canvas helps agents create and edit valid .canvas files for Obsidian and other JSON Canvas apps. Use it to generate structurally correct nodes, edges, groups, positions, and layering for mind maps, flowcharts, and lightweight diagramming workflows.
This skill scores 68/100, which means it is acceptable to list for directory users but should be presented as a reference-heavy skill rather than a strongly operational one. The repository evidence shows real substance: a long SKILL.md with valid frontmatter, multiple sections, code fences, and concrete coverage of JSON Canvas structure and node types. However, install-decision clarity is only moderate because there are no support files, no install command, and limited evidence of step-by-step execution patterns beyond the documentation itself.
- Strong triggerability from the frontmatter description: it clearly tells agents to use the skill for .canvas files, Obsidian Canvas work, mind maps, and flowcharts.
- Substantial core documentation: a 13k+ character SKILL.md with many headings and code fences gives agents concrete schema-level guidance for valid JSON Canvas files.
- Useful domain specificity over a generic prompt: it explains JSON Canvas structure, node types, edges, groups, and ordering rules that an agent could apply directly when generating or editing .canvas data.
- Operational clarity is limited by the lack of support artifacts: no scripts, references, resources, rules, metadata, or examples outside the single SKILL.md file.
- Adoption guidance is thin for installers because SKILL.md does not include an install command and the evidence shows only modest workflow/constraint signaling.
Overview of json-canvas skill
What the json-canvas skill does
The json-canvas skill helps an agent create or edit valid .canvas files for the JSON Canvas format used by Obsidian and similar diagramming tools. Its real job is not “draw something nice,” but “produce structurally correct canvas JSON with nodes, edges, groups, positions, sizes, and layering that a canvas app can actually open.”
Who should install json-canvas
This json-canvas skill is best for users who already know the content they want on a board but do not want to hand-author the schema. It fits note-taking, mind maps, flowcharts, architecture sketches, research boards, and lightweight diagramming workflows where the output must be a real .canvas file rather than a prose description of one.
Why it is better than a generic prompt
A normal prompt often gets the format almost right, then misses required fields, node types, or array structure. json-canvas is useful because it centers the JSON Canvas object model: top-level nodes and edges, four node types (text, file, link, group), and practical details like z-order depending on node array order. That reduces cleanup if your goal is diagramming in Obsidian instead of generating mock JSON.
How to Use json-canvas skill
Install context and when to invoke json-canvas
If your agent platform supports GitHub skills, add json-canvas from MarsWang42/OrbitOS using your normal skill install flow. The repository evidence only exposes SKILL.md, so expect a compact skill with format guidance rather than helper scripts or validators. Invoke it when the task explicitly mentions .canvas, JSON Canvas, Obsidian Canvas, or visual diagramming that must end as editable canvas JSON.
What input produces good json-canvas usage
The skill works best when you provide diagram intent, not just topic. Strong input usually includes:
- node list or sections to represent
- relationships between nodes
- desired node types:
text,file,link,group - rough layout direction: left-to-right, top-down, clustered
- whether groups should visually contain related nodes
- file references or URLs if using
fileorlinknodes
A weak prompt: “Make a canvas for my project.”
A stronger prompt: “Create a .canvas for a project roadmap with three groups: planning, build, launch. Use text nodes for tasks, link nodes for docs URLs, connect task dependencies with edges, and arrange groups left to right.”
How to turn a rough goal into a usable prompt
For reliable json-canvas usage, specify both content and structure. A practical prompt pattern is:
- Define the board purpose.
- List node categories.
- State key edges.
- Give layout rules.
- Ask for valid
.canvasJSON only.
Example:
“Use the json-canvas skill to generate valid .canvas JSON for diagramming a hiring pipeline. Include groups for sourcing, screening, interview, and offer. Add text nodes for each stage, link nodes for ATS and policy docs, and edges showing candidate flow. Keep nodes spaced for readability and place groups in process order.”
What to read first and workflow tips
Read EN/.agents/skills/json-canvas/SKILL.md first. Focus on:
- top-level file structure
- node types and required fields
- edge modeling
- z-index ordering via node array order
Practical workflow:
- Draft the node inventory.
- Generate a minimal canvas.
- Open it in your canvas app.
- Fix layout, grouping, or missing links in a second pass.
This works better than asking for a polished final board immediately, because format correctness is easier to validate before visual refinement.
json-canvas skill FAQ
Is json-canvas for diagramming only in Obsidian?
No. json-canvas for Diagramming is a good fit anywhere the target app reads the JSON Canvas spec. Obsidian is the obvious case, but the underlying value is standards-based .canvas generation, not Obsidian-specific styling magic.
Is this better than asking an LLM to write JSON directly?
Usually yes if your end product must load cleanly. Generic prompting can work for tiny examples, but this skill narrows the model toward the actual canvas schema and node semantics. That matters once you have multiple node types, grouped regions, or many edges.
Is json-canvas suitable for beginners?
Yes, if you understand the board you want. You do not need deep spec knowledge, but you do need to describe entities and relationships clearly. If you cannot yet list the nodes or flows, the skill will still generate something, but the result may need heavy manual revision.
When should I not use the json-canvas skill?
Skip it if you only need a static image, Mermaid diagram, Excalidraw export, or a plain text outline. It is also a weak fit if your diagram depends on advanced app-specific behavior not represented in the base JSON Canvas format.
How to Improve json-canvas skill
Give the model a board plan, not just a topic
The biggest quality gain comes from naming nodes and edges explicitly. Instead of “make a system architecture canvas,” provide:
- services
- dependencies
- external links
- grouping logic
- preferred reading order
This improves both validity and layout decisions, and makes the json-canvas guide more actionable in practice.
Prevent common json-canvas failure modes
The most common issues are missing required attributes, vague grouping, and unreadable layouts. To reduce them:
- ask for valid
.canvasJSON only - request unique node IDs
- specify approximate canvas direction
- separate “must connect” edges from optional visual links
- mention if groups should contain nodes spatially
If your board opens but looks wrong, the structure may be valid while the positioning is poor.
Iterate in two passes for better output
A good json-canvas install decision often depends on whether the skill supports efficient iteration. Here it does, if you use it in stages:
- pass 1: schema-correct nodes and edges
- pass 2: refine coordinates, widths, heights, and groups
- pass 3: reorder nodes if visual stacking matters
Because node array order affects z-index, ask specifically when you want groups behind content or labels on top.
What to ask for after the first draft
After initial generation, improve results with targeted edits:
- “Convert these URLs to
linknodes.” - “Wrap these five nodes in a
groupnode.” - “Reposition nodes to reduce edge crossings.”
- “Keep the same IDs but add missing dependency edges.”
- “Put groups on lower z-index than text nodes.”
That kind of constrained follow-up gets better results than regenerating the whole board from scratch.