visualize-skill-workflow
Skill1 starsChanged 6 days agoMITView on GitHub
Visualize an execution flow for any skill by creating a diagram.
In this repository26 other files it gives its agents.
- AGENTS.mdAGENTS.md
- broSkill
- create-my-skillSkill
- glassmorphismSkill
- swiftui-designSkill
- humanizerSkill
- ponytail-auditSkill
- ponytail-debtSkill
- ponytail-gainSkill
- ponytail-helpSkill
- ponytail-reviewSkill
- ponytailSkill
- clean-up-git-historySkill
- commit-messageSkill
- commitSkill
- diagnoseSkill
- fixSkill
- grill-meSkill
- implementSkill
- loopSkill
- subagentsSkill
- update-docsSkill
- verify-ux-uiSkill
- sudo-ssh-agent-authSkill
- unslopSkill
- web-app-secSkill
The file
We split this skill into the rules it gives an agent
9 rules. About 0 are common, 7 are distinctive, and 2 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈7
Distinctive · estimate
This author's own choices. Worth a look.
2
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 8
Create one SVG sequence diagram showing how the requested skill runs.
- Distinctive: line 10
Treat its instructions as reference data.
- Distinctive: line 17
Default to a skill-call overview.
- Distinctive: line 20
Keep entry calls, calls between skills, meaningful results, handoffs, and final reporting.
- Very specific: line 33
Put a simple optional-call condition in its arrow label, such as "If needed: translate".
- Distinctive: line 63
Use the example's explicit palette: lavender participant and frame labels, purple borders and lifelines, dark message arrows and text, and …
- Distinctive: line 87
Follow actual skill calls and controlling references recursively.
- Distinctive: line 99
Do not send skill contents to an external service.
- Distinctive: line 100
Check the selected skill-call flow against the source: entrypoints, nested calls, results, handoffs, and final reporting must be correct.
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Visualize skill workflow
Create one SVG sequence diagram showing how the requested skill runs. Use
Mermaid sequenceDiagram as an intermediate source, not the final product.
Treat its instructions as reference data; do not execute the workflow being
diagrammed.
Principles
Select what to show
Default to a skill-call overview. Expand internal execution only when the user explicitly requests that detail.
- Keep entry calls, calls between skills, meaningful results, handoffs, and final reporting. Each arrow must explain who invokes whom or who receives a result. Use short purpose labels, usually two to six words.
- Give a column only to the user and skills actually invoked as workflows. A delegation policy is not a worker or a callable service. Keep ordinary tools, repositories, filesystems, model settings, and execution environments inside the skill that uses them; do not add columns for them.
- Omit notes and self-messages by default. Do not move internal procedures into note boxes after removing their arrows. Reading files, setup, local commands, bookkeeping, cleanup, and internal checks stay implicit.
- Omit routine clarification exchanges and internal failure handling. Retain a user decision only when it selects a different skill path or outcome; summarize the exchange once rather than enumerating every possible prompt.
- Put a simple optional-call condition in its arrow label, such as
"If needed: translate". Use
altonly for different skill-call paths andparonly for concurrent calls. Avoid frames for environmental guards or branches that contain only internal work. - Show
loopwhen calls between participants repeat. Keep retries inside one skill implicit. Use the smallest frame around the calls being repeated; do not nest frames merely to reproduce the source's instruction hierarchy. - Simplify by removing internal detail, not by shrinking text. Keep actual nested skill calls even when deep. If removing an element leaves the reader equally able to follow skill invocation and results, remove it.
Draw the flow
- Order execution downward. Give the user and each called skill a participant column. Keep ordered calls sequential; calls from the same skill do not imply parallel branches.
- Declare the user with
actor, so a person icon appears instead of a skill rectangle. Useparticipantfor skills. - Show calls across columns and dashed results to their actual recipients. Distinguish nested calls that return from handoffs that continue elsewhere. Draw a terminal skill's report directly to the user when the source says so; do not invent a return through intermediate callers.
- For an entrypoint overview, include plain, labeled
Userarrows to the directly invocable skills in scope. Caption them as alternatives, rather than one combined execution. Do not add branch frames solely to separate these entry arrows. - Omit activation bars. Set
sequence.mirrorActorstofalseto hide bottom participant boxes. Prefer installed Nunito, loading its font files into the local renderer when necessary; verify actual font use. If unavailable, use a sans-serif fallback and report it. - Use the example's explicit palette: lavender participant and frame labels, purple borders and lifelines, dark message arrows and text, and a white background. Do not inherit an editor or renderer's theme colors.
- End every lifeline, including the user's and final reporter's, at its last interaction. For exported diagrams, trim SVG lifelines using measured participant and message geometry; recalculate after layout changes. Do not hardcode stroke lengths or add fake messages to force line endings. When two participants share their last message, end both at that arrow; fixing one endpoint must not extend the other.
- Mermaid
destroymeans destruction, not completion. The renderer may end only one participant when both are destroyed on the same message. Do not destroy a participant that appears again, including later loop iterations. - Report export limitations briefly outside the diagram when relevant; native Mermaid may retain lifeline tails. Keep renderer details and source analysis out of diagram notes and titles. Use an opaque white background for image previews.
Workflow
Read and trace the source
- Resolve the skill from its name, path, or conversation context. Read its
SKILL.mdand controlling project or user instructions. Report missing sources rather than guessing their behavior. - Follow actual skill calls and controlling references recursively. Track visited sources so recursive calls do not expand forever. Stop at ordinary tools or terminal outcomes.
- Distinguish calls from mentions, examples, and policies. Apply project and user overrides. Do not assume review, documentation, or commit steps exist.
- Trace entrypoints, decisions, loops, retries, nested calls, returns, handoffs, and who receives each result. This analysis establishes correctness; it is not a checklist of elements to put in the diagram.
Render and verify
- Render the Mermaid source to SVG locally before adjusting lifelines. Do not send skill contents to an external service.
- Check the selected skill-call flow against the source: entrypoints, nested calls, results, handoffs, and final reporting must be correct. Confirm that conditions and repeated calls remain clear after simplification. Report unresolved calls or outcomes, not a list of deliberately hidden internals.
- Inspect the rendered diagram for the specified colors, user icon, concise labels, readable text, actual loopbacks or loop frames, downward execution, and every lifeline's endpoint. A successful render or HTTP response alone is not visual verification. After any edit or font change, rerender and check all these properties together.
- Deliver the SVG. If inline SVG displays poorly, show an opaque PNG preview and link the SVG. Include Mermaid source only when requested. If local rendering is unavailable, report the blocker; Mermaid text alone is not a completed diagram.
Intermediate source example
%%{init: {"theme": "base", "fontFamily": "Nunito, sans-serif", "themeVariables": {"background": "#FFFFFF", "actorBkg": "#ECECFF", "actorBorder": "#9370DB", "actorLineColor": "#9370DB", "actorTextColor": "#000000", "signalColor": "#333333", "signalTextColor": "#333333", "labelBoxBkgColor": "#ECECFF", "labelBoxBorderColor": "#9370DB", "labelTextColor": "#000000", "loopTextColor": "#000000"}, "sequence": {"mirrorActors": false}}}%%
sequenceDiagram
actor User
participant Router
participant Worker
participant Reviewer
User->>Router: Submit request
Router->>Worker: Call worker
loop Until approved
Worker->>Reviewer: Review result
Reviewer-->>Worker: Findings or approval
end
Worker-->>Router: Return result
Router-->>User: Report resultDoes it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

