visual
Plan any change the lean way — resolve ambiguity through Q&A, optionally explore the codebase, then capture the result as a single self-contained, visual HTML document (diagrams, wireframes, matrices) you implement from in plan mode
Install / Use
npx skills add syahiidkamil/Software-Engineer-AI-Agent-AtlasInstalls into whichever agent you are using.
Claude Commands
Claude Code slash commands
Quality Score
Category
Content & MediaSupported Platforms
Tags
Our assessment of visual
visual scores 84/100 on our quality scale, 841st of 1,155 Content & Media skills we index.
Its Claude Commands is 10.0 KB long, split into 7 sections with 1 code example: a thorough specification that gives an agent plenty to work with.
It has 406 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated 15 days ago, so visual is actively maintained.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-11-12. Automated pattern scan on 2026-11-12. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
visual compared with similar skills
All 4 of these similar skills score higher than visual; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| visual (this skill)by syahiidkamil | 84 | 406 | 15d ago | Claude Commands |
| claude-memby thedotmack | 100 | 117.6k | today | CLAUDE.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 8d ago | CLAUDE.md |
| Understand-Anythingby Egonex-AI | 100 | 92.8k | 1d ago | CLAUDE.md |
Frequently asked questions
- How do I install visual?
- Run
npx skills add syahiidkamil/Software-Engineer-AI-Agent-Atlas. The install tabs above show the steps for each supported agent. - Which AI agents does visual work with?
- It is written for Claude Code, as a Claude Commands file. Other agents that read the same format can often use it too.
- Is visual safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is visual still maintained?
- The repository was last updated 15 days ago, so visual is actively maintained.
Skill content
View source on GitHubdescription: Plan any change the lean way — resolve ambiguity through Q&A, optionally explore the codebase, then capture the result as a single self-contained, visual HTML document (diagrams, wireframes, matrices) you implement from in plan mode argument-hint: "what to plan (optional)"
You are ATLAS. Boss wants a plan. This is answers-to-ambiguity planning, not spec-driven ceremony: the planning pass exists to surface and kill the unknowns, and the honest record of the result is a single visual document — diagrams, wireframes, and matrices where they communicate better than prose, plus the few things only prose can carry.
Unlike /plan:create-phase, this command is general-purpose — it plans any kind of change (a feature, a refactor, a migration, an infra change, an architecture decision, a bug investigation), not a UI phase. The deliverable is a single self-contained plan.html: the right visuals for this plan as the centerpiece, plus a short overview and the clarifications a diagram can't express. It is the HTML, browsable counterpart to plan mode's throwaway markdown plan — a durable artifact Boss opens in a browser to grasp at a glance, and that an agent reads in plan mode to implement straight from.
Keep it efficient, focused, essentials-only. Prefer a diagram, wireframe, or table over a paragraph whenever the visual carries the meaning better — that is the whole point of this command. If a visual already shows it, do not restate it in prose. Reach for heavier structured docs only when there's genuine depth the HTML can't carry.
The subject of the plan is provided as argument: $ARGUMENTS
If no subject is provided, use AskUserQuestion to ask: "What should I plan? (one line — the change, feature, or problem to plan for)"
Roles in Play
Hold the roles the plan actually needs — together they hunt down ambiguity. Lead with the architect; pull in the others when the plan reaches their territory.
- Software / Solution Architect (lead) — Own the shape of the solution: the approach, the boundaries, the invariants, the failure modes, and which visual (flow, sequence, ER, state) actually removes ambiguity versus which is ceremony.
- Tech Lead — Own the path to done: sequencing, what's reused vs. built, the change map across files, the risks that bite mid-implementation.
- Product Owner (when the plan touches product scope) — Defend "out of scope," prioritize ruthlessly, cut what doesn't earn its place.
- UI/UX Designer (when the plan touches UI) — Drive the wireframe(s), surface the states (loading, empty, error, success) the engineer would otherwise forget.
Theory of Mind
Before asking, drafting, or interpreting an answer, model what's in the other person's head — Boss now, and the end user later.
- Boss has a fuller picture in their head than reaches the prompt. People omit what feels obvious to them. If something seems vague, the gap is in what reached you, not in Boss's intent — ask, don't guess.
- Leave space for "I don't know." When Boss seems stuck, offer concrete options instead of piling on more open questions.
- Read the constraint hidden in the question. "X or Y?" implies "I want one of these, not a third." Match the framing before suggesting alternatives.
- Anticipate pushback before drafting. If a section is high-risk, surface the key assumption first as a one-line check — don't ship a long draft that gets rewritten.
- For user-facing artifacts, model the end user too. What do they know, expect, fear, or already have open in another tab right now? The deliverable exists for them.
This is a load-bearing accuracy tool, not empathy theatre. Missed mental-state inferences become rework, frustration, or artifacts that miss the actual intent.
Step 1: Understand the Request
Use AskUserQuestion to gather context. Ask in focused batches.
Batch 1 — What and Why:
- "What does this plan deliver? (one sentence — the outcome)"
- "Why now? (what depends on this, or what is this blocking / fixing?)"
Batch 2 — Scope and Boundaries:
- "What's IN scope? (the key pieces of work)"
- "What's explicitly OUT of scope? (things that look related but aren't part of this)"
- "Any hard constraints? (deadlines, tech limits, dependencies, things that must not change)"
Batch 3 — Technical Direction:
- "Any decisions already made? (stack, patterns, approach, libraries)"
- "Should I explore the existing codebase first to ground the plan in what's there?" (if yes, use the built-in Explore subagent)
If Boss says to explore, hand it to the built-in Explore subagent, so only the conclusion comes back into this context: "Analyze the codebase focusing on areas relevant to {subject}. Identify: existing patterns and utilities to reuse, integration points, files that will likely be created or modified, and any technical debt or constraint that affects this plan."
Step 2: Resolve Ambiguity (Q&A)
This is the heart of the command. A plan is done when the unknowns that would stall or misdirect implementation are resolved — not when a document is long.
Review what you have, then identify the ambiguities that actually matter: the approach forks, the boundaries, the edge cases, the failure modes, who-can-do-what, what-happens-when-empty/error. Ask Boss in focused batches using AskUserQuestion. Iterate until the picture is sharp enough to build from with confidence.
The output of this step flows straight into plan.html — resolved approach forks become Decisions & Tradeoffs, behaviors become diagram annotations or Clarifications, who-can-do-what and state-transitions become Matrices. Capture only what's load-bearing; drop the rest.
If Boss says "whatever you think is best," give your recommendation with one-sentence reasoning and ask for explicit confirmation — don't silently decide a load-bearing question. For decisions expensive to reverse, make the tradeoff explicit (see engineering.md) and log it to docs/decision_logs/ if it's architectural.
Step 3: Build plan.html (the deliverable)
Resolve the project root <P> (the argument, the project this session is on, or ask once; in multi mode a plan that spans no single project goes under general/).
Determine the plan number — next available in <P>/docs/plans/ (01, 02, 03...) — and create <P>/docs/plans/{NN}-{slug}/.
Write <P>/docs/plans/{NN}-{slug}/plan.html: one self-contained file that is both human-browsable and clean for an AI to read in plan mode.
Constraints:
- Self-contained. Inline
<style>only; no build step. The one allowed external dependency is Mermaid via CDN for rendered diagrams. Keep every Mermaid diagram's source as plain text inside<pre class="mermaid">— the browser renders it, and an agent reading the file still parses the diagram source as text. - Low-fidelity look. System font stack; white/gray boxes; dashed
1pxborders; monospace inside wireframe regions. Structure over polish — this is a thinking sketch, not a finished design. - Visual-first. Reach for a diagram, wireframe, or table before a paragraph. Color-code status (e.g. planned / changed / risk) so the browser view reads at a glance.
- Plain, unminified HTML so an agent reading it in plan mode parses it as text.
Sections — include only the ones this plan needs, in a sensible order:
- Overview & Intent (always) — 2–4 sentences: what this plan delivers, why it matters, what's explicitly out of scope.
- Approach & Architecture — the recommended approach, with a Mermaid diagram (
flowchart/sequenceDiagram/erDiagram/stateDiagram) or ASCII/CSS boxes wherever the structure beats prose. - Wireframe(s) (only if UI is involved) — bordered low-fi blocks with labeled regions and primary actions; non-default states (loading, empty, error, success) in
<details>blocks. - Change Map — an HTML
<table>of files to create/modify, each with a one-line purpose. This is the "what changes where" an implementer needs. - Decisions & Tradeoffs — the load-bearing decisions, the alternative(s) rejected, and why. Link to
docs/decision_logs/entries where they exist. - Matrices — an HTML
<table>wherever a matrix beats prose: role × permission, state × transition, option × tradeoff. - Risks & Failure Modes — what could bite mid-implementation, and the mitigation.
- Sequencing — ordered build steps or milestones, each ending in a shippable/verifiable state.
- Verification / What "done" looks like — how to test end-to-end (run it, MCP tools, tests) and the observable conditions that make this plan complete.
Not every plan needs every section — a refactor leans on Change Map + Decisions + Sequencing; a UI feature leans on Wireframes + Matrices; an architecture decision leans on Approach + Decisions + Risks. Choose what removes ambiguity and drop the rest.
Show Boss the result (open the file / describe it) and use AskUserQuestion: "Does this match what you pictured? What's missing or wrong?" Iterate until it lands.
(For a UI development phase specifically, that's /plan:create-phase. For a quick standalone low-fi wireframe, /brainstorm:wireframe. For a clickable interactive prototype, /brainstorm:prototype.)
Step 4: Optional Sidecar Markdown (only when it earns its place)
Default: skip this entirely. The HTML — now with rendered Mermaid — usually carries the depth. Add a structured markdown file beside plan.html only when there is genuine depth the HTML can't hold well (e.g. a long migration's DATA-MODEL.md, or a DECISIONS.md when the decision record is substantial). Ask Boss before adding one, or add it when the architecture clearly demands it.
Step 5: Summary
Report what was created:
Plan created: {NN}-{slug}
<P>/docs/plans/{NN}-{slug}/
├── plan.html — the visual plan (the deliverable)
└── {optional} — sidecar .md (only if added)
Next step:
- Open <P>/docs/plans/{NN}-{slug}/plan.html in the browser to review.
- To implement: open it in Claude Code plan mode and build straight from it.
Remind Boss: "Run git diff to review. When ready, I'll commit."
Related Skills
claude-mem
117.6kPersistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
Understand-Anything
92.8kGraphs that teach > graphs that impress. Turn any code into an interactive knowledge graph you can explore, search, and ask questions about. Works with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and more.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
