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.