Progressive Disclosure
by alexander-opalic
A UX pattern that sequences information and actions across a series of stages to reduce complexity and cognitive load.
architecture
(51)Local-First Software
A comprehensive map of local-first software — from foundational philosophy and CRDTs to sync engines, tooling, and real-world production stories.
Sync Panel Discussion
by aaron-boodman, james-cowling, johannes-schickling, kyle-mathews
Four sync engine builders reveal that the real disagreement isn't sync vs. no-sync—it's where you draw the line between server authority and client autonomy, and every position demands different trade-offs.
Minions: Stripe's One-Shot, End-to-End Coding Agents — Part 2
by alistair-gray
The competitive moat in coding agents isn't the model — it's the orchestration layer. Stripe's Blueprints prove that mixing deterministic workflows with agentic flexibility, backed by 500 MCP tools, scales autonomous coding to 1,300+ PRs per week.
Minions: Stripe's One-Shot, End-to-End Coding Agents
by alistair-gray
Stripe's coding agents produce 1,000+ merged PRs per week by combining isolated devboxes, a customized Goose fork, MCP with 400+ internal tools, and aggressive feedback-left testing — proving that enterprise-scale autonomous coding demands custom infrastructure, not off-the-shelf solutions.
Raising An Agent - Episode 10
by amp
The IDE sidebar is a dead-end interaction model for coding agents—parallel, headless agent swarms that run for 45 minutes without human input replace the one-on-one assistant workflow.
Harness Engineering: Leveraging Codex in an Agent-First World
by ryan-lopopolo
When AI agents write all the code, engineering shifts from authoring to harness design—crafting navigable documentation, mechanical enforcement, and feedback loops that keep autonomous agents productive across thousands of pull requests.
Unrolling the Codex Agent Loop
by michael-bolin
The agent loop—a simple cycle of LLM calls and tool execution—is the core of every AI agent, but performance requires stateless design, prompt caching, and context compaction to avoid quadratic inference costs.
Config-driven Vue Interfaces with Dynamic Components
by jakub-andrzejewski
Vue's `<component :is>` enables config-driven UIs where data structures determine what renders, making interfaces flexible for CMS integration, A/B testing, and white-label products.
Raising An Agent - Episode 9
by amp
The assistant era is over—agents now write production code. The next frontier is building 'agent-native codebases' with feedback loops that let agents verify their own work autonomously.
Gas Town's Agent Patterns, Design Bottlenecks, and Vibecoding at Scale
by maggie-appleton
When agents handle code generation at scale, design and architectural planning become the bottleneck—implementation velocity no longer constrains development.
10 Principles for Designing Good GraphQL Schemas
by jens-neuse
Good GraphQL schemas start from client needs, not backend models. Ten principles—from capability-based design to organizational alignment—establish patterns for maintainable, evolvable APIs.
Spec Driven Development: When Architecture Becomes Executable
by leigh-griffin, ray-carroll
Specifications become the authoritative source of truth in software systems, with implementations continuously derived and validated against them—a paradigm shift that trades code-centric development for declarative intent.
Detecting AI Slop with Distance from Main Sequence
Normalized Distance from Main Sequence (D) identifies structurally poor code by measuring how far components deviate from the ideal balance of abstractness and stability—making it the single best metric for detecting AI-generated code that compiles but rots.
The Intersection of Fitness Function driven Architecture and Agentic AI
by neal-ford
MCP enables enterprise architects to express architectural intent without implementation details, solving the brittleness problem that has plagued fitness function governance at scale.
Functional Core, Imperative Shell - Introduction and Goals
by lachlan-miller
Pure functions that receive arguments and return new values (functional core) should handle business logic, while a thin imperative shell manages state mutation and UI integration.
A Look at the Functional Core and Imperative Shell Pattern
by mario-bittencourt
Business logic belongs in pure functions (functional core) while infrastructure concerns like databases and UIs live in the imperative shell—and the core must never call the shell.
A Software Library with No Code
by drew-breunig
Specification-only libraries work for simple utilities but foundational software still requires actual code, community oversight, and sustained maintenance.
Context Engineering for AI Agents with LangChain and Manus
by langchain
Context engineering—filling the context window with the right information at each step—determines agent performance more than model choice or complex frameworks.
Claude Agent SDK [Full Workshop]
by thariq-shihipar
Bash is the most powerful agent tool. The Claude Agent SDK packages Claude Code's battle-tested patterns—tools, file system, skills, sandboxing—for building coding and non-coding agents alike.
The Importance of Agent Harness in 2026
by philipp-schmid
As AI models converge in benchmark performance, the infrastructure managing them—Agent Harnesses—becomes the competitive differentiator for building reliable, multi-day workflows.
GraphQL Guide
Patterns and tools for building GraphQL APIs—from schema design to Meta's fragment philosophy
How AI Will Change Software Engineering
by gergely-orosz, martin-fowler
Martin Fowler argues AI represents the biggest shift in software engineering since assembly to high-level languages—not because of abstraction level, but because we now work with non-deterministic systems.
Implementing Fractional Indexing
by david-greenspan
A technique for maintaining ordered sequences in collaborative systems using string-based keys that allow arbitrary insertions without renumbering.
The Past, Present, and Future of Local-First
by martin-kleppmann
Martin Kleppmann traces local-first from CRDTs to a proposed definition: software where another computer's availability never blocks the user—including when the developer shuts down.
Unexpected benefits of going local-first
by tuomas-artman
Beyond performance and offline support, local-first architecture dramatically improves developer productivity by eliminating network error handling and enabling synchronous data access.
@async: Defer Even More!
by matt-mahoney
Meta's @async directive solves the problem of paying server compute costs for data that may never be displayed, using a persist-time transform that defers fragments until explicitly requested.
Building Evolutionary Architectures: Support Constant Change
by neal-ford, rebecca-parsons, patrick-kua
A framework for designing software architectures that evolve over time, using fitness functions to protect important characteristics while enabling incremental change.
Building Evolutionary Architectures
by neal-ford
Evolutionary architecture supports guided incremental change through fitness functions—automated tests that validate architecture characteristics like performance, security, and structural integrity.
Composition Is All You Need
by fernando-rojo
Replace boolean prop sprawl with compound components. Lift state to context providers and compose distinct component trees instead of branching with conditionals.
How To Use Fragments (They're Not for Re-use!)
by janette-cheng
GraphQL fragments describe data requirements for components, not reduce code duplication. Reusing fragments causes overfetching. Use fragment models, collocate GraphQL with code, and write GraphQL that mirrors your component structure.
The Context Window Problem
by varin-nair
Frontier models cap out at 1-2 million tokens, yet enterprise codebases span several million. Factory's solution: a five-layer context stack that delivers the right information at the right time.
Why Local-First Apps Haven't Become Popular
by marco-bambini
Explains why local-first apps remain niche despite their advantages—syncing data across distributed devices without losing information is genuinely hard.
12 Design Patterns in Vue
by michael-thiessen
A curated collection of 12 Vue-specific design patterns addressing common problems every app encounters, from state management to component organization.
Building Effective Agents
by erik-schluntz, barry-zhang
Anthropic's guide to building agentic LLM systems, advocating for simple composable patterns over complex frameworks.
What is Prompt Chaining in AI Agents? - Theory and Code
by yacine-mahdid
Prompt chaining breaks complex LLM tasks into sequential steps, each with a specific job and structured input/output, trading latency for reliability.
You Can't Design Software You Don't Work On
by sean-goedecke
Effective software design requires hands-on codebase knowledge—architects who don't implement their designs lack accountability and produce solutions that ignore concrete system constraints.
12 Factor Agents
by humanlayer-team
A manifesto for building production-grade LLM agents, arguing that effective agents combine mostly deterministic software with strategic LLM decision-making rather than naive 'loop until solved' patterns.
How to Structure Vue Projects
by alexander-opalic
A guide to structuring Vue projects at different scales—from flat folder structures for small apps, to modular monolithic architecture for medium-scale, to micro frontends for large enterprise projects.
Mastering Vue 3 Composables: A Comprehensive Style Guide
by alexander-opalic
A comprehensive style guide for writing clean, testable, and maintainable Vue 3 composables by applying time-tested software design principles like single responsibility, separation of concerns, and functional core/imperative shell.
Vue 3 Development Guide
A comprehensive guide to building maintainable, scalable Vue 3 applications
Welcome to Gas Town
by steve-yegge
Managing 20-30 parallel AI coding agents requires factory-scale orchestration—hierarchical roles, persistent state in Git, and structured workflow primitives that survive session crashes.
We Removed 80% of Our Agent's Tools
by andrew-qu
Stripping a text-to-SQL agent down to a single bash tool produced a 3.5x speedup, 100% success rate, and 37% fewer tokens—proving that simpler agent architectures outperform elaborate tooling.
Supporting the Transition to Self-Contained Systems Using Architecture Fitness Functions at Scale
by marc-olivier-fleury
Architecture fitness functions transform vague architectural principles into daily metrics, enabling organizations to track and drive large-scale migration from legacy systems to Self-Contained Systems through measurable, automated governance.
Everything is Context: Agentic File System Abstraction for Context Engineering
by xiwei-xu
Context engineering—not model fine-tuning—should be the central challenge for generative AI systems, solved through a Unix-inspired file system abstraction that treats all context components uniformly.
What I Learned Building an Opinionated and Minimal Coding Agent
by mario-zechner
Minimal coding agents outperform bloated ones because frontier models already understand agentic coding—so the harness should stay out of the way with fewer than 1,000 tokens of system prompt and just four tools.
Building a Modular Monolith with Nuxt Layers
by alexander-opalic
Nuxt Layers enable modular monolith architecture by enforcing feature boundaries at compile-time—each layer has its own config and components, preventing the coupling and circular dependencies that plague flat folder structures.
General-purpose Sync with IVM
by aaron-boodman
Query-driven sync turns out to be the key to general-purpose sync engines — and the trick that makes it work at interactive speeds is a novel IVM approach (ZVM) that pulls sorted data through operator pipelines instead of pushing everything.
An Object Sync Engine for Local-first Apps
by sujay-jayakar
The object sync engine — three components (local store, server store, sync protocol) wired together with server authority — is the architecture Linear, Figma, and Asana independently converged on. Convex is building their version.
A Map of Sync
by sujay-jayakar
The sync ecosystem is a wilderness — nine dimensions (size, update rate, structure, latency, offline, concurrency, centralization, flexibility, consistency) map where every platform sits and why no single engine wins everywhere.
A Practical Guide to Writing Technical Specs
by zara-cooper
Technical specs force engineers to think through problems before coding, align teams on deliverables, and prevent scope creep through eight essential components.