sharp-edges

Identify security-footgun patterns in APIs and configuration schemas.

Updated Jul 10, 2025
One-click install
npx skills add https://github.com/Superlend/superloop-core-contracts --skill sharp-edges-superlend
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: sharp-edges
Source: https://github.com/Superlend/superloop-core-contracts/tree/main/.cursor/skills/sharp-edges/skills/sharp-edges
Command: npx skills add https://github.com/Superlend/superloop-core-contracts --skill sharp-edges-superlend

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Security reviews often miss footguns in APIs and configuration schemas, leading to insecure defaults and exploitable design flaws. This Skill helps teams identify error-prone API patterns, dangerous configurations, and other security footguns that elevate risk.

Core Features & Use Cases

  • Detects API design footguns and configuration pitfalls across languages and libraries.
  • Provides concrete remediation guidance and secure-by-default patterns for common cryptographic, authentication, and authorization APIs.
  • Supports security reviews during development, architecture discussions, and post-release audits to reduce misconfigurations.

Quick Start

Provide a codebase or design document snippet to scan; the Skill returns a prioritized list of footguns with recommended mitigations and references.

Frequently Asked Questions about sharp-edges

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

FAQPage Schema
How do I identify security footguns in API design and configuration schemas?

To identify security footguns in APIs and configurations, provide a codebase or design document snippet for analysis. The system surfaces insecure defaults, dangerous configuration options, and error-prone interface patterns with prioritized remediation guidance.

What are common API security footguns and insecure defaults to look for during a code review?

Common API security footguns include dangerous configuration options, error-prone interface patterns, and insecure cryptographic or authentication defaults. Analyzing documentation and code samples helps surface these exploitable design flaws and provides secure-by-default alternatives.

How do I apply secure-by-default patterns for authentication and crypto APIs across different languages?

You can apply secure-by-default patterns for authentication and crypto by analyzing your library interfaces and configuration options. The system provides concrete remediation guidance to replace insecure defaults with safe alternatives across multiple programming languages.

Can I use this for post-release security audits and architecture discussions?

Yes, you can use it for post-release security audits, architecture discussions, and development phase reviews. It analyzes interface ergonomics and configuration schemas to detect misconfigurations and reduce risk throughout the software lifecycle.

What is the best way to review API ergonomics for dangerous configuration pitfalls?

The best way to review API ergonomics for configuration pitfalls is to scan documentation and code samples to detect insecure defaults. This surfaces dangerous configuration options and provides actionable mitigations to harden the interface design.

Do I need to provide code samples or design documents to detect insecure API patterns?

Yes, you need to provide codebase snippets or design documents to detect insecure API patterns. The system requires this input to analyze documentation, code samples, and configuration options to surface footguns and recommend mitigations.