One-click install
npx skills add https://github.com/vigolium/vigolium --skill sharp-edges-vigolium
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sharp-edges
Source: https://github.com/vigolium/vigolium/tree/main/platform/vigolium-audit/src/content/skills/sharp-edges
Command: npx skills add https://github.com/vigolium/vigolium --skill sharp-edges-vigolium

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps reviewers spot error-prone security APIs, dangerous configuration semantics, and “secure-by-default” violations that make developer mistakes likely and vulnerabilities easier to introduce.

Core Features & Use Cases

  • Misuse-resistant API review: Detects footguns where developer choice points (algorithms, modes, primitives, flags) can silently lead to insecure behavior.
  • Secure defaults & validation checks: Identifies dangerous zero/empty/null semantics, sentinel values, and unvalidated constructor/config parameters that create “configuration cliffs.”
  • Failure-mode and error-path analysis: Flags silent failures, bypasses, and verification functions whose outcomes are easy to mishandle.

Use it when auditing authentication/session logic, cryptographic interfaces, authorization checks, configuration schemas, and any security-relevant API ergonomics that others will call under deadline pressure.

Quick Start

Ask the AI to review the following code for sharp edges and misuse-resistant design issues, explicitly checking zero/empty/null semantics, algorithm/mode selection footguns, secure defaults, and whether security failures are silent or easy to bypass.

Frequently Asked Questions about sharp-edges

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I review my code for security design flaws and insecure API defaults?

Security design review identifies error-prone APIs and insecure configuration defaults by mapping developer choice points and probing zero, empty, or null inputs to prevent silent bypasses. It targets cryptographic footguns and authentication logic where misuse is plausible under deadline pressure.

What are cryptographic footguns and how do I find them in my codebase?

Cryptographic footguns are dangerous API design choices where algorithm or mode selection silently leads to insecure behavior. You find them by mapping developer choice points, validating constructor parameters, and verifying that failure modes are explicit rather than silently bypassable during security design review.

How do I check if my authentication logic has silent failure modes or bypassable security checks?

Check authentication logic for silent failures by analyzing error paths and probing zero, empty, null, and invalid inputs. Verify that verification functions return explicit failure modes and that authorization checks cannot be easily bypassed or mishandled by developers calling the interface.

Can I use this to audit configuration schemas for dangerous zero, empty, or null semantics?

Yes, you can audit configuration schemas by identifying dangerous zero, empty, and null semantics alongside unvalidated sentinel values. This process detects configuration cliffs where unvalidated constructor parameters create secure-by-default violations that make developer mistakes likely and vulnerabilities easier to introduce.

What is misuse-resistant API design and when do I need a security design review?

Misuse-resistant API design eliminates developer choice points that silently lead to insecure behavior by enforcing secure defaults and explicit failure modes. You need a security design review when auditing authentication, authorization, cryptographic interfaces, and developer-facing configuration schemas where others will call under pressure.

Does this approach work for reviewing authorization checks and developer-facing interface ergonomics?

Yes, misuse-resistant design review applies directly to authorization checks and developer-facing interface ergonomics. It maps developer choice points, validates allowlists and config ranges, and probes invalid inputs to ensure security failures are explicit rather than silently bypassable under deadline pressure.