sharp edges

Other Community

Skill notes

When to Use

Reviewing API or library design decisions Auditing configuration schemas for dangerous options Evaluating cryptographic API ergonomics Assessing authentication/authorization interfaces Reviewing any code that exposes security-relevant choices to developers

When NOT to Use

Implementation bugs (use standard code review) Business logic flaws (use domain-specific analysis) Performance optimization (different concern)

Agent

The sharp-edges-analyzer agent runs the full sharp edges analysis workflow autonomously. Use it when you want a dedicated analysis of APIs, configurations, or interfaces for misuse resistance and footgun potential. The agent follows the four-phase workflow (Surface Identification, Edge Case Probing, Threat Modeling, Validate Findings) and reads language-specific references on demand.

Core Principle

The pit of success: Secure usage should be the path of least resistance. If developers must understand cryptography, read documentation carefully, or remember special rules to avoid vulnerabilities, the API has failed.

Rationalizations to Reject

Rationalization · Why It's Wrong · Required Action "It's documented" · Developers don't read docs under deadline pressure · Make the secure choice the default or only option "Advanced users need flexibility" · Flexibility creates footguns; most "advanced" usage is copy-paste · Provide safe high-level APIs; hide primitives "It's the developer's responsibility" · Blame-shifting; you designed the footgun · Remove the footgun or make it impossible to misuse

Fluxly profile Runtime and permissions are inferred by Fluxly static checks, not author declarations or runtime test results.
Domain
Other
Author-declared agents
No explicit declaration found; this is not inferred or tested compatibility
Static check
88 / 100 · heuristic scan, not runtime safety proof
Runtime evidence
Not run; no isolated runtime test evidence is currently recorded
Author / version / license
@trailofbits · no license declared
Token usage
Lean
Setup complexity
Guided setup
External API key
Not required
Operating systems
Unspecified (assume cross-platform)
Runtime requirements
Python
Detected file/system behavior
  • Read-only
  • Write / modify
  • Env read
Network behavior
Local-only
Install commands
None (reference only)

Heads up: Tool permissions are not declared; actual access depends on the runtime.

01
Phase 1: Surface Identification

Map security-relevant APIs: authentication, authorization, cryptography, session management, input validation Identify developer choice points: Where can developers select algorithms, configure timeouts, choose modes? Find configuration schemas: Environment variables, config files, constructor parameters

02
Phase 2: Edge Case Probing

For each choice point, ask: Zero/empty/null: What happens with `0`, `""`, `null`, `[]`? Negative values: What does `-1` mean? Infinite? Error? Type confusion: Can different security concepts be swapped? Default values: Is the default secure? Is it documented?

03
Phase 3: Threat Modeling

Consider three adversaries: The Scoundrel: Actively malicious developer or attacker controlling config Can they disable security via configuration? Can they downgrade algorithms? Can they inject malicious values?

04
Phase 4: Validate Findings

For each identified sharp edge: Reproduce the misuse: Write minimal code demonstrating the footgun Verify exploitability: Does the misuse create a real vulnerability? Check documentation: Is the danger documented? (Documentation doesn't excuse bad design, but affects severity) Test mitigations: Can the API be used safely with reasonable effort?

Discussion

Powered by GitHub Discussions. Sign in with GitHub to comment, react, or subscribe.