Best of Architecture — February 2026

  1. 1
    Article
    Avatar of techworld-with-milanTech World With Milan·12w

    Learn fundamentals, not frameworks

    Frameworks have short lifespans (median 3.3 years, frontend as low as 0.32 years), while fundamental concepts like algorithms, design patterns, and distributed systems remain relevant for decades. With AI now generating 41% of code, understanding fundamentals becomes more critical for debugging, architectural decisions, and code review. The 80/20 rule suggests spending 80% of learning time on timeless fundamentals (data structures, clean code, system design) and only 20% on frameworks, which you'll learn on the job anyway. Developers who invest in fundamentals can quickly adapt to new technologies and become expert generalists who thrive in an AI-enhanced world.

  2. 2
    Article
    Avatar of rhdevRed Hat Developer·11w

    The uncomfortable truth about vibe coding

    Vibe coding—building software through AI conversations—enables rapid prototyping but creates unsustainable codebases that become unmaintainable after 3 months. Projects hit walls when changes break multiple features because prompts become obsolete and code lacks intent documentation. Spec-driven development solves this by treating specifications as the authoritative blueprint, maintaining version-controlled documentation, and enabling regeneration from a single source of truth. The most effective approach combines natural language efficiency for exploration with rigorous specifications for production systems, using unit tests to validate small scopes while specs govern larger architecture.

  3. 3
    Article
    Avatar of addyAddy Osmani·13w

    Agentic Engineering

    Agentic engineering is a disciplined approach to AI-assisted software development that distinguishes itself from "vibe coding" through human oversight and engineering rigor. While vibe coding means accepting AI output without review (useful for prototypes and MVPs), agentic engineering involves treating AI agents as tools that handle implementation under careful human direction. The workflow requires writing specs before prompting, reviewing every diff, running comprehensive test suites, and maintaining ownership of the codebase. This approach disproportionately benefits senior engineers with strong fundamentals, as it trades typing time for review time and demands architectural thinking over raw code generation. The rise of AI coding raises rather than lowers the bar for software engineering craft.

  4. 4
    Article
    Avatar of itnextITNEXT·11w

    Sandwich Architecture

    The 'Sandwich Architecture' is a system topology that sits between layered and service-based architectures. It consists of a shared integration layer on top, domain-level services in the middle, and a shared data layer at the bottom. This pattern emerges naturally when a layered system's domain layer is split into subdomains while the integration and data layers remain intact. It suits medium-sized projects with complex domain logic, offering a pragmatic balance of simplicity and flexibility. The article covers its structure, performance characteristics, dependency options (orchestration, data change notifications, choreography), applicability, and evolution paths. Real-world examples include Blackboard Systems, Space-Based Architecture, Service-Based Architecture, and CQRS.

  5. 5
    Article
    Avatar of nxNx·10w

    A Monorepo Is NOT a Monolith

    Common objections to monorepos are addressed and debunked one by one. A monorepo is not a monolith — deployment and repository structure are orthogonal concerns. Code ownership can be enforced at the folder or project level using tools like GitHub CODEOWNERS or Nx's @nx/owners. Module boundaries and dependency constraints prevent the 'big ball of mud' problem. CI scalability is solved through affected-only builds, remote caching, distributed task execution, and test atomization. AI coding agents actually benefit from monorepo structure rather than being overwhelmed by it. Real challenges include the need for trunk-based development, more sophisticated CI setup, and careful handling of breaking changes to shared libraries.

  6. 6
    Article
    Avatar of itnextITNEXT·12w

    I follow an architecture principle I call The Law of Collective Amnesia

    Software systems inevitably drift from their original design as teams change and new requirements emerge. To combat this "collective amnesia," design systems where the correct architectural path is the easiest one to follow. Use contracts as constraints, control entry/exit points, build modular interfaces from day one, and assume future developers won't understand or follow your intentions. Documentation alone won't prevent architectural decay—structural guardrails that make the right choice the path of least resistance will.

  7. 7
    Article
    Avatar of nordicapisNordic APIs·13w

    Why It’s Good to Be API-First in the AI Era

    API-first design provides structural advantages for AI systems by creating efficient, well-documented, and standardized interfaces that AI agents can consume effectively. This approach improves agentic workflows through better discovery, error handling, and decision-making while reducing infrastructure costs. Standardization enhances security and auditability across multi-call workflows, and simplified data structures give organizations control over AI data access. API-first systems are naturally positioned to adopt emerging standards like Model Context Protocol (MCP), enabling structured tool invocation. The paradigm effectively makes organizations AI-ready by prioritizing clarity, discoverability, and consumability.

  8. 8
    Article
    Avatar of systemdesigncodexSystem Design Codex·11w

    Airbnb's Move from Monolith

    Airbnb migrated from a Ruby on Rails monolith ("monorail") to a Service-Oriented Architecture with four layers: data services, derived services, middle-tier services, and presentation services. The migration used dual reads with response comparison for read paths and shadow databases for write paths to ensure correctness before switching traffic. Key principles included single service data ownership, specific concerns per service, event-driven data changes, and proper observability. Important lessons emphasized investing in migration infrastructure early, simplifying dependencies, recognizing cultural organizational change, and viewing migration as an ongoing journey.

  9. 9
    Article
    Avatar of bytebytegoByteByteGo·12w

    How LinkedIn Built a Next-Gen Service Discovery for 1000s of Services

    LinkedIn replaced its decade-old Zookeeper-based service discovery system with a next-generation architecture using Kafka for writes and gRPC/xDS for reads. The new system handles hundreds of thousands of service instances with 10x better median latency (P50 < 1s vs 10s) and 6x better P99 latency. Key improvements include horizontal scalability through Go-based Observer components, eventual consistency over strong consistency, multi-language support via xDS protocol, and cross-fabric capabilities. The migration used a dual-mode strategy where applications ran both systems simultaneously, with automated dependency analysis to safely transition thousands of services without downtime.

  10. 10
    Article
    Avatar of neo4jneo4j·11w

    I Built a Tiny AI Agent just for fun

    A developer built a minimal AI agent using Neo4j Aura Agents to answer a single question: whether a startup idea is crowded or has unmet opportunities. The graph had just six nodes and three relationship types. Key decisions included skipping embeddings in favor of explicit graph traversal, removing Text2Cypher to prevent hallucination, and using two deterministic Cypher-based tools with strict parameter binding. The result was a fully traceable reasoning system where every output maps directly to graph relationships, demonstrating that for closed domains with fixed schemas, explicit traversal can replace probabilistic reasoning.

  11. 11
    Article
    Avatar of frederickvanbrabantFrederick's delirious rantings·11w

    Systems Thinking in Enterprise Architecture

    Systems thinking applied to enterprise architecture explores how organizations, like complex ecosystems, contain interactions that are impossible to fully map. Using the Rumsfeld Matrix (known knowns, known unknowns, unknown knowns, unknown unknowns), enterprise architects can categorize their knowledge gaps — from documented systems to shadow IT and emergent behaviors. Causal Loop Diagrams offer a post-mortem tool for understanding reinforcing loops (snowball effects) and balancing loops (resistance to change, often behind failed digital transformations). The key takeaway: a map is not the territory — architects should focus on high-value abstractions rather than exhaustive documentation, while staying humble about the organizational complexity they cannot see.

  12. 12
    Article
    Avatar of ayendeAyende @ Rahien·10w

    The 'Million AI Monkeys' Hypothesis & Real-World Projects

    A critical response to the 'million AI monkeys' hypothesis that AI can rapidly generate production-ready software. Using examples like Cloudflare's vinext (which shipped critical vulnerabilities days after launch), the Claude C Compiler (impressive but architecturally flawed), and the OpenClaw vs NanoClaw comparison, the author argues that generating code quickly is easy but verifying and maintaining it is not. The value of a line of code lies in its battle-tested history, not its speed of generation. Production-grade software still requires the full software lifecycle, and AI-generated code shifts the burden from writing to verification without eliminating it.

  13. 13
    Article
    Avatar of programmingdigestProgramming Digest·13w

    The Phoenix Architecture

    The "deletion test" is a thought experiment: imagine deleting your entire codebase and regenerating it from scratch. If that's terrifying, it reveals that critical knowledge lives only in the code itself, not in specifications, tests, or contracts. As code generation becomes cheaper through AI, the bottleneck shifts from production to validation. Systems should be built around durable oracles (property-based tests, invariants, contracts) that can mechanically verify correctness without referencing old implementations. When you have strong evaluation mechanisms, code becomes disposable and regeneration becomes safe.

  14. 14
    Article
    Avatar of devtoDEV·13w

    Above the API: What Developers Contribute When AI Can Code

    AI coding assistants create a divide between developers who use them for delegation versus judgment. Research shows junior engineers using AI finish faster but score 17% lower on mastery tests. The critical skills that remain valuable are architectural thinking, verification capability, maintenance of existing systems (v2+), simplification discipline, and domain expertise. These "above the API" skills are traditionally learned through friction, mentorship, and public knowledge sharing—transmission mechanisms now at risk. Developers who treat AI as a confident junior requiring review maintain value, while those who blindly accept AI output lose understanding. The piece argues for deliberate verification habits, public knowledge contribution, and explicit mentorship to preserve these judgment skills across generations.

  15. 15
    Article
    Avatar of infoqInfoQ·11w

    Reducing Onboarding From 48 Hours to 4: Inside Amazon Key’s Event-Driven Platform

    Amazon Key's engineering team overhauled its event platform from a tightly coupled monolithic architecture to a centralized event-driven system built on Amazon EventBridge. The redesign uses a single bus, multi-account pattern where a core EventBridge bus routes domain events to isolated subscriber accounts. A centralized schema repository with a custom client library enforces consistent data contracts across producers and consumers. Infrastructure provisioning is automated via reusable AWS CDK constructs. The results: ~2,000 events/second processed at p90 latency of ~80ms, 99.99% success rate, service onboarding reduced from 48 hours to 4, and integration time cut from ~40 hours to ~8.

  16. 16
    Article
    Avatar of bytebytegoByteByteGo·11w

    The First 10-Year Evolution of Stripe’s Payments API

    A detailed look at how Stripe's payments API evolved over its first decade, from the original seven-line card integration using Tokens and Charges, through the Sources API attempt at unification, to the PaymentIntents and PaymentMethods redesign. The piece covers the technical challenges of supporting diverse global payment methods (ACH, Bitcoin, iDEAL, OXXO), the design process behind PaymentIntents including the single predictable state machine, the two-year launch challenge of making the new API accessible without sacrificing simplicity, and key API design lessons: managing product debt, designing from first principles, and the true meaning of simplicity.

  17. 17
    Video
    Avatar of mattpocockMatt Pocock·10w

    Your codebase is NOT ready for AI (here's how to fix it)

    Most codebases are poorly structured for AI coding tools because they consist of many small, shallow, interconnected modules that are hard to navigate without prior context. AI agents lack memory and treat every session as a fresh start, so they struggle with tangled dependency graphs. The solution is to adopt 'deep modules' — large chunks of functionality behind simple, well-documented interfaces — organized clearly in the file system. This approach enables progressive disclosure of complexity, reduces cognitive burnout, and gives AI a clear map to navigate. Tests are critical to lock down module behavior so AI changes can be verified quickly. These are established software engineering principles that matter even more in the AI-assisted development era.

  18. 18
    Video
    Avatar of philipplacknerPhilipp Lackner·11w

    Learning THIS Becomes More Important Than Ever In the Era of AI

    As AI becomes better at writing boilerplate code, solving well-defined problems, and reviewing logic, developers need to shift from a 'bricklayer' mindset to an 'entrepreneurial' one. The skills that matter most going forward are system design and architecture (which require deep organizational context AI can't replicate), deep technical understanding for reviewing AI-generated code, and hands-on experience actually using AI tools and agents in practice. Mobile developers in particular are encouraged to start experimenting with AI in their IDEs, refine their prompting skills, and treat AI as a fast execution layer they supervise rather than a replacement for engineering judgment.

  19. 19
    Article
    Avatar of infoworldInfoWorld·13w

    AI is not coming for your developer job

    Agentic AI excels at deterministic coding tasks like writing, refactoring, and validating code, but lacks the strategic context and human interpretation needed for real engineering work. AI operates within fixed parameters and cannot adapt to shifting business priorities, customer needs, or strategic realignments that arrive through fragmented human communication. The future lies not in replacing developers but in AI handling mechanical tasks while humans focus on interpretation, strategy, and building with intent. For AI to become a true collaborator, it must understand evolving context—not just what code does, but whether it still matters given current priorities.

  20. 20
    Article
    Avatar of apacheThe Apache Software Foundation Blog·12w

    The Apache Software Foundation Announces New Top-Level Project

    Apache HugeGraph has graduated from the Apache Incubator to become a Top-Level Project. HugeGraph is a full-stack graph platform combining database, computing, and AI capabilities, designed to handle hundreds of billions of graph elements with millisecond-level latency. It integrates with Apache ecosystem tools like Flink, Spark, and SeaTunnel, and focuses on bridging graph data with LLMs for intelligent applications. The project is backed by a vendor-neutral community of enterprises and academia.

  21. 21
    Article
    Avatar of itrevolutionIT Revolution·14w

    “No Vibe Coding While I’m On Call”: What Happens When AI Writes Your Production Code

    AI code generation without proper guardrails leads to production incidents. Through a fictional narrative of a company experiencing repeated outages from AI-generated code, the article illustrates four critical failure patterns: AI optimizing code without understanding system context, generating tests that pass but don't validate requirements, documenting features that don't exist, and eroding architectural resilience through incremental changes. The solution involves breaking AI tasks into small verifiable chunks, using AI to critique its own work, verifying documentation against actual code, establishing architectural reviews, and building observability from day one.

  22. 22
    Article
    Avatar of htmxhtmx·10w

    > htmx ~ Yes, and...

    Carson Gross, creator of htmx and CS professor at Montana State University, addresses whether aspiring programmers should still pursue the field given AI advancements. His answer is 'yes, and' — programming remains valuable, but juniors must resist the temptation to let AI generate code for them. Writing code yourself is essential to developing the ability to read, understand, and architect systems. He argues AI-generated code differs fundamentally from high-level languages because LLMs are non-deterministic and often add accidental complexity. AI is best used as a TA to unblock learners, not as a code generator. He also advises on job hunting via personal connections rather than online job boards, and predicts the current bad job market is cyclical and temporary.

  23. 23
    Article
    Avatar of mondaymonday Engineering·13w

    From API Chaos to Collaborative Graph

    Monday.com's engineering team solved API chaos at scale by implementing Federated GraphQL as a centralized API engine. The solution replaces fragmented REST endpoints with a unified supergraph, eliminating boilerplate for versioning, limits, documentation, and authorization. Producers focus only on business logic while consumers get a single endpoint with dynamic field selection, consistent standards, and automatic type generation. The architecture includes CI/CD schema publishing, API wrappers for common functionality, and a central router for observability and rate limiting.

  24. 24
    Article
    Avatar of techleaddigestTech Lead Digest·13w

    AI Fluency Leveling

    A 7-level framework for assessing AI fluency in knowledge workers, from casual consumers to AI pioneers. The levels progress from basic prompt usage through context engineering and RAG implementation to system architecture and platform development. The critical transition occurs at Level 4, where practitioners shift from prompt-based approaches to deterministic code for managing AI's probabilistic nature. Each level includes hiring criteria, required skillsets, and practical guidance for career development and organizational assessment.

  25. 25
    Article
    Avatar of ploehploeh blog·14w

    Code that fits in a context window

    LLMs struggle with large codebases due to context window limitations, similar to how human short-term memory constrains programming. The author suggests that architectural patterns like Fractal Architecture—organizing code into small, nested components at every abstraction level—could help both humans and AI systems manage complexity more effectively. These principles from "Code That Fits in Your Head" may be equally valuable for making code more accessible to LLMs.

See all Architecture archives