rust-pro

Design and optimize Rust services with Tokio, axum, and error handling.

Updated Apr 4, 2026
One-click install
npx skills add https://github.com/capaas2/Site-teste --skill rust-pro-capaas2
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-pro
Source: https://github.com/capaas2/Site-teste/tree/main/.agent/skills/rust-pro
Command: npx skills add https://github.com/capaas2/Site-teste --skill rust-pro-capaas2

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you design, implement, and optimize production-grade Rust solutions when you need memory safety, strong type guarantees, and high performance in the same system.

Core Features & Use Cases

  • Modern Rust Development: Use advanced Rust 1.75+ language features, traits, lifetimes, generics, and macro patterns correctly.
  • Async and Concurrency Design: Build services and tooling with Tokio, axum, channels, streams, and structured concurrency.
  • Performance and Systems Work: Improve throughput, reduce allocations, tune memory layout, and reason about low-level I/O and unsafe boundaries.
  • Use Case: You can ask for help debugging lifetime issues, creating a fast API service, building a concurrent data processor, or wrapping a C library safely.

Quick Start

Ask for help designing or fixing a Rust component, such as: build a high-performance async service with Tokio and axum, including tests and error handling.

Frequently Asked Questions about rust-pro

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

FAQPage Schema
How do I fix lifetime and ownership errors in Rust?

Resolving lifetime and ownership errors in Rust requires applying advanced lifetime annotations, trait bounds, and ownership patterns. This Skill helps debug these compilation issues to ensure memory safety and correct borrowing across your codebase.

How do I build a high-performance async API service with Tokio and axum?

Building a high-performance async API service with Tokio and axum involves structured concurrency, efficient I/O handling, and robust error management. This Skill provides modern Rust patterns to design concurrent data processors and fast services with reliable type guarantees.

What is the best way to reduce allocations and optimize throughput in systems programming?

Reducing allocations and optimizing throughput in systems programming is achieved by tuning memory layout and minimizing heap usage. This Skill helps improve performance by reasoning about low-level I/O, unsafe boundaries, and modern Rust language features.

Can I safely wrap a C library using Rust FFI?

Safely wrapping a C library using Rust FFI requires establishing secure unsafe boundaries and translating C pointers into safe Rust types. This Skill assists in creating FFI wrappers that maintain memory safety and strong type guarantees across the boundary.

Does this Skill support production Rust libraries requiring testing and linting?

Supporting production Rust libraries requires integrating testing, linting, and profiling into the development process. This Skill applies modern Rust patterns and reliable error handling to ensure production-grade code quality and memory safety for systems tooling and libraries.