skills/cybersecurity-dashboard-ux/SKILL.md
Use this skill when designing, building, or reviewing UI/UX for cybersecurity SaaS dashboards and security platforms. Triggers when the user asks to design a security dashboard, build an AppSec UI, create a vulnerability explorer, design a DevSecOps portal, build security posture views, create risk dashboards, design alert triage interfaces, or build any security-focused web application UI. Also use when improving existing security product interfaces for usability, designing role-based views for AppSec vs engineering personas, or building drill-down patterns for security data. Do NOT use for general website design, marketing pages, or non-security product UIs.
npx skillsauth add kylejryan/better-code cybersecurity-dashboard-uxInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
Security dashboards serve two fundamentally different audiences with the same underlying data: AppSec teams who need org-wide risk posture and triage at scale, and engineers who need scoped, actionable work queues for their own services. Every design decision must account for this split.
The user's primary emotion when using a security dashboard is anxiety — "am I safe? what's broken? what do I need to do?" Good security UX replaces anxiety with clarity. Bad security UX amplifies anxiety with walls of alerts, unexplained severity scores, and data without context.
Apply these patterns when:
| Priority | Category | Impact | Prefix |
|----------|----------|--------|--------|
| 1 | Personas | CRITICAL | persona- |
| 2 | Information Architecture | CRITICAL | ia- |
| 3 | Screen Design | HIGH | screen- |
| 4 | Drill-Down & Navigation | HIGH | drilldown- |
| 5 | Visual Design | MEDIUM-HIGH | visual- |
| 6 | Interaction Patterns | MEDIUM | interaction- |
| 7 | Design Checklist | MEDIUM | checklist- |
Dual-Persona Design: Every widget has a clear primary persona. AppSec sees org-wide risk with slicing by team, env, and severity. Engineers see their own services by default with scoped work queues. One view for both serves neither.
Information Layers: Structure as Overview → Lens (role) → Explorer → Detail. Each layer increases specificity and decreases scope. Every summary card, chart segment, and table row has a clear drill-down target.
Problem Space, Not Tool Space: Organize by what users understand — vulnerabilities, secrets, misconfigurations, threats, compliance — never by which scanner produced the data.
Task-First Navigation: Top-level nav mirrors jobs-to-be-done: Monitor, Investigate, Fix, Configure, Report. Users should never wonder which tab has what they need.
Severity Colors Are Sacred: Critical=red, High=orange, Medium=yellow/amber, Low=blue. Never use severity colors for non-severity purposes. Red means critical. Always.
Build these screens in priority order:
1. Org Overview (AppSec Home) — the situation room
2. Engineering Home ("My Security Work") — the engineer's action center
3. Service Detail Page — shared, role-adapted
4. Vulnerability Explorer — power-user investigation tool
5. Issue Detail Page — deep-linkable, full context
6. Incident/Threat Explorer — if runtime detection is in scope
7. Policy/Configuration Panel — rule and policy management
8. Audit Log / Activity Timeline — who did what when
Screens 1-5 are the core loop. Each screen should be functional standalone — a user who deep-links to the issue detail page shouldn't need to navigate from the overview first.
Read individual reference files for detailed specifications:
references/persona-appsec.md
references/persona-engineer.md
references/screen-org-overview.md
references/screen-vuln-explorer.md
references/drilldown-navigation-chains.md
references/visual-severity-colors.md
references/checklist-comprehensive.md
references/_sections.md
Each reference file contains:
Before shipping a security dashboard screen, verify:
A security dashboard succeeds when users open it proactively — not because an alert forced them to, but because it's the fastest way to understand their security posture and take action.
development
Use this skill when performing the actual vulnerability analysis AFTER a threat model has been established (see threat-model skill). Triggers when the user asks to find vulnerabilities, audit code for security, hunt for bugs, or perform security review of source code AND a threat model already exists or the codebase context is clear. This skill enforces depth-first, exploitability-proven analysis — it actively prevents the breadth-first pattern-matching that produces lists of theoretical vulnerabilities. Do NOT use without a threat model; use threat-model skill first. Do NOT use for general code quality review.
development
Staff+ engineering patterns for maximum leverage per line of code. Use this skill when designing abstractions, building reusable primitives, creating shared libraries, reducing code through architecture, reviewing code for leverage and reuse potential, choosing between building vs configuring, or establishing conventions and patterns across a codebase.
development
Use this skill when designing test strategies, writing tests beyond basic unit tests, verifying software for production readiness, or improving test coverage and reliability. Triggers when the user asks about testing strategy, integration tests, end-to-end tests, contract tests, property-based tests, load tests, chaos testing, test architecture, flaky tests, test confidence, 'how do I test this,' 'how do I know this is safe to deploy,' 'my tests are flaky,' 'what should I test,' 'test coverage,' CI/CD test pipelines, or any question about software verification and validation. Also triggers when the user is shipping a change and wants confidence it won't break production. Primarily targets TypeScript and Go but principles apply universally. Do NOT use for writing basic unit tests for simple functions — this skill is for the harder testing questions.
development
Use this skill when debugging software issues, performing root cause analysis, triaging errors from logs or alerts, or investigating why code isn't working as expected. Triggers when the user shares an error message, stack trace, log output, failing test, unexpected behavior, crash report, performance degradation, or says things like 'this isn't working,' 'I'm getting an error,' 'help me debug,' 'why is this failing,' 'something broke,' or 'I can't figure out what's wrong.' Also use when the user has been going back and forth trying fixes that aren't working — this is the signal to stop guessing and start systematically diagnosing. Do NOT use for writing new code from scratch, general code review, or feature development unless a bug is involved.