#Architecture
28 articles — newest first.
- 10 min read
Optimistic React UIs that don't drift from the server
How I ship optimistic UI in React without state drift: versioned writes, idempotency keys, React Query/Zustand patterns, and the rollback math.
- 10 min read
Stop mixing render and domain state in React dashboards
A pragmatic split for large React 18 dashboards: keep server/domain data out of UI stores, cut re-renders and payloads with a thin serialization adapter.
- 8 min read
Zero-Account Auth: Device-Bound Identity + Capability Tokens
Build secure apps without accounts or an auth server: bind identity to device keys, mint PASETO capability tokens, and enforce DPoP for stateless, least-privilege access.
- 6 min read
Vision Over Syntax: I Design the Entire Product in My Head Before the First Commit
Syntax is solved; vision is not. How architecture-first thinking — data contracts, trust boundaries, and deliberate refusals — is the real engineering skill in the AI era, shown through shipped products.
- 6 min read
The 94% Decision: One Architecture Call That Made IntegrateX Feel Instant
Persisting React Flow's UI objects nearly sank the product. Drawing a serialization boundary between view and domain cut payloads 94% — the reasoning behind the call, and how to audit your own product for it.
- 9 min read
Pinning a 1.8% Idle CPU: Evented vs Polling in Tauri Tray Apps
A ruthless, code-first look at hitting a ~1.8% idle CPU budget in long‑running Tauri tray apps by replacing polling with event‑driven plumbing.
- 7 min read
Custom Serialization Adapters: 94% Payload Compression
Rich UI objects make terrible database records. The Serialization Adapter pattern that separates render model from transport record — and cut IntegrateX payloads by 94%.
- 7 min read
Redux Toolkit Architectures for Massive Enterprise State
RTK made Redux's boilerplate reputation obsolete. Structuring feature slices, normalizing with entity adapters, offloading server state to RTK Query — and when not to reach for it.
- 6 min read
The AI-Native Portfolio: Landing Lead Roles by Shipping the System
A portfolio that lists 'used ChatGPT' reads junior. One that demonstrates systems architecture — RAG, agents, guardrails, latency budgets — reads like the lead they're trying to hire. Here's how to build the second one.
- 7 min read
TypeScript Migration Without a Feature Freeze
My TypeScript migrations skipped the feature freeze: allowJs coexistence, strictness ratcheted one flag at a time, and any quarantined behind a single typed boundary.
- 7 min read
Stateful AI Memory: The Context Window Is RAM, Not Disk
Sable remembers users across sessions, so I tier its stateful memory into a working buffer, an episodic vector store, and durable semantic facts.
- 8 min read
The 10x Reality: How AI Replaced the Traditional MERN Squad
AI shifted the engineer's job from writing syntax to directing architectural flow. Why one architect with Claude now outships a traditional 10-person MERN squad.
- 7 min read
Architecting a MERN Stack at AI-Speed
How an agentic AI workflow shifts the engineering bottleneck from typing to architecture — letting one developer ship a production MERN stack in days.
- 7 min read
How I Run Agents Off a React Flow Canvas, Not a Diagram
On IntegrateX, the React Flow graph a PM drags is the exact spec the runtime executes — typed nodes and ports make it a debuggable agent orchestration layer.
- 7 min read
FinOps for AI: Routing, Caching, and Cost Attribution
At scale, cost per request is an architectural property you design, not an invoice surprise. FinOps for AI uses three levers — a semantic cache, a difficulty-aware model router, and per-tenant attribution — to govern the token-spend curve.
- 7 min read
When Logs Lie: Tracing LLM Agents with OpenTelemetry
The live RAG concierge on this site ships a span per step — tokens, cost, latency in OpenTelemetry — which is how I trace LLM agents, not guess from logs.
- 8 min read
Prompting for Architecture: Building Full-Stack Systems with Claude
Coding with AI is easy; architecting with it is hard. Shadow Documentation and strict contextual boundaries are how you build enterprise systems with Claude — the exact workflow behind streamerOS.
- 7 min read
Guardrail Engineering: Preventing Hallucination in Production
You can't fine-tune away hallucination, but you can engineer around it. Guardrails are deterministic checks wrapped around a probabilistic core — input validation, grounding contracts, and output verification that fail closed.
- 6 min read
The Router-Agent Pattern: Multi-Agent Orchestration Without the Chaos
Adding agents is how multi-agent systems become untraceable. The router-agent pattern keeps a single narrow classifier at the front, dispatching each request to exactly one specialist — with a confidence-gated fallback.
- 10 min read
Multi-Agent Worktrees & Parallel Subagents
One context can't hold a migration and one agent can't parallelize itself. An orchestrator fans work out to isolated git-worktree subagents and fans the results back in.
- 10 min read
Stateful Agent Runtime: Durable Objects + Redis
A crash mid-run erases a stateless agent's progress. Checkpoint the agent's state machine to Durable Objects and Redis so it resumes from the last good step — exactly once.
- 9 min read
Enterprise MCP Aggregation: Postgres, Figma & Playwright
Wiring three MCP servers into an agent is easy; governing a fleet is the enterprise problem. An aggregation gateway gives one namespaced, auth-brokered, role-filtered surface.
- 6 min read
Cutting a Payload 94% With Custom Serialization Patterns
I cut a React Flow agent-graph payload 94% without losing a node — not with gzip, but by shaping a custom serialization format around the data: schema, not prose.
- 6 min read
The Model Context Protocol: USB-C for AI Tooling
Every integration you hand-wire between a model and a tool rots. MCP is a single protocol so any model can discover and call any tool, resource, or prompt — collapsing N×M bespoke adapters into N+M servers and clients.
- 7 min read
The Agentic Control Loop I Ship: A Budget and a Stop Gate
Across Sable and IntegrateX I built agents as a tight agentic control loop — observe, decide, act — with a hard step budget and a termination gate.
- 7 min read
How I Ground a RAG Agent So It Refuses Instead of Lying
The grounding contract behind my streamerOS support agent: I score-floor retrieval and bind the model to cited context, so it refuses instead of guessing.
- 6 min read
Beyond the Prompt: The LLM Mechanics Architects Actually Need
Prompt engineering is UX for a function you don't control. To architect with LLMs you need the mechanics: tokens, the context window as a byte budget, and why determinism is a sampling parameter — not a model property.
- 7 min read
The AI-Native Dev Stack: Rethinking MERN for Production AI
MERN didn't die — it grew a nervous system. The AI-native stack keeps Mongo, Express, React and Node but adds three new tiers — vector memory, a model gateway, and an orchestration loop — that change every architectural assumption.