rust-developer

Identify bugs, unsafe patterns, and performance footguns in Rust code.

3|Updated Sep 14, 2025
One-click install
npx skills add https://github.com/david-deji/oaxaca-blinder-rs --skill rust-developer-david-deji
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-developer
Source: https://github.com/david-deji/oaxaca-blinder-rs/tree/main/.agent/skills/rust-developer
Command: npx skills add https://github.com/david-deji/oaxaca-blinder-rs --skill rust-developer-david-deji

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps developers write, debug, and review Rust code with fewer compiler errors, safer file and path handling, better ownership decisions, and stronger performance habits.

Core Features & Use Cases

  • Rust best practices: Guides idiomatic patterns for error handling, ownership, type safety, and concurrency.
  • Production safety: Highlights file I/O hazards, borrow checker footguns, and validation gaps before they become bugs.
  • Code review support: Useful when auditing libraries, CLI tools, binaries, and hot paths for correctness and speed.
  • Use case: Review a Rust CLI that opens files, propagates errors, and shares state across threads to suggest safer patterns and more maintainable structure.

Quick Start

Use the rust-developer skill to review this Rust codebase for compiler issues, unsafe patterns, error handling gaps, and performance footguns, then suggest concrete fixes.

Frequently Asked Questions about rust-developer

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

FAQPage Schema
How do I review Rust code for unsafe patterns and performance footguns?

Reviewing Rust code for unsafe patterns requires auditing ownership decisions, file I/O hazards, and borrow checker footguns. You can identify validation gaps and suggest safer, idiomatic error propagation and concurrency patterns to improve correctness.

What is the best way to handle errors and file I/O in a Rust CLI?

The best way to handle errors and file I/O in a Rust CLI is using atomic file operations and explicit error propagation. This approach ensures structured logging and maintains type safety across failure paths.

How does Rust ownership and type safety prevent concurrency bugs?

Rust ownership and type safety prevent concurrency bugs by enforcing strict borrowing rules at compile time. This mechanism eliminates data races and requires idiomatic patterns for sharing state across threads.

Why does the Rust borrow checker reject my code during code review?

The Rust borrow checker rejects code due to validation gaps and borrow checker footguns. Code reviews help identify these issues by enforcing idiomatic ownership decisions and suggesting safer structural patterns.

Can I use this approach to audit Rust libraries and hot paths?

Yes, you can audit Rust libraries and hot paths by reviewing them for compiler issues and performance bottlenecks. This process highlights unsafe patterns and suggests concrete fixes for performance-sensitive code.