rust-architect

Design Rust application architectures and generate documentation packages.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/towry/dots --skill rust-architect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: rust-architect
Source: https://github.com/towry/dots/tree/main/conf/claude-local-marketplace/skills/rust-architect
Command: npx skills add https://github.com/towry/dots --skill rust-architect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill guides the design and architecture of production-ready Rust applications, generating comprehensive documentation and guardrails for AI-driven development teams. It ensures adherence to Rust best practices, memory safety, and efficient concurrency, reducing architectural debt and development time.

Core Features & Use Cases

  • Full System Design: Covers project structure, tech stack, domain models, data layers, concurrency, and async patterns, ensuring a holistic architectural approach.
  • AI Collaboration Handoff: Creates detailed HANDOFF.md and Superpowers plans for Director/Implementor AI agents, streamlining the transition from design to implementation.
  • Mandatory Guardrails: Establishes NEVER_DO.md (prohibitions) and ALWAYS_DO.md (mandatory practices) rules for memory safety, testing, code quality, and security, enforcing high standards.

Quick Start

Design a new Rust web service using Axum and Tokio, with a PostgreSQL database, and generate the initial project structure and comprehensive architecture documentation.

Frequently Asked Questions about rust-architect

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

FAQPage Schema
How do I design a production-ready Rust architecture for a new system?

Production-ready Rust architecture design covers project structure, tech stack selection, domain models, data layers, and concurrency patterns. This Skill generates comprehensive documentation including system design decisions, async/await patterns using Tokio, multi-crate workspace organization, and architectural decision records to guide implementation from concept to handoff.

What's the best way to structure async/await patterns in a Rust application?

Async/await patterns in Rust require careful planning around Tokio runtime setup, task spawning, channel usage, and error propagation through Result types. This Skill designs these patterns holistically within your full system architecture, ensuring fearless concurrency while maintaining memory safety and type safety guarantees.

How do I organize a multi-crate Rust workspace for team collaboration?

Multi-crate workspace organization in Cargo involves dependency separation, module boundaries, and shared build configuration. This Skill structures workspaces for clarity and maintainability, then generates HANDOFF.md documentation and Superpowers plans that enable AI agents and teams to implement confidently without rework.

Can I use this to create architecture documentation for AI-driven development?

Yes. This Skill generates mandatory guardrails files—NEVER_DO.md and ALWAYS_DO.md—that codify memory safety rules, error handling via Result, testing standards, and security practices. Combined with detailed handoff documentation, these establish clear constraints for Director and Implementor AI agents to follow during implementation.

What ownership and borrowing patterns should I enforce in my Rust system design?

Ownership and borrowing are foundational to Rust memory safety. This Skill integrates ownership patterns into your architecture upfront—designing data flow, lifetime boundaries, and reference semantics across async tasks and multi-crate boundaries—reducing architectural debt and unsafe code later.

Does this cover database integration with async Rust applications?

Yes. This Skill designs data layers using sqlx and async patterns, covering connection pooling, query execution within Tokio tasks, and error handling strategies. Architecture includes PostgreSQL integration examples and patterns for maintaining type safety and zero-cost abstractions in database code.