uberarchitect

Diagnose system-design mismatches in agentic coding workflows with an Architecture Stepback Packet.

Updated Apr 30, 2026
One-click install
npx skills add https://github.com/rdleclerc/agentic-uber-skills --skill uberarchitect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: uberarchitect
Source: https://github.com/rdleclerc/agentic-uber-skills/tree/main/uberarchitect
Command: npx skills add https://github.com/rdleclerc/agentic-uber-skills --skill uberarchitect

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

Uberarchitect stops agents from chasing narrow implementation bugs when the real failure is a system-design mismatch, ensuring the workflow treats concurrency, scaling, and orchestration as architecture problems instead of local patch problems.

Core Features & Use Cases

  • Architecture Stepback Gate: Produces an architecture recommendation and proof plan instead of performing local code fixes.
  • System-Class Diagnosis: Identifies the system category (e.g., queue/worker, durable workflow, gateway, backpressure) and compares it to normal industry patterns.
  • Scope & Proof Guardrails: Requires a Scope revision gate when the fresh-start architecture materially differs, and defines a Proof gate to validate the architecture before rewrite effort.

Quick Start

Use uberarchitect when a project is stuck in repeated timeouts, throughput collapse, blocked pipelines, or micro-patch loops for concurrency and orchestration issues, and request an Architecture Stepback Packet with system class, normal industry pattern, fresh-start design, mismatch, demoted symptom patches, transition path, proof gate, and recommendation.

Frequently Asked Questions about uberarchitect

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

FAQPage Schema
How do I stop repeated timeouts and throughput collapse in my queue worker system?

Repeated timeouts and throughput collapse in queue worker systems often indicate a system-design mismatch requiring an architecture stepback rather than local patches. An Architecture Stepback Packet diagnoses the system class, compares it to normal industry patterns, and defines a fresh-start design with proof gates to validate the fix before rewrite effort.

When do I need an architecture stepback for concurrency and orchestration failures?

An architecture stepback is needed when projects are stuck in micro-patch loops, blocked pipelines, or multi-agent coordination issues. It forces senior system-shape architecture before fixes by diagnosing the system class, identifying the current mismatch, and demoting symptom patches to address root causes.

What is the best way to handle backpressure and scaling problems in durable workflows?

The best way to handle backpressure and scaling problems in durable workflows is to generate an Architecture Stepback Packet. It identifies the system class, maps the current mismatch against normal industry patterns, and defines a transition path with scope and proof guardrails to validate the architecture.

How do I create an Architecture Stepback Packet for multi-agent coordination issues?

Create an Architecture Stepback Packet for multi-agent coordination by including a diagnosis, system class, normal and fresh-start architectures, current mismatch, demoted symptom patches, transition path, scope and proof gates, and a human counterfactual or agent affordance gap analysis.

Does this approach work for gateway and agent routing failures in distributed systems?

Yes, this approach works for gateway and agent routing failures by applying architecture stepback logic to orchestration scenarios. It ensures local patches are demoted in favor of comprehensive system-class diagnosis, fresh-start architecture design, and validated transition paths for durable execution patterns.

What are the limitations of using local code patches for repeated concurrency failures?

Local code patches for repeated concurrency failures risk missing the root cause by treating system-level design mismatches as narrow implementation bugs. Without an architecture stepback, they fail to address underlying orchestration, scaling, or durable execution pattern mismatches, leading to continued system instability.