skills.rest
CyangZhou
CyangZhouCOMMUNITY
Explore all skills by this author →
GitHub

system_architect

Architect scalable backend systems in Rust/C++ with memory safety and explicit error handling.

2|Updated Jan 16, 2026
Search Tags:#architecture#backend#concurrency#rust#distributed#memory-safety#cpp
One-click install
npx skills add https://github.com/CyangZhou/-2--Project-Yunshu- --skill system-architect-cyangzhou
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: system_architect
Source: https://github.com/CyangZhou/-2--Project-Yunshu-/tree/main/.trae/skills/system_architect
Command: npx skills add https://github.com/CyangZhou/-2--Project-Yunshu- --skill system-architect-cyangzhou

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill helps engineers design scalable, memory-safe backend architectures using Rust by default, with safe C++ lifecycle management when needed, enabling robust distributed systems.

Core Features & Use Cases

  • Memory-safe design with Rust as the default language; if C++ is used, lifecycle management must be explicit and thoroughly documented.
  • Concurrency models based on Actor or CSP (Go channels) to minimize shared memory and race conditions.
  • Explicit error handling using Result<T, E> with clear failure modes and strong typing.
  • Use Case: Build a distributed microservice with high throughput and low latency while maintaining maintainability.

Quick Start

Begin by outlining a new backend service's performance and safety constraints and choose Rust as the primary implementation language to start modeling the architecture.

Frequently Asked Questions about system_architect

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

FAQPage Schema
How do I design a high-performance backend architecture that ensures memory safety and concurrency?▼

Design high-performance backend architecture by selecting Rust as the default language for memory safety, applying Actor or CSP concurrency models to minimize shared memory, and using explicit Result<T, E> error handling for robust distributed systems.

What is the best way to handle concurrency in a multi-core backend server without race conditions?▼

Handle concurrency in multi-core backend servers by adopting Actor or CSP models like Go channels. These approaches minimize shared memory and race conditions while ensuring deterministic performance and cache locality.

Can I use C++ instead of Rust for building a memory-safe distributed system?▼

You can use C++ instead of Rust for distributed systems, but you must require explicit manual lifecycle management and thorough comments to achieve equivalent memory safety and prevent faults in high-throughput services.

How do I structure error handling for low latency microservices to ensure fault tolerance?▼

Structure error handling for low latency microservices by using explicit Result<T, E> types. This enforces strong typing and clear failure modes, ensuring deterministic performance and robust fault tolerance.

When do I need to enforce cache locality and deterministic performance in backend architecture?▼

Enforce cache locality and deterministic performance when building high-throughput, multi-core backend servers. Focusing on these constraints ensures your distributed services maintain low latency under heavy concurrent loads.

Related Skills

Explore More Software Engineering Skills→
gelsonsimoesgelsonsimoes

rust-pro

Plan Rust 1.75+ async development with Tokio, axum, Serde, tests, linting, profiling, and optimization.

Community
Advanced
rainoftimerainoftime
17

message-passing-system

Implement message passing concurrency with actors and CSP channels.

Community
Intermediate
mtsatryanmtsatryan
1

microservices-architect

Design scalable microservice architectures with domain-driven service boundaries for Kubernetes.

Community
Advanced
grasberggrasberg
3

rust-pro

Develop memory-safe Rust services using Tokio and axum async patterns.

Community
Advanced