Reading up on software-architecture

Shared folders and vector databases fail for multi-agent AI memory; a graph-shaped system with typed schemas, atomic commits, and Git-like branching solves this, as demonstrated by Omnigraph.

Co-locating workflow state and application data in Postgres enables atomic transactions that provide exactly-once execution without application-level idempotency logic.

Go Micro provides a unified runtime for building agents, services, and workflows with built-in AI capabilities like MCP and A2A gateways.

Google Chrome is fully removing Manifest V2 support in upcoming releases, finally ending the last loophole that allowed ad blockers like uBlock Origin to work.

HTML-in-canvas enables rich 3D web experiences without sacrificing accessibility or machine readability, signaling a future where human-facing design is no longer limited by document formats.

Perplexity introduces Search as Code (SaC), an architecture that exposes search stack components as programmable SDK primitives for AI agents to compose via generated Python code.

Commenters debate using Postgres for durable workflows, praising its flexibility but warning it often leads to building a poor copy of dedicated workflow engines like Temporal.

The AI compute market is shifting from homogeneous GPU clusters for training toward heterogeneous hardware for inference, where Cerebras' wafer-scale chips excel at high-speed token generation but may be overshadowed by agentic inference's need for large memory rather than raw speed.

A developer realizes vibe-coding with AI creates unmaintainable code and advocates for designing architecture by hand before prompting AI for implementation.

Microservices were originally a technical fix for organizational scaling, but the rise of AI coding agents now demands larger code ownership and new architectural boundaries, creating significant tension.

Many SaaS apps don't need servers; shipping the full backend to the browser via WASM, SQLite, and OPFS enables local-first single-user apps.

An interactive essay explains how agent memory systems work through context windows, embeddings, and retrieval architectures to overcome LLM statelessness.

The article argues that employing pure code or pure markdown to specify AI agent behavior is a failure mode, and advocates for a hybrid approach.

OpenDuck is an open-source DuckDB extension that adds distributed query execution with differential storage and hybrid local-remote processing.

Configuration flags often become permanent, accumulating maintenance burden and hiding design flaws, making them a form of technical debt.

Function naming, side-effect control, and strict model design (using branded types) are the core practices that keep a codebase self-documenting and maintainable.

A proposed separation of Wayland compositor and window manager into distinct components, as seen in the River project, aims to restore the modular flexibility users had in X11.

WordPress Playground now runs a full WordPress instance in-browser via WebAssembly, radically expanding where and how WordPress can be deployed.

Filesystems are emerging as a key context layer for AI agents, offering portable, owned data and interoperability without coordination, though context files risk reducing agent task success if overburdened.

A six-month evolution from fully agentic AI to a hybrid architecture shows 65% of workflow nodes now run as deterministic code, improving reliability and cost efficiency.

A developer created a fully functional x86 CPU emulator using only CSS, demonstrating Turing completeness of CSS, though it currently only runs in Chromium-based browsers.

Vercel recommends separating agent harness from generated code execution in isolated sandboxes with secret injection to prevent prompt injection and credential theft in agentic architectures.

Detailed design docs fail because they front-load decisions when information is lowest; a one-pager on intent and hard-to-reverse choices is more effective.

OpenClaw sacrifices the full observability of its minimal core (Pi) as it scales to a multi-agent gateway, creating un-auditable reasoning chains.

As AI agents scale, stateless interactions fail, making memory a systems problem requiring active maintenance—write control, deduplication, and purposeful forgetting—rather than simple storage.

The article outlines seven stages of scaling a system from zero to 10 million users, advocating incremental architecture evolution starting from a single server.

AI agent swarms cannot produce coherent software architecture because architecture requires global invariants, temporal persistence, and enforcement authority—properties that swarms structurally lack.

The article argues that social media data should be stored as open files in a distributed filesystem, using the AT Protocol's records, lexicons, and DIDs to decouple data from apps.

DeepSeek's Engram architecture adds conditional memory via N-gram lookup tables to LLMs, improving knowledge and reasoning benchmarks by offloading static pattern reconstruction from neural computation.

Software agents like Claude Code, operating in a loop with atomic tools and file interfaces, enable a new paradigm where features are outcomes described in prompts rather than hand-coded logic.

Software design requires hands-on experience with the codebase; abstract architecture without implementation involvement leads to flawed designs.

Effective software design in large existing systems requires deep codebase familiarity, making generic design advice largely useless for practical problems.

Large-scale distributed infrastructure lacks a complete datacenter OS analogous to a single-machine OS, with only fragmented proto-OS components existing today.

Claude's memory system uses on-demand tools and selective retrieval rather than pre-computed summaries, trading automatic continuity for on-demand depth.

Matt Webb argues that effective AI agents require continuous, pre-planned movement of context from creation to use, akin to plumbing.

OpenAI advises developers to build ChatGPT apps as focused, model-callable capabilities—small APIs that let users know, do, or show new things—rather than porting full products into chat.

Claude's Agent Skills use a prompt-based meta-tool architecture that injects specialized instructions and context modifications to guide complex workflows without executing code.

Browserbase forked Chromium and applied patches to remove automation signals and enable long-lived sessions, making headless browsers undetectable and stable for AI agents.

Google's Gemini uses a cautious, structured memory with timestamps and rationales, but underutilizes its vast cross-product data advantage.

Putting your site behind Cloudflare introduces a single point of failure and unnecessary risk for sites that don't need its DDoS or CDN benefits.

OpenAI demonstrates building a GPT-5.1 coding agent that scaffolds NextJS/shadcn apps using shell, web search, apply_patch, and Context7 MCP tools via the Agents SDK and Responses API.

A look at Forrester founder George Colony, who repeatedly predicted the Web's death over three decades but was consistently wrong as the Web evolved.

Many developers argue that CLI tools and direct API calls are simpler and more reliable than MCP for hooking LLMs to external systems.