unsafe-checker

Identify unsafe Rust patterns and FFI misuse in Rust projects.

1|Updated May 29, 2026
One-click install
npx skills add https://github.com/simorgh3196/tsuzulint --skill unsafe-checker
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: unsafe-checker
Source: https://github.com/simorgh3196/tsuzulint/tree/main/.agents/skills/unsafe-checker
Command: npx skills add https://github.com/simorgh3196/tsuzulint --skill unsafe-checker

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps teams identify and remediate unsafe Rust patterns, including unsafe blocks, raw pointers, and FFI usage, to prevent memory safety violations and undefined behavior.

Core Features & Use Cases

  • Static linting and review guidance for unsafe blocks to ensure SAFETY comments are present and explicit invariants are documented.
  • FFI boundary auditing to verify correct memory ownership, pointer nullability, and proper error handling patterns across Rust<->C interfaces.
  • Safe wrappers guidance to encapsulate unsafe logic behind safe APIs and minimize unsafely exposed surfaces.

Quick Start

Install or run the skill against a Rust codebase with unsafe patterns to generate a safety audit report and recommended fixes.

Frequently Asked Questions about unsafe-checker

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

FAQPage Schema
How do I audit unsafe Rust blocks and ensure proper SAFETY comments?

To audit unsafe Rust blocks, run the skill against your codebase to statically lint for unsafe patterns. It identifies missing SAFETY comments, verifies documented invariants, and guides remediation to prevent memory safety violations.

What is the best way to audit FFI safety and memory ownership in Rust projects?

Auditing FFI safety in Rust projects involves checking foreign function interfaces for correct memory ownership and pointer nullability. The skill reviews Rust<->C boundaries to verify proper error handling patterns and FFI misuse.

How do I create safe wrappers for unsafe Rust code and raw pointers?

Creating safe wrappers for unsafe Rust code requires encapsulating unsafe logic behind safe APIs. The skill guides you to minimize unsafely exposed surfaces and properly handle raw pointers, ensuring the external interface remains safe.

Can I use this to lint unsafe Rust patterns across multiple crates and executables?

Yes, you can lint unsafe Rust patterns across multiple crates and executables. The skill applies to codebases containing unsafe blocks, raw pointers, and foreign function interfaces, generating comprehensive safety audit reports.

Why do I need to document invariants when writing unsafe Rust code?

Documenting invariants in unsafe Rust code is necessary to enforce memory safety and prevent undefined behavior. The skill ensures explicit invariants are present in SAFETY comments, verifying that the unsafe block's preconditions are clearly justified.