Installation

$ npx skills add praxstack/skills-and-personas --skill backend-principle-eng-cpp-pro-max

Summary

Principal backend engineering intelligence for C++ systems and performance-critical services.
Actions: plan, design, build, implement, review, fix, optimize, refactor, debug, secure, scale backend code and architectures.
Focus: correctness, memory safety, latency, reliability, observability, scalability, operability.

Agent compatibility

Declared targets from SKILL.md / docs. Unmarked agents are not listed — the skill may still install via the CLI.

Claude Code Not declared

Cursor Not declared

Codex Not declared

GitHub Copilot Not declared

Windsurf Not declared

Gemini CLI Not declared

Cline Not declared

OpenCode Not declared

Repository health

Stars 1

License LICENSE

Default branch main

Open issues 4

Status Active

Package contents

Files included with this skill beyond the listing page.

skill md SKILL.md 4,074 B

docs SUMMARY.md 359 B

History

Feb 8, 2026 First seen on skills.sh

Sep 9, 2026 First recorded snapshot · 103 installs

SKILL.md

Backend Principle Eng C++ Pro Max

Principal-level guidance for C++ backend systems, low-latency services, and infrastructure. Emphasizes correctness, memory safety, and predictable performance.

When to Apply

Designing or refactoring C++ backend services and infrastructure
Reviewing code for memory safety, concurrency, and latency regressions
Building high-throughput networking, storage, or compute systems
Incident response and performance regressions

Priority Model (highest to lowest)

Priority	Category	Goal	Signals
1	Correctness & UB Avoidance	No undefined behavior	RAII, invariants, validated inputs
2	Reliability & Resilience	Fail safe under load	Timeouts, backpressure, graceful shutdown
3	Security	Hard to exploit	Hardened builds, safe parsing, least privilege
4	Performance & Latency	Predictable P99	Stable allocs, bounded queues, zero-copy where safe
5	Observability & Operability	Fast triage	Trace ids, structured logs, metrics
6	Scalability & Evolution	Safe growth	Statelessness, sharding, protocol versioning
7	Tooling & Testing	Sustainable velocity	Sanitizers, fuzzing, CI gates

Quick Reference (Rules)

1. Correctness & UB Avoidance (CRITICAL)

raii - Own resources with RAII and deterministic lifetimes
no-raw-ownership - Raw pointers only for non-owning references
bounds - Validate all indices and sizes at boundaries
invariants - Assert core invariants and state transitions
time - Use monotonic clocks for durations

2. Reliability & Resilience (CRITICAL)

timeouts - Explicit timeouts for every external call
backpressure - Bounded queues; apply load shedding
shutdown - Drain in-flight work with deadlines
bulkheads - Isolate thread pools by dependency

3. Security (CRITICAL)

safe-parse - Validate untrusted input; avoid unsafe string ops
harden - Compile with stack protection, PIE, RELRO, FORTIFY
secrets - No secrets in logs or core dumps
least-priv - Drop privileges and sandbox when possible

4. Performance & Latency (HIGH)

allocs - Minimize allocations in hot paths
copy - Prefer move or views; avoid unnecessary copies
cache - Improve locality; avoid false sharing
io - Use async I/O where appropriate
profiling - Measure before optimizing

5. Observability & Operability (HIGH)

logs - Structured logs with request and trace ids
metrics - RED/USE plus business KPIs
tracing - Propagate trace context across threads
crash - Symbolized crash reports and core dump policies

6. Scalability & Evolution (MEDIUM)

stateless - Externalize state, enable horizontal scale
partitioning - Shard by stable keys
versioning - Protocol and schema versioning
limits - Explicit limits on payloads and queue sizes

7. Tooling & Testing (MEDIUM)

sanitizers - ASan, UBSan, TSan in CI
fuzzing - Fuzz parsers and protocol handlers
tests - Unit, integration, and load tests
lint - clang-tidy, clang-format, warnings as errors

Execution Workflow

Clarify latency/SLOs, throughput, and cost budgets
Map data flow, thread model, and failure modes
Define interfaces and memory ownership contracts
Implement with bounded queues and explicit timeouts
Add observability and crash diagnostics
Validate with sanitizers, fuzzing, load tests
Review risks and publish runbooks

Language-Specific Guidance

See references/cpp-core.md for toolchain defaults, concurrency patterns, and hardening.

backend-principle-eng-cpp-pro-max