rust-pro

Develop production-grade Rust 1.75+ code with async patterns and type system usage.

31|Updated Jan 28, 2026
One-click install
npx skills add https://github.com/citum/citum-core --skill rust-pro-citum
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: rust-pro
Source: https://github.com/citum/citum-core/tree/main/.claude/skills/rust-pro
Command: npx skills add https://github.com/citum/citum-core --skill rust-pro-citum

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It helps you design and ship production-ready Rust 1.75+ code that is memory-safe, high-performance, and reliable under real async and concurrency workloads.

Core Features & Use Cases

  • Modern Rust mastery: leverage advanced language features (lifetimes, GATs, const evaluation, traits/macros) to express complex logic safely and clearly.
  • Production async & concurrency: build robust async services and pipelines with Tokio, axum/tower-style patterns, streaming, backpressure, and coordination primitives.
  • Performance and quality discipline: plan hot-path benchmarks, review string ownership decisions, and validate changes with measurable before/after results; includes testing strategies such as property-based and integration tests.

Quick Start

Ask: "Help me implement a high-performance Tokio-based async component in Rust 1.75+ with strong error handling and benchmarks for the hot path, and review my string ownership decisions for allocation hotspots."

Frequently Asked Questions about rust-pro

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

FAQPage Schema
How do I build a high-performance Tokio async component in Rust?▼

Build robust Tokio-based async pipelines by leveraging Rust 1.75+ features, explicit error handling, and backpressure coordination primitives. This ensures memory safety and reliable concurrency for production workloads.

How do I benchmark hot paths and optimize string ownership in Rust?▼

Optimize Rust hot paths by planning benchmarks, reviewing string ownership decisions for allocation hotspots, and validating changes with measurable before/after results. This discipline ensures high performance in sensitive rendering or parsing workflows.

Does this approach support building axum and tower-style web services?▼

Yes, it applies modern Rust async patterns to build axum and tower-style web services. It uses advanced type system features to create fast, reliable systems components with FFI-safe abstractions.

What is the best way to handle unsafe code and FFI invariants in Rust systems?▼

Handle unsafe code and FFI invariants by enforcing strict memory safety and explicit error handling in Rust 1.75+ systems. Careful validation of FFI boundaries ensures high performance without compromising reliability.

When should I use advanced Rust type system features like GATs and const evaluation?▼

Use advanced Rust type system features like GATs and const evaluation to safely express complex logic in fast, reliable systems. These features enable compile-time verification and efficient memory management for production async workloads.

How do I implement stream processing with backpressure in Rust?▼

Implement stream processing with backpressure using Tokio coordination primitives and modern async patterns in Rust 1.75+. This ensures robust pipelines that handle memory safety and explicit error handling under real concurrency workloads.