Progressive Disclosure
by alexander-opalic
A UX pattern that sequences information and actions across a series of stages to reduce complexity and cognitive load.
design
(34)The UX of Local-First
by eileen-wagner
The tech for local-first has matured but the UX hasn't — four unsolved design challenges stand between us and mainstream adoption, and they require collective agreement, not individual solutions.
Code Mode: Providing Complete APIs with Minimal Token Usage
by matt-carey
MCP's context bloat problem has a clean solution: give the agent two tools—search and execute—running in a V8 sandbox against the full OpenAPI spec, cutting 1.17M tokens to ~1K.
A Language For Agents
by armin-ronacher
The plummeting cost of code production makes new programming languages viable again—and the winning ones will optimize for machine readability over human brevity.
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.
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.
GraphQL Performance Issues at Netflix Scale
by steven-chambers
At Netflix's scale of 160 million resolver executions per second, even innocuous framework code can become a critical bottleneck. Doubling fleet efficiency came from fixing a simple introspection API call.
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.
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.
Building Type-Safe Compound Components
by tkdodo
Compound components work best for flexible layouts, not dynamic data or fixed structures. A factory function pattern solves the type safety problem without sacrificing flexibility.
It's Hard to Justify Tahoe Icons
by nikita-prokopov
Adding icons to every menu item defeats their purpose—differentiation requires scarcity, and when everything has an icon, nothing stands out.
Superhuman Is Built for Speed
by christina-marfice
Speed is Superhuman's core feature. Every interaction under 100ms feels instantaneous, and the product achieves this through local caching, preloading, and keyboard-first design.
GraphQL Guide
Patterns and tools for building GraphQL APIs—from schema design to Meta's fragment philosophy
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.
@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.
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.
Fixing GraphQL's Biggest Mistake in 512 Bytes
by benjie-gillam
GraphQL's error propagation destroys sibling data when non-null fields fail. A 512-byte library called graphql-toe transforms error-nulls into thrown errors, letting schemas express business semantics instead of error boundaries.
Refactoring: Improving the Design of Existing Code
by martin-fowler
The definitive guide to improving code structure without changing behavior. Fowler catalogs refactoring techniques with clear examples, making messy code maintainable.
Tidy First?
by kent-beck
A compact guide to code tidying—small, behavior-preserving changes that make code easier to understand and modify before making structural changes.
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.
13 Vue Composables Tips That Make Your Code Better
by michael-thiessen
Practical patterns for writing maintainable Vue composables, covering state management, reactivity handling, and code organization.
The 6 Levels of Reusability
by michael-thiessen
A progressive framework for Vue component reusability, from basic templating to sophisticated nested composition.
Agentic Design Patterns: A Hands-On Guide to Building Intelligent Systems
by antonio-gulli
A practical guide presenting 21 design patterns for building AI agents, covering prompt chaining, tool use, multi-agent collaboration, and self-correction techniques with examples in LangChain, CrewAI, and Google ADK.
AI Agents 4 - Prompt Chaining, Routing and Reflection
by mohammad-ghassemi
Michigan State University lecture covering three agentic design patterns—prompt chaining, routing, and reflection—with practical LangChain and LangGraph implementations.
AI Agents Guide
Patterns and practices for building autonomous AI agents with prompt chaining, routing, and reflection
Malleable Software
by ink-and-switch
A research agenda for malleable software—tools that users can adapt to their needs without relying on developers, restoring agency in an era of locked-down applications.
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.
Front-End Engineering is Dead, Long Live Front-End Composability
by nate-b-jones
Traditional front-end engineering (hand-coding pages from Figma designs) is being replaced by composability—designing primitives, schemas, and contracts that let AI, PMs, and designers ship dynamic interfaces without reinventing the wheel.
Securing Nuxt API Routes with Nitro Utils
by kiran-sai-subramanyam-k
Centralizing session validation through a reusable secure handler wrapper eliminates repetitive auth checks and improves maintainability.
Mastering Functional Programming with TypeScript
by art-deineka
A practical guide to functional programming in TypeScript using the fp-ts library, covering core concepts like referential transparency, currying, functors, and monads.
90% of My Skills Are Now Worth $0
by kent-beck
Kent Beck argues that AI has devalued 90% of traditional skills while giving the remaining 10% a 1000x leverage boost.
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.
Refactoring — Not on the Backlog!
by ron-jeffries
Refactoring should happen continuously during feature work, not as separate backlog items. Deferring code cleanup creates a vicious cycle that slows velocity and rarely gets approved.