Claude Skills by Dadmin88

Design and test fault tolerance by defining expected faults, containment boundaries, detection, failover, retry/replay semantics, state reconciliation, and safe recovery after partial failure.

Design system reliability from user-critical outcomes through service objectives, dependency budgets, redundancy, graceful degradation, recovery, observability, and operational ownership.

Design a multi-service or distributed system around responsibilities, protocols, topology, identity, consistency, failure, capacity, observability, and evolution.

Model a system's logical and physical topology across services, nodes, networks, state, control planes, trust boundaries, failure domains, dependencies, and communication paths.

MUST load first for Academy learning or go-learn requests.

Design or troubleshoot an art production pipeline across DCC tools, import/export, shaders, assets, validation, automation, and runtime constraints.

Profile and optimize art-asset runtime cost across geometry, materials, textures, animation, VFX, draw calls, overdraw, memory, streaming, and scene density without sacrificing visible intent blindly.

Define and validate the art-to-engine contract for formats, scale, naming, materials, rigs, animation, metadata, import settings, automation, and ownership across distributed production.

Design procedural art tools that encode repeatable artistic constraints while exposing useful controls, deterministic generation, editable outputs, performance limits, and safe artist override.

Diagnose shader and material failures using reproduction, render-state inspection, inputs, spaces, precision, variants, platform differences, and frame or debugger evidence.

MUST load first for Academy learning or go-learn requests.

Scope an engineering change in an unfamiliar or evolving codebase by tracing entry points, ownership, callers, data flow, tests, configuration, generated artifacts, and adjacent contracts before assigning implementation work.

Coordinate parallel engineering implementation by keeping ownership, contracts, dependencies, integration state, blockers, and validation evidence aligned without taking over specialists' work.

Plan how independently owned engineering changes will combine into one working system, including interface readiness, merge order, data/schema compatibility, feature exposure, test environments, and rollback checkpoints.

Convert approved product scope and architecture into a coordinated technical execution plan across engineering specialties.

Assess implementation risk across uncertainty, blast radius, compatibility, data, concurrency, dependencies, performance, security, operations, and reversibility so engineering effort follows the risks that can actually derail delivery.

MUST load first for Academy learning or go-learn requests.

Diagnose configuration failures by comparing effective values, precedence, environment, defaults, validation, and version compatibility rather than assuming the visible file is authoritative.

Prepare an engineering escalation with minimal reproduction, impact, evidence, suspected boundary, failed hypotheses, workaround status, and exact decision or fix needed.

Recreate a customer or operator environment closely enough to validate a technical failure without copying secrets or unnecessary private data.

Turn noisy logs and traces into a precise failure timeline by correlating identifiers, requests, retries, dependencies, resource state, and user-visible outcomes.

Diagnose a complex support case by reconstructing environment, configuration, timeline, logs, network, dependencies, and reproduction evidence before assigning cause.

MUST load first for Academy learning or go-learn requests.

Write API documentation that lets a developer correctly authenticate, call, interpret, retry, paginate, version, and troubleshoot an interface using verified contracts and executable examples.

Validate documentation code examples by executing them against the documented version, checking dependencies, setup, security, output, cleanup, platform assumptions, and consistency with current APIs.

Write a technical migration guide from a known old state to a supported new state with compatibility, prerequisites, staged changes, data or configuration transformation, verification, mixed-version behavior, and recovery.

Coordinate the technical documentation required for a release by identifying changed behavior, affected pages, new reference, migration, configuration, examples, troubleshooting, and versioned notices tied to the released state.

Write an operational runbook that turns a recurring or incident response task into safe prerequisites, diagnostics, actions, verification, rollback or recovery, escalation, and evidence capture.

Produce precise developer and operator documentation from verified implementation, interfaces, constraints, examples, and failure behavior.

MUST load first for Academy learning or go-learn requests.

Design and improve build tooling around dependency graphs, incremental correctness, caching, generated inputs, hermeticity, diagnostics, parallelism, reproducibility, and developer/CI feedback time.

Design command-line interfaces with task-oriented commands, predictable arguments, composable output, stable exit behavior, safe destructive operations, discoverable help, and script compatibility.

Build maintainable code generators with explicit source schemas, deterministic output, minimal generated surface, safe overwrite rules, versioning, validation, and a migration path for generated consumers.

Build developer tooling that turns a repeated engineering workflow into a fast, safe, discoverable, scriptable, and diagnosable interface.

Integrate engineering capabilities into editors/IDEs with explicit protocol boundaries, workspace awareness, incremental updates, cancellation, diagnostics, compatibility, and fallback behavior.

Evaluate and improve an engineering tool through real task success, discoverability, defaults, feedback, error recovery, scriptability, latency, accessibility, and support evidence.

MUST load first for Academy learning or go-learn requests.

Balance incoming professional work across Agency owners and queues using current commitments, specialist scarcity, urgency, WIP, and service expectations without performing Fleet compute scheduling.

Diagnose persistent delivery bottlenecks from queue age, WIP, handoffs, dependencies, rework, specialist scarcity, approvals, and flow evidence before moving work or adding capacity.

Triage incoming work by clarifying requested outcome, source, urgency, authority, duplication, prerequisites, owner, and acceptance evidence before it enters active queues.

Triage competing work using urgency, impact, dependencies, capacity, and cost of delay while keeping ownership explicit.

Route incoming work to the correct Agency owner from decision responsibility, capability, urgency, dependencies, and current organizational load while leaving machine placement to Fleet.

MUST load first for Academy learning or go-learn requests.

Design assessments that validly measure the stated learning objectives using representative tasks, clear criteria, appropriate evidence, reliable scoring, and actionable remediation.

Build a curriculum that sequences prerequisite knowledge, explanation, demonstration, practice, feedback, assessment, and transfer to real work around defined learning objectives.

Design training exercises that make learners perform the target skill with realistic inputs, constraints, feedback, difficulty, and failure modes rather than merely restating lesson content.

Define observable learning objectives from real role performance, prerequisite knowledge, learner context, and success evidence instead of vague goals such as understand or know.

Design a practical training program from target behaviors, learner context, exercises, assessment, and reinforcement rather than information dumping.

MUST load first for Academy learning or go-learn requests.

Produce implementation-ready UI and UX specifications covering structure, states, behavior, content, responsive rules, accessibility expectations, tokens, components, and acceptance details without over-prescribing engineering internals.