ledesixsixsix

Designs a bounded multi-agent workflow: typed handoffs, graph limits, merge authority, failure and resume rules.

Routes an architecture request to the installed Architect skills that own it, and plans what to load in order.

Turns a decision your team already made into a complete ADR: context, options, rationale, consequences, follow-ups.

Runs an evidence-based architecture review: criteria, coverage, findings, owner responses and a recommended disposition.

Designs async HTTP operations: 202 Accepted polling contracts, job status lifecycles, and webhook completion callbacks.

Benchmarks technologies: Kafka vs RabbitMQ throughput, consumer lag latency, and KRaft consensus trade-offs.

Compares architectural styles: Event-Driven outbox patterns, synchronous REST traps, and sub-35ms p99 SLAs.

Architects testing platforms: 70/20/10 test pyramids, Consumer-Driven Contract testing via Pact, and mutation testing.

Architects deliverable templates: standard Markdown shapes, placeholder elimination linters, and CI quality gates.

Models UML 2.5 state machines: composite state hierarchies, event-driven transitions, and immutable terminal states.

Architects specifications: IETF RFC 2119 normative keywords, embedded JSON Schema contracts, and CI linter gates.

Models UML 2.5 sequence flows: synchronous gRPC lifelines, asynchronous event publishing, and 1.5s timeout fragments.

Models cloud network architectures: Transit Gateway hubs, segregated route domains, and central inspection DMZ firewalls.

Models physical ERDs: Crow's Foot cardinalities, RESTRICT foreign keys, and covering composite index candidates.

Architects Docs-as-Code platforms: Git colocation, 90-day freshness review SLAs, and automated markdown linters.

Architects visual diagramming platforms: C4 model hierarchies, Plaintext Diagram-as-Code, and automated SVG builds.

Models UML 2.5 deployment topologies: 3-AZ active-active distribution, topology spread constraints, and CloudHSMs.

Models C4 Level 1 system context: perimeter boundaries, external actor personas, and partner banking network links.

Models C4 Level 2 containers: deployable units, mTLS gRPC protocols, single-owner databases, and sub-45ms latency.

Models C4 Level 3 component boundaries: thread-pool bulkheads, transactional outbox relays, and gRPC contracts.

Models C4 Level 4 code diagrams: interface ports, constructor dependency inversion, and thread-safe DTO records.

Models UML 2.5 class structures: DDD aggregate roots, private encapsulation, and immutable MonetaryAmount objects.

Architects readiness checklists: declarative YAML schemas, dynamic applicability predicates, and 90-day waivers.

Models BPMN 2.0 business processes: cross-functional swimlanes, message flows, and boundary error compensation.

Architects decision governance: MADR 3.0 standards, immutable decision lifecycles, and automated CI linters.

Architects documentation appendixes: RFC 2119 glossaries, regulatory standards matrices, and data dictionaries.

Models UML 2.5 activity diagrams: synchronized fork/join concurrency, decision guards, and exception rollbacks.

Selects identity providers: Keycloak sovereign EKS hosting, FIDO2 WebAuthn passkeys, and sub-20ms token minting.

Models architectural scalability: Universal Scalability Law (USL), contention/coherency coefficients, and sharding.

Analyzes architectural risk: Failure Mode and Effects Analysis (FMEA), RPN scoring, and defense-in-depth mitigations.

Audits software maintainability: ISO 25010 sub-characteristics, pure domain decoupling, and 85% branch coverage.

Analyzes architecture pros/cons: GraphQL vs REST BFF, N+1 query defense, and sub-45ms p99 checkout execution.

Evaluates architectural options: Pugh weighted decision matrices, normalized weights, and sensitivity stress testing.

Models architectural costs: serverless vs container crossover points, unit economics, and 3-year TCO projections.

Rates architectural complexity: McCabe cyclomatic complexity AST parsing, Martin coupling metrics, and CI gates.

Architects enterprise mobile apps: Kotlin Multiplatform shared logic, native SwiftUI/Compose, and SQLDelight sync.

Selects AI foundation models: legal reasoning benchmarks, 128k context recall, and prompt caching token savings.

Audits software licenses: CycloneDX SBOM scanning, copyleft contamination elimination, and automated third-party notices.

Audits regulatory compliance: PCI-DSS v4.0 tokenization, GDPR Article 32 security, and 365-day immutable audit trails.

Architects modern frontend platforms: micro-frontends via Module Federation, sub-1.8s LCP, and isolated design tokens.

Architects enterprise desktop apps: Tauri 2.0 Rust core, strict IPC command allowlists, and SQLCipher AES-256 storage.

Models 3-year Total Cost of Ownership: fully-loaded CapEx/OpEx, high-density power facilities, and 36.8% hybrid savings.

Analyzes architectural ROI: 5-year Discounted Cash Flow models, 34.2% IRR hurdle compliance, and Monte Carlo stress tests.

Plans FinOps waste reclamation: mandatory tag governance, automated anomaly detection, and $4.8M cost reductions.

Architects cloud FinOps: Cost-per-Transaction unit economics, automated rightsizing, and 32.5% recurring savings.

Estimates monthly cloud spend: first-principles unit models, cross-AZ network pricing, and commitment discounts.

Architects green cloud platforms: Scope 3 carbon tracking, Graviton3 ARM64 silicon, and renewable grid routing.

Selects enterprise storage: AWS S3 Object Lock compliance WORM, automated Glacier tiering, and 87% cost reduction.

Architects SRE platforms: multi-burn-rate alerting, automated CI/CD deployment freezes, and a strict 50% toil cap.

Architects scalable platforms: stateless container fleets, AWS Karpenter sub-45s scaling, and DB read-write splitting.

Plans engineering resources: Team Topologies structures, 70/20/10 capacity allocation, and skill gap remediation.

Architects enterprise resilience: thread-pool bulkheads, CoDel adaptive load shedding, and edge rate-limiting.

Architects site reliability: 99.99% availability SLOs, Envoy circuit breakers, degraded fallbacks, and chaos testing.

Architects enterprise releases: automated release trains, SLSA Level 3 attestations, and non-bypassable CI/CD cutover gates.

Architects low-latency performance: DPDK kernel bypass, lock-free SPSC ring buffers, and sub-1,200µs tail-latency SLAs.

Architects platform operability: three-tier health probes, executable SSM runbooks, and 30s connection-draining shutdowns.

Architects observability platforms: OpenTelemetry standards, W3C TraceContext linking, and sub-5m root-cause identification.

Selects observability platforms: native OpenTelemetry instrumentation, high-cardinality filters, and S3 tiers.

Architects cloud migrations: Strangler Fig API proxies, dual-run shadow reconciliation, and sub-5s rollbacks.

Selects programming languages: sub-500µs Rust determinism, zero GC jitter, and compile-time memory safety.

Architects disaster recovery: Warm Standby multi-region pilot lights, Aurora Global DB, and 15-minute RTO.

Architects continuous deployment: ArgoCD GitOps, progressive canary analysis, and sub-60s automated rollbacks.

Selects container runtimes: native Kubernetes CRI containerd, gVisor syscall sandboxing, and sub-1.5s startup.

Selects enterprise cloud providers: European EBA sovereignty enclaves, sub-4ms Aurora databases, and FIPS HSMs.

Models infrastructure capacity: M/M/c/K burst sizing, socket buffer tuning, and 35% headroom allocations.

Architects capacity planning: M/M/c queueing models, scheduled pre-warming, and 30% headroom governance.

Architects high-availability platforms: 3-AZ active-active meshes, sub-3s ARC evacuation, and error budgets.

Architects vector databases: distributed Milvus clusters, HNSW indexing with SQ8 quantization, and sub-10ms recall.

Architects event streaming: Apache Kafka KRaft clusters, deterministic partition keys, and cooperative sticky rebalancing.

Designs database sharding: horizontal range-hash partitions, MurmurHash3 routing, and cross-shard 2PC avoidance.

Selects search engines: complex Boolean proximity queries, document-level security, and open Apache 2.0 licensing.

Architects enterprise search platforms: hybrid dense/sparse retrieval, OpenSearch clusters, and zero-downtime aliases.

Designs physical database schemas: 3NF relational DDL, covering composite B-Tree indexes, and sub-4.5ms query latency.

Defines data retention: statutory retention schedules, automated S3 tiering, WORM legal holds, and cryptographic purging.

Designs database replication: synchronous multi-AZ storage quorum, sub-1s cross-region lag, and RPO=0 automated failover.

Designs database partitioning: composite range-hash keys, automated chunk lifecycle, and sub-15ms pruning queries.

Assesses relational normalization: 3NF/BCNF functional dependencies, update anomaly prevention, and governed caching.

Architects active metadata platforms: OpenLineage collectors, column-level lineage graphs, and CI/CD blast-radius gates.

Architects master data management: Fellegi-Sunter probabilistic matching, additive survivorship, and EMPI Golden Records.

Architects data lakehouses: open Delta Lake storage, ACID transactions, time-travel auditing, and unified BI/ML queries.

Architects batch ETL platforms: Airflow DAG orchestration, Apache Spark WAP patterns, and automated ledger reconciliation.

Evaluates database technologies: workload access patterns, columnar compression, and standard SQL time-series downsampling.

Architects enterprise databases: RDS Proxy connection multiplexing, polyglot persistence tiering, and sub-12ms query speed.

Architects data warehouses: Kimball dimensional models, star schemas, SCD Type 2 history, and sub-3s BI queries.

Architects data platforms: self-service developer portals, decoupled storage/compute, and FinOps quota controls.

Architects data pipelines: Apache Flink stateful streaming, exactly-once 2PC sinks, and non-halting DLQ isolation.

Designs database migrations: zero-downtime expand-and-contract, adaptive throttling, and automated rollback.

Architects enterprise data lakes: multi-zone medallion storage, Apache Iceberg ACID tables, and automated compaction.

Architects enterprise data governance: Data Mesh domain ownership, automated data contracts, and BCBS 239 lineage.

Designs data encryption: application-layer envelope encryption, FPE tokenization, AES-256-GCM, and FIPS HSM custody.

Architects CDC platforms: log-based Debezium pipelines, schema evolution contracts, outbox patterns, and event streaming.

Selects caching technologies: complex data structures, sub-3ms latency, multi-AZ failover, and operational cost.

Architects distributed caching: multi-tier cache topologies, XFetch stampede defense, and invalidate-on-commit contracts.

Designs database backup architectures: continuous WAL archiving, 5-minute RPO, automated restore drills, and WORM vaults.

Enforces technical standards: ArchUnit boundary rules, technology radar allowlists, and AST linter build breakers.

Architects review governance: multi-tier review rubrics, evidence-first intake, ARB charters, and disposition tracking.

Enforces CI/CD quality gates: non-bypassable branch protection, automated build breakers, and latency baselines.

Defines binding architecture policies: normative RFC 2119 rules, automated OPA gates, and 90-day waiver lifecycles.

Architects legacy modernizations: Strangler Fig proxies, dual-run shadow reconciliation, and automated rollbacks.

Validates readiness checklists: evidence attachment audits, applicability predicates, waiver lifecycles, and gating.

Audits systems against best practices: 12-factor compliance, API hygiene, cloud-native maturity, and remediation.

Detects architectural smells: cyclic dependencies, distributed monoliths, coupling metrics, and false-positive triage.

Maps value streams: process vs lead times, queue delays, percent complete and accurate (%C&A), and waste elimination.

Architects value stream networks: stage boundaries, flow metrics, capability alignment, and operating topologies.

Maps architectural stakeholders: power-interest grids, salience models, RACI decision rights, and engagement pathways.

Analyzes stakeholder interests: hidden objections, organizational resistance, incentive alignment, and compromise paths.

Establishes architectural scope boundaries: in-scope vs out-of-scope matrices, non-goals, and scope change governance.

Discovers architectural risks: impact-probability scoring, failure modes, mitigation controls, and residual risk registers.

Analyzes functional requirements: disambiguation, acceptance criteria, conflict resolution, and verification testability.

Architects product line architectures: core-asset reuse, feature variability models, and multi-tier product platforms.

Maps organizational teams to software architectures: Conway's Law alignment, ownership boundaries, and cognitive load.

Architects enterprise organization structures: Team Topologies, operating models, interaction modes, and governance rights.

Discovers and quantifies quality attribute NFRs: latency percentiles, availability, throughput, and verifiable metrics.

Architects industry-specific reference architectures: BIAN, FHIR, TM Forum ODA, and sector regulatory compliance models.

Architects enterprise architecture: BDAT blueprints, architecture review governance, transition roadmaps, and debt control.

Discovers cross-system dependencies: coupling analysis, circular dependency traps, blast radius, and critical paths.

Discovers outer system context boundaries: stakeholder viewpoints, regulatory framing, and environmental interfaces.

Analyzes architectural constraints: mutability classification, regulatory boundaries, cost of compliance, and trade-offs.

Maps business capabilities to application systems: realization matrices, redundancy detection, and system-of-record bounds.

Models operational business processes: BPMN 2.0 flows, decision gateways, exception routing, and handoff contracts.

Architects enterprise business process portfolios: process frameworks, governance models, and performance metrics.

Decomposes strategic business goals: metric formulation, conflict resolution, and architectural driver alignment.

Architects enterprise business capabilities: 3-tier capability maps, maturity scoring, and investment prioritization.

Architects business architecture: strategy mapping, value streams, business capabilities, and operating models.

Discovers hidden architectural assumptions: risk-impact scoring, uncertainty mapping, and falsification experiments.

Architects workflow orchestration clusters: durable state engines, activity worker topologies, and cluster resilience.

Designs business workflow DAGs: step transitions, human checkpoints, retry timeouts, and compensation handlers.

Architects workflow platforms: state persistence, activity queues, signal/timer semantics, and durable execution engines.

Designs DDD value objects: primitive obsession elimination, structural equality, immutability, and self-validation.

Architects end-to-end solution architectures: cross-cutting system blueprints, integration views, and delivery roadmaps.

Evaluates SOA style: enterprise service bus integration, canonical data models, contracts, and ESB bottleneck trade-offs.

Evaluates Serverless style: cold-start latency, scale-to-zero economics, database connection limits, and FaaS trade-offs.

Selects third-party SDKs: official vs handwritten clients, transitive dependency bloat, licensing, and security postures.

Designs distributed sagas: orchestration vs choreography, compensating actions, pivot transactions, and idempotency.

Architects rule engines: DMN standards, Rete algorithms, conflict resolution, hot-reloading, and execution sandboxing.

Designs DDD repository contracts: aggregate reconstitution, explicit queries, unit-of-work bounds, and zero N+1 traps.

Architects enterprise reference architectures: golden-path blueprints, standardized stacks, and governance baselines.

Selects message brokers: log-based streams vs transient work queues, ordering, retention models, and operational fit.

Designs queue performance and flow control: consumer concurrency, prefetch limits, backpressure, and lag budgets.

Evaluates Microkernel and Plugin style: core stability, extension points, plugin sandboxing, and lifecycle trade-offs.

Architects plugin platforms: extension point SPIs, sandboxed runtimes, lifecycle controls, and developer extension SDKs.

Evaluates Pipes and Filters style: stream filter boundaries, pipe buffering, backpressure, and poison-pill fault isolation.

Architects maintainable monolithic systems: layer boundaries, shared-database scaling, and deployment pipelines.

Evaluates Modular Monolith: logical module boundaries, in-process calls, schema separation, and microservice trade-offs.

Architects modular monoliths: package boundaries, in-process event seams, schema isolation, and extraction readiness.

Evaluates Microservices style: independent deployability, distributed operational tax, data boundaries, and team readiness.

Architects microservice fleets: service boundaries, communication topologies, data autonomy, and resilient runtimes.

Evaluates Data Mesh style: decentralized data ownership, data products, self-serve platforms, and federated governance.

Designs load balancing: weighted least-request routing, outlier detection ejections, panic modes, and slow-start warmups.

Architects software libraries and SDKs: public API surfaces, zero-dependency cores, SemVer evolution, and error models.

Evaluates Layered Architecture style: strict vs relaxed tiers, dependency flows, vertical slicing, and bypass trade-offs.

Architects integration adapters: Anti-Corruption Layers, protocol translation, error mapping, and idempotent relays.

Designs database indexes: composite column ordering, index selectivity, write-amplification bounds, and partial indexes.

Evaluates Hexagonal Architecture style: ports and adapters, framework-free domain core, and infrastructure pluggability.

Architects API gateway platforms: routing topologies, protocol mediation, authentication offloading, and rate limiting.

Evaluates backend frameworks: startup times, memory footprints, developer ergonomics, and cloud-native runtime trade-offs.

Discovers domain entities: identity continuity, lifecycle transitions, invariants, and Value Object boundaries.

Architects edge computing systems: PoP topologies, edge-versus-origin compute tiers, and edge state synchronization.

Evaluates Event-Driven Architecture: temporal decoupling, event stream topologies, ordering, and consistency trade-offs.

Architects rich DDD domain models: entity identities, immutable Value Objects, domain services, and invariant rules.

Designs domain event contracts: CloudEvents schemas, causation tracking, partition keying, and idempotency guarantees.

Models immutable domain business facts: naming, causal lineage, minimum payloads, and context-to-integration maps.

Architects business capability portfolios: 3-tier capability hierarchies, maturity heatmaps, and context mapping.

Architects enterprise Domain-Driven Design: ubiquitous language catalogs, strategic context boundaries, and aggregate models.

Evaluates CQRS architecture style: command/query separation, asynchronous projections, eventual consistency, and trade-offs.

Architects enterprise context maps: upstream-downstream topology, translation adapters, OHS contracts, and ACL governance.

Designs strategic context maps: upstream-downstream models, Anti-Corruption Layers, OHS/PL, and relationship matrices.

Designs shared-state concurrency control: optimistic locking, distributed mutexes, isolation levels, and deadlock avoidance.

Designs HTTP payload compression: Brotli/Gzip/Zstd algorithms, MIME allowlists, minimum size thresholds, and Vary headers.

Evaluates Clean Architecture style: dependency rules, framework-free domain cores, use cases, and testing trade-offs.

Evaluates Cell-Based Architecture: cellular blast-radius boundaries, routing keys, state isolation, and failure limits.

Designs caching architectures: cache-aside patterns, TTL freshness models, event invalidations, and stampede defenses.

Architects strategic DDD bounded contexts: ubiquitous language scoping, relationship maps, ACLs, and team alignment.

Architects client-specific BFF layers: tailored view models, downstream parallel aggregation, and mobile payload pruning.

Designs operation and data batching contracts: dual-trigger flushes, partial failure models, and memory buffering bounds.

Architects backend microservices: hexagonal boundaries, ports and adapters, outbox event relays, and resilient runtimes.

Designs pod autoscaling control loops: custom KEDA metrics, scaling rules, stabilization windows, and flapping prevention.

Governs API portfolios: cross-service contract standards, error and pagination profiles, stability tiers, and deprecation.

Designs DDD aggregate boundaries: aggregate roots, encapsulation, transaction invariants, and domain event contracts.