BestHub
Sign in
Tagged articles

Design Patterns

943 articles · Page 1 of 10
DataFunTalk
DataFunTalk
Aug 18, 2026 · Artificial Intelligence

Why DeepSeek Harness Is Shaping the Next Agent Battlefield: From Model‑Centric to System‑Centric Design

The article breaks down five concrete design patterns in DeepSeek Harness—session logs as truth, repeat‑tool reminders, output retention, Code Mode governance, and Workspace for long‑term state—showing how the framework shifts agent development from pure model tricks to a full‑featured runtime system.

AI AgentsCode ModeDeepSeek Harness
0 likes · 11 min read
Why DeepSeek Harness Is Shaping the Next Agent Battlefield: From Model‑Centric to System‑Centric Design
Architect's Guide
Architect's Guide
Aug 11, 2026 · Backend Development

Boosting API Extensibility in SpringBoot with the Strategy Pattern

The article demonstrates how to combine SpringBoot with the Strategy pattern and a simple factory to route different business operations—add, subtract, multiply, divide—through a single API, registering strategy beans in a map for easy extension without modifying existing code.

Design PatternsExtensibilityJava
0 likes · 7 min read
Boosting API Extensibility in SpringBoot with the Strategy Pattern
Big Data and Microservices
Big Data and Microservices
Aug 9, 2026 · Artificial Intelligence

Four Core Design Patterns that Power AI Agents

The article explains why simply using a smarter model isn’t enough, showing that applying four fundamental AI‑agent design patterns—Reflection, Tool Use, Planning, and Multi‑Agent Collaboration—can raise GPT‑3.5’s HumanEval success from 48 % to over 95 %, and outlines how each pattern works, their trade‑offs, and practical implementation guidance.

AI AgentDesign PatternsMulti-agent
0 likes · 11 min read
Four Core Design Patterns that Power AI Agents
DeepNoMind
DeepNoMind
Aug 8, 2026 · Fundamentals

Stop Chasing Frameworks: Master These 7 Architecture Patterns First

This article breaks down seven practical software‑architecture patterns—Bounded Context, Sidecar, Publisher‑Subscriber, Application Gateway, Microservices, Micro‑frontends, and CQRS/Event Sourcing—showing how they can be combined in a real e‑commerce system and guiding architects on when each pattern best solves complexity, performance, or team‑collaboration challenges.

CQRSDesign PatternsSoftware Architecture
0 likes · 17 min read
Stop Chasing Frameworks: Master These 7 Architecture Patterns First
21CTO
21CTO
Aug 7, 2026 · Fundamentals

5 Bad C++ Practices: OOP, Design Patterns, and Heap Allocation

The article critiques five common C++ misconceptions—overusing OOP, treating books as a coding substitute, obsessing over advanced language features, indiscriminately applying templates, and needlessly allocating small objects on the heap—using concrete game‑dev examples and detailed reasoning.

C++Design PatternsGame Development
0 likes · 10 min read
5 Bad C++ Practices: OOP, Design Patterns, and Heap Allocation
Golang Shines
Golang Shines
Aug 6, 2026 · Fundamentals

Understanding Go's Zero Values and Default Initialization

The article explains Go's zero‑value concept, why every variable gets a deterministic default, provides a complete table of zero values for basic and composite types, shows how standard library types are "zero‑value useful", demonstrates designing your own zero‑value-friendly types, and discusses nil semantics, new vs make, and common pitfalls with practical code examples.

Design PatternsGodefault initialization
0 likes · 21 min read
Understanding Go's Zero Values and Default Initialization
Mike Chen Rui
Mike Chen Rui
Jul 30, 2026 · Backend Development

Four Microservice Architecture Design Patterns Explained

The article examines four microservice architecture designs—shared‑database, aggregation, proxy (gateway/BFF), and asynchronous messaging—detailing their structures, advantages, drawbacks, and ideal use cases such as e‑commerce order processing, high‑concurrency systems, and gradual migration scenarios.

AggregationDesign Patternsarchitecture
0 likes · 4 min read
Four Microservice Architecture Design Patterns Explained
IT Learning Made Simple
IT Learning Made Simple
Jul 22, 2026 · Fundamentals

Architect’s Reading List: From Beginner to Master

This article presents a curated reading list for software architects, organized by career stages and covering design patterns, code quality, architecture, distributed systems, cloud‑native topics, along with reading principles, recommendations, and a top‑10 book ranking to guide continuous learning.

Design PatternsSoftware Architecturebook list
0 likes · 10 min read
Architect’s Reading List: From Beginner to Master
samdeepthink
samdeepthink
Jul 20, 2026 · Fundamentals

Implementing the Singleton Pattern in One Line: Scala vs. Java

The article shows that Scala’s built‑in object keyword lets you create a singleton with a single line, contrasts this with Java’s multi‑line implementation, explains why design patterns exist, and discusses when and how to use them responsibly.

Design PatternsJavaObject-Oriented
0 likes · 3 min read
Implementing the Singleton Pattern in One Line: Scala vs. Java
liandk
liandk
Jul 17, 2026 · Fundamentals

Observer Pattern Explained: Code Demo and Real‑World Use Cases

This article introduces the Observer pattern, explains its purpose of decoupling publishers and subscribers, walks through a complete Java implementation with an official‑account subscription example, lists typical business scenarios, compares it with the Mediator pattern, and outlines its advantages and pitfalls.

DecouplingDesign PatternsJava
0 likes · 6 min read
Observer Pattern Explained: Code Demo and Real‑World Use Cases
dbaplus Community
dbaplus Community
Jul 16, 2026 · Artificial Intelligence

Comprehensive Guide to Agent Skills: Standards, Build Process, and Design Patterns

This article provides an in‑depth technical analysis of Agent Skills, detailing the official specification, three‑layer progressive loading mechanism, engineering workflow of Skill‑Creator, naming and description rules, evaluation agents, practical advantages, known limitations, and five reusable design patterns for building robust AI agent capabilities.

AIAgent SkillsDesign Patterns
0 likes · 34 min read
Comprehensive Guide to Agent Skills: Standards, Build Process, and Design Patterns
YiSu Grain
YiSu Grain
Jul 15, 2026 · Fundamentals

Day 21 – Link the Six Core Software‑Engineering Topics Before Advancing

Day 21 ties together six software‑engineering pillars—development models, requirements engineering, UML, design principles & patterns, testing, and CMMI—explains their interrelations, illustrates them with an e‑commerce order‑system case, teaches a memory‑palace recall method, and provides a 20‑question exam with answers.

CMMIDesign PatternsUML
0 likes · 21 min read
Day 21 – Link the Six Core Software‑Engineering Topics Before Advancing
YiSu Grain
YiSu Grain
Jul 13, 2026 · Fundamentals

Design Patterns: Focus on the Problems They Solve, Not Just Their Names

The article explains why memorizing design pattern names is insufficient, introduces core design principles (SRP, OCP, LSP, DIP, ISP, LoD), and walks through seven high‑frequency patterns—Singleton, Factory, Adapter, Decorator, Proxy, Observer, and Strategy—using an evolving order‑processing system to show how each pattern addresses changeability and extensibility.

Design Patternsadapterdecorator
0 likes · 16 min read
Design Patterns: Focus on the Problems They Solve, Not Just Their Names
TonyBai
TonyBai
Jul 9, 2026 · Artificial Intelligence

MCP Server Architecture Patterns: 5 Designs and 4 Anti‑Patterns Uncovered

The article reviews the arXiv paper on MCP Server architecture, presenting five reusable design patterns and four anti‑patterns, explains the research methodology, shares concrete code examples, and quantifies how tool count affects LLM selection accuracy, offering practical guidelines for building robust MCP Servers.

Design PatternsLLMMCP
0 likes · 21 min read
MCP Server Architecture Patterns: 5 Designs and 4 Anti‑Patterns Uncovered
samdeepthink
samdeepthink
Jul 8, 2026 · Industry Insights

When to Build Extensibility Early? Three Scenarios That Justify It

The article argues that early extensibility design should be driven by concrete industry certainty—such as established multi-system integration patterns, clear product roadmaps, or repeated historical changes—rather than speculative future needs, illustrating the approach with chain-store integrations, payment channels, and marketing rules.

Design PatternsExtensibilitySoftware Architecture
0 likes · 8 min read
When to Build Extensibility Early? Three Scenarios That Justify It
samdeepthink
samdeepthink
Jul 6, 2026 · Fundamentals

Why Object‑Oriented Programming Manages Dependencies, Not Objects

The article argues that true object‑oriented design is about controlling software dependencies, tracing its historical roots from Simula to Smalltalk and C++, illustrating how polymorphism, composition, and proper dependency inversion solve real‑world problems while warning against over‑engineered OO patterns.

Dependency ManagementDesign PatternsSoftware Architecture
0 likes · 15 min read
Why Object‑Oriented Programming Manages Dependencies, Not Objects
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jul 5, 2026 · Backend Development

Master 8 Design Patterns in Spring Boot with Real-World Examples

This article walks through eight essential design patterns—Factory Method, Prototype, Adapter, Decorator, Observer, Strategy, Template Method, and Chain of Responsibility—showing concrete Spring Boot 3.5.0 code examples, explaining the problems each pattern solves, and highlighting their practical advantages for clean, extensible backend development.

Chain of ResponsibilityDesign PatternsFactory Method
0 likes · 24 min read
Master 8 Design Patterns in Spring Boot with Real-World Examples
AI Architecture Hub
AI Architecture Hub
Jul 3, 2026 · Artificial Intelligence

20 Loop Design Patterns Every AI Engineer Must Master

This article catalogs twenty high‑frequency loop architectures that transform single‑call AI models into autonomous, self‑optimising agents, explaining each pattern’s purpose, workflow, concrete code example, and typical commercial scenarios such as content creation, compliance review, and strategic decision making.

AI loopsAutonomous AgentsDesign Patterns
0 likes · 21 min read
20 Loop Design Patterns Every AI Engineer Must Master
TonyBai
TonyBai
Jul 3, 2026 · Artificial Intelligence

20 Loop Design Patterns Every AI Engineer Should Know

The article presents twenty essential loop design patterns for industrial AI systems, explains how they differ from single‑call prompts, provides concrete examples, code snippets, and use‑case scenarios, and shows how these loops enable self‑improvement, memory, planning, exploration, and system optimization for AI agents.

AIAgentDesign Patterns
0 likes · 23 min read
20 Loop Design Patterns Every AI Engineer Should Know
liandk
liandk
Jul 2, 2026 · Fundamentals

Iterator Pattern Explained: Real‑World Scenarios and Java Code

This article demystifies the Iterator design pattern by describing its purpose of separating collection storage from traversal, illustrating everyday analogies, presenting a complete Java implementation—including interfaces, concrete aggregate, custom iterator, and test code—and summarizing typical applications, advantages, and drawbacks.

CollectionsDesign PatternsIterator
0 likes · 5 min read
Iterator Pattern Explained: Real‑World Scenarios and Java Code
Code Ape Tech Column
Code Ape Tech Column
Jul 1, 2026 · Backend Development

How Spring Integration Simplifies Inter‑Service Messaging

This article explains Spring Integration’s core concepts—messages, channels, endpoints, adapters, filters, and transformers—shows how to configure them with XML or Java, compares the framework to traditional middleware, and provides a complete e‑commerce order‑processing example with code snippets and interceptor techniques.

Design PatternsInterceptorsJava
0 likes · 20 min read
How Spring Integration Simplifies Inter‑Service Messaging
liandk
liandk
Jul 1, 2026 · Fundamentals

Interpreter Pattern Explained with Java Code and Real-World Scenarios

This article introduces the Interpreter design pattern, explains its core concept of splitting custom syntax into expression objects, showcases practical Java implementations for arithmetic, and outlines typical use cases such as calculators, rule engines, and low‑code platforms while discussing its advantages and drawbacks.

Design PatternsExpression EvaluationInterpreter Pattern
0 likes · 5 min read
Interpreter Pattern Explained with Java Code and Real-World Scenarios
Niu Liu
Niu Liu
Jul 1, 2026 · Backend Development

E‑commerce Pricing Engine Architecture: Promotion Calculation Using Aviator Rule Engine

This article details the design of an e‑commerce pricing engine that processes shopping‑cart items and multiple promotional activities through a three‑stage workflow, copy‑on‑trial execution, configurable Aviator rule chains, and a two‑phase discount sharing algorithm, with code examples and engineering considerations.

AviatorDesign PatternsJava
0 likes · 11 min read
E‑commerce Pricing Engine Architecture: Promotion Calculation Using Aviator Rule Engine
liandk
liandk
Jun 30, 2026 · Fundamentals

Command Pattern Explained: Theory, Java Code, and Real‑World Scenarios

This article introduces the Command pattern, describing how encapsulating each action as a command object decouples callers from executors, and demonstrates its use through real‑world examples like remote controls and editors, followed by a complete Java implementation, common business scenarios, and a brief pros‑cons analysis.

Command PatternDesign PatternsInvoker
0 likes · 5 min read
Command Pattern Explained: Theory, Java Code, and Real‑World Scenarios
Subtle Storm
Subtle Storm
Jun 29, 2026 · Fundamentals

A Complete Guide to 23 Classic Design Patterns

This article systematically explains 23 fundamental design patterns—creational, structural, and behavioral—detailing their intent, typical use cases, and concrete examples such as Singleton for configuration managers, Factory Method for transport logistics, Builder for house construction, and many more, helping readers master pattern selection and application.

BehavioralBuilderCreational
0 likes · 14 min read
A Complete Guide to 23 Classic Design Patterns
liandk
liandk
Jun 25, 2026 · Fundamentals

Proxy Pattern Explained: Code Samples and Real‑World Scenarios

This article introduces the Proxy design pattern, explains its core purpose of controlling access without modifying original classes, illustrates everyday analogies, provides a complete Java static‑proxy implementation with interface, real subject, proxy and test code, and summarizes common use cases and distinctions from decorators.

AOPDesign PatternsDynamic Proxy
0 likes · 5 min read
Proxy Pattern Explained: Code Samples and Real‑World Scenarios
We-Design
We-Design
Jun 25, 2026 · User Experience Design

How to Balance AI Presence Using User Intent

The article examines how to regulate AI's visibility in products by applying a tiered interaction model, defining clear boundaries, and dynamically adjusting response intensity based on user intent and confidence, illustrated with real‑world examples such as Microsoft’s Clippy and data‑dashboard scenarios.

AI interactionDesign PatternsJTBD
0 likes · 8 min read
How to Balance AI Presence Using User Intent
liandk
liandk
Jun 24, 2026 · Fundamentals

Mastering the Facade Pattern: Clear Explanation, Real‑World Scenarios, and Java Code

This article explains the Facade design pattern, illustrates everyday and software scenarios such as hotel front desks and multimedia players, provides a complete Java implementation with subsystem classes, a facade class, and client code, and lists typical business use cases while warning against common misconceptions.

Design PatternsFacade PatternJava
0 likes · 5 min read
Mastering the Facade Pattern: Clear Explanation, Real‑World Scenarios, and Java Code
Tinker Programmer
Tinker Programmer
Jun 24, 2026 · Fundamentals

Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples

This article walks through the three core behavioral design patterns—Strategy, Observer, and Chain of Responsibility—explaining their intent, showing problematic anti‑patterns, providing step‑by‑step Spring and MQ code implementations, mapping them to real‑world frameworks, and offering interview‑style comparison questions to solidify understanding.

Chain of ResponsibilityDesign PatternsJava
0 likes · 19 min read
Master Strategy, Observer, and Chain of Responsibility with Spring & MQ examples
liandk
liandk
Jun 23, 2026 · Fundamentals

Decorator Pattern Explained: Simple Theory, Real‑World Scenarios, and Java Code

The article introduces the Decorator pattern, explains its purpose of dynamically adding functionality without altering existing classes, illustrates the concept with everyday analogies and a complete Java milk‑tea example, and lists typical use cases and common pitfalls.

Code ExampleDecorator PatternDesign Patterns
0 likes · 5 min read
Decorator Pattern Explained: Simple Theory, Real‑World Scenarios, and Java Code
liandk
liandk
Jun 22, 2026 · Fundamentals

Composite Pattern Explained with Code and Real‑World Scenarios

This article introduces the Composite design pattern, explains its purpose of treating leaf and container objects uniformly, shows typical tree‑structured use cases, and provides a complete Java implementation with abstract component, leaf, composite, and a test demo.

Composite PatternDesign PatternsJava
0 likes · 5 min read
Composite Pattern Explained with Code and Real‑World Scenarios
Tinker Programmer
Tinker Programmer
Jun 21, 2026 · Fundamentals

Master Java Builder Pattern and Avoid Lombok @Builder & @SuperBuilder Pitfalls

This article explains why telescoping constructors and JavaBean setters are problematic, demonstrates a hand‑written Builder implementation based on Effective Java, shows how Lombok @Builder simplifies code, and warns about two common Lombok pitfalls—default values and inheritance—while offering practical solutions.

Builder PatternDesign PatternsEffective Java
0 likes · 12 min read
Master Java Builder Pattern and Avoid Lombok @Builder & @SuperBuilder Pitfalls
liandk
liandk
Jun 17, 2026 · Fundamentals

Prototype Pattern Explained with Code and Real‑World Scenarios

This article introduces the Prototype design pattern, explains its purpose of cloning existing objects to avoid costly construction, illustrates practical scenarios such as product templates and game asset generation, provides a complete Java shallow‑copy example, and highlights common pitfalls and differences from the Factory pattern.

CloneableDesign PatternsJava
0 likes · 4 min read
Prototype Pattern Explained with Code and Real‑World Scenarios
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Jun 16, 2026 · Backend Development

Stop Overusing ‘new’: Four Design Patterns That Separate Junior from Senior Developers

The article explains why indiscriminate use of the Java new operator leads to duplicated configuration, hidden complexity, and performance problems, and demonstrates how Factory, Builder, Object‑Pool, and Prototype patterns—illustrated with Spring Boot 3.5.0 code—provide clean, maintainable alternatives that distinguish junior from senior developers.

Builder PatternDesign PatternsFactory Pattern
0 likes · 19 min read
Stop Overusing ‘new’: Four Design Patterns That Separate Junior from Senior Developers
liandk
liandk
Jun 16, 2026 · Fundamentals

Builder Pattern Explained: Simple Theory, Real‑World Scenarios & Java Code

This article introduces the Builder design pattern, illustrates its concept with everyday analogies like milk‑tea making, and provides a complete Java example that assembles a computer through step‑by‑step builders, followed by a summary of typical business use cases and a tip on avoiding confusion with the Factory pattern.

Builder PatternDesign PatternsJava
0 likes · 5 min read
Builder Pattern Explained: Simple Theory, Real‑World Scenarios & Java Code
liandk
liandk
Jun 16, 2026 · Fundamentals

Understanding the Abstract Factory Pattern: Theory, Real‑World Scenarios, and Java Code

The article explains how the Abstract Factory pattern creates whole families of related objects—contrasting it with the Factory Method—illustrates practical scenarios such as phone accessories, UI themes, and payment suites, provides step‑by‑step Java code, lists common use cases, and discusses its limitations.

Abstract FactoryDesign PatternsFactory Method
0 likes · 6 min read
Understanding the Abstract Factory Pattern: Theory, Real‑World Scenarios, and Java Code
liandk
liandk
Jun 13, 2026 · Fundamentals

23 Essential Design Patterns – Complete List with Visuals

This article presents a comprehensive, mobile‑friendly catalog of 23 classic design patterns, organized into Creational, Structural, and Behavioral groups, offering clear names and categories that developers can copy and use as a quick reference for learning and applying design patterns.

BehavioralCreationalDesign Patterns
0 likes · 2 min read
23 Essential Design Patterns – Complete List with Visuals
Frontend AI Walk
Frontend AI Walk
Jun 11, 2026 · Artificial Intelligence

Do AI Skills Have a Methodology? From Scientific Foundations to Design Patterns

The article argues that building AI Agent Skills follows a nascent methodology built on three scientific principles—In‑Context Learning, attention distribution, and bounded rationality—organized into three methodological streams (design‑driven, engineering‑driven, auto‑optimization) and distilled into six reusable design patterns, with a roadmap for future evolution.

AI AgentBounded RationalityDesign Patterns
0 likes · 13 min read
Do AI Skills Have a Methodology? From Scientific Foundations to Design Patterns
Golang Shines
Golang Shines
Jun 9, 2026 · Artificial Intelligence

Essential AI Agent Design Patterns and Frameworks Every Ops Engineer Should Know

The article explains seven AI agent design patterns—workflow, routing, parallel, loop, aggregation, network, and hierarchy—illustrates their use with concrete examples and code, compares agent frameworks such as AutoGPT, Dify, AutoGen, CrewAI and LangGraph, and shows why multi‑agent architectures outperform traditional workflows in complex operational tasks.

AI AgentDesign PatternsFrameworks
0 likes · 12 min read
Essential AI Agent Design Patterns and Frameworks Every Ops Engineer Should Know
Data STUDIO
Data STUDIO
Jun 5, 2026 · Artificial Intelligence

12 Reusable Agentic Harness Patterns: When to Use and Avoid Over‑Design

The article breaks down twelve reusable Agentic Harness design patterns extracted from Claude Code, grouping them into memory, workflow, tool‑permission, and automation categories, explains the architectural pain points each solves, shows when to apply or over‑engineer them, and provides concrete Python implementations.

Agentic HarnessDesign PatternsMemory Management
0 likes · 21 min read
12 Reusable Agentic Harness Patterns: When to Use and Avoid Over‑Design
ZhiKe AI
ZhiKe AI
Jun 1, 2026 · Backend Development

Balancing Software Architecture Choices in Real Projects

The article explains that software architecture is fundamentally about trade‑offs, categorises major architecture families such as DDD, Clean/Hexagonal/Onion, Microservices vs SOA, CQRS/Event Sourcing, MVC, PACELC, BASE, FLP, Repository and 12‑Factor principles, and shows how each addresses specific constraints to help engineers pick the most suitable design for their context.

CAPClean ArchitectureDesign Patterns
0 likes · 12 min read
Balancing Software Architecture Choices in Real Projects
ZhiKe AI
ZhiKe AI
May 31, 2026 · Fundamentals

Do You Really Understand SOLID Design Principles?

This article expands the SOLID principles into a three‑layer framework—class, pattern, and component levels—clarifying common misinterpretations, presenting correct definitions with concrete examples, and showing how GRASP and design patterns operationalize these principles for stable, low‑coupling software.

Design PatternsDesign PrinciplesGRASP
0 likes · 14 min read
Do You Really Understand SOLID Design Principles?
ZhiKe AI
ZhiKe AI
May 28, 2026 · Artificial Intelligence

Why Your LLM Skill Gets Ignored and 5 Proven Design Patterns to Make Agents Work

Even after spending hours crafting a Skill, many LLM agents ignore it, leading to failed automation; this article analyzes why and presents five validated design patterns—linear flow, decision tree with lazy loading, iterative loops, baton passing, and multi‑stage checkpoints—plus concrete examples and a minimal Skill template to ensure reliable, production‑grade agent behavior.

AgentDesign PatternsLLM
0 likes · 12 min read
Why Your LLM Skill Gets Ignored and 5 Proven Design Patterns to Make Agents Work
DeepHub IMBA
DeepHub IMBA
May 26, 2026 · Artificial Intelligence

Agentic AI Design Patterns: Pros, Cons, and Use Cases of Six Architectures

The article breaks down six common agentic AI design patterns—Single Agent, Sequential Agents, Parallel Agents, Loop & Critic, Coordinator & Sub‑agents, and Sub‑Agents as Tools—detailing their implementation structures, strengths, weaknesses, and ideal application scenarios, helping practitioners choose the right architecture for scalable LLM workflows.

AI architectureDesign PatternsLLM orchestration
0 likes · 9 min read
Agentic AI Design Patterns: Pros, Cons, and Use Cases of Six Architectures
Programmer1970
Programmer1970
May 19, 2026 · Interview Experience

What Do Interviewers Really Test When They Ask About Design Patterns?

The article shows that interviewers don’t just want you to list design patterns; they assess your ability to identify real scenarios, solve concrete problems, justify trade‑offs, and discuss implementation details, illustrated with payment and order‑processing examples in Java and Spring.

Chain of ResponsibilityDesign PatternsFactory Pattern
0 likes · 11 min read
What Do Interviewers Really Test When They Ask About Design Patterns?
Linyb Geek Road
Linyb Geek Road
May 19, 2026 · Artificial Intelligence

Five Best Design Patterns for AI Agent Skills

This article explains five practical design patterns—tool wrapper, generator, reviewer, inversion, and pipeline—for structuring AI agent SKILL.md files, showing when to use each, how they work internally, and how they can be combined for robust, maintainable agent behavior.

AI AgentsDesign PatternsLLM
0 likes · 19 min read
Five Best Design Patterns for AI Agent Skills
James' Growth Diary
James' Growth Diary
May 17, 2026 · Backend Development

Why Claude Code’s Tool System Relies on a Generic Triple for Safety and Flexibility

The article dissects Claude Code’s tool architecture, showing how a single generic triple (Input, Output, Progress) defined in src/Tool.ts unifies over 60 runtime tools, enforces type‑safe contracts, streamlines permission checks, progress reporting, and implements a fail‑closed default strategy.

Claude CodeDesign PatternsFail-Closed
0 likes · 20 min read
Why Claude Code’s Tool System Relies on a Generic Triple for Safety and Flexibility
IT Services Circle
IT Services Circle
May 14, 2026 · Fundamentals

Design Patterns: Born in 1994, Died in 2034 – A 40‑Year Saga

The article traces the fictional rise and fall of design patterns from their 1994 debut, through a golden era of OOP and interview hype, to their eclipse by modern language features and AI‑generated code, ending with AI agents unintentionally reinventing the same abstractions.

AI code generationDesign PatternsGang of Four
0 likes · 12 min read
Design Patterns: Born in 1994, Died in 2034 – A 40‑Year Saga
Subtle Storm
Subtle Storm
May 12, 2026 · Backend Development

A Ready‑to‑Use Template for Scoring High on the System Architecture Designer Exam

This article provides a comprehensive, step‑by‑step template for a high‑scoring system architecture design paper, detailing project background, challenges, six‑stage ABSD design, microservice migration with Spring Cloud Alibaba and Kubernetes, performance metrics, high‑availability safeguards, and lessons learned.

Design PatternsKubernetesSystem Architecture
0 likes · 10 min read
A Ready‑to‑Use Template for Scoring High on the System Architecture Designer Exam
Linyb Geek Road
Linyb Geek Road
May 11, 2026 · Artificial Intelligence

14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices

The article distills Anthropic’s official skill‑authoring guide into fourteen reusable design patterns—grouped into discovery, context economy, instruction calibration, workflow control, and executable code—detailing their purpose, concrete examples, applicability, and trade‑offs for building effective Claude Agent Skills.

AI AgentAgent SkillsAnthropic
0 likes · 17 min read
14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices
samdeepthink
samdeepthink
May 9, 2026 · Backend Development

When You Can’t Understand Someone Else’s Code, Is It Their Skill or Yours?

The article explains that difficulty reading code often stems from unfamiliar design patterns and complex construction logic rather than poor code quality, illustrating with factory and strategy patterns in inventory systems, and provides a checklist to distinguish between genuinely bad code and gaps in a developer’s knowledge.

Code OrganizationDesign PatternsFactory Pattern
0 likes · 9 min read
When You Can’t Understand Someone Else’s Code, Is It Their Skill or Yours?
LuTiao Programming
LuTiao Programming
May 8, 2026 · Fundamentals

Why Knowing Hundreds of Design Patterns Still Breaks Your Code—and How an Engineering Decision Method Helps

Many developers learn dozens of design patterns but still end up with fragile, hard‑to‑maintain code; the article explains that the real key is to identify system problems first and apply a disciplined engineering decision method, illustrated with concrete Factory, Builder, Strategy, Template, Decorator, Adapter, Observer and Mediator examples.

Builder PatternDesign PatternsFactory Pattern
0 likes · 16 min read
Why Knowing Hundreds of Design Patterns Still Breaks Your Code—and How an Engineering Decision Method Helps
Tech Minimalism
Tech Minimalism
May 7, 2026 · Artificial Intelligence

12 Reusable MCP Design Patterns for Production‑Grade Anthropic Agents

The article distills Anthropic’s production‑agent guidance into five groups of twelve concrete MCP patterns—covering tool surface design, interaction semantics, authentication, context economy, and packaging—explaining why each pattern matters, its trade‑offs, and how it helps build safe, stable, low‑cost agent integrations.

AIAgent EngineeringAnthropic
0 likes · 22 min read
12 Reusable MCP Design Patterns for Production‑Grade Anthropic Agents
AI Architecture Hub
AI Architecture Hub
May 6, 2026 · Artificial Intelligence

Google’s Five Core Agent Skill Design Patterns: Elevating Agent Skills to a New Design Paradigm

The article explains how, after format standardization removed the bottleneck for enterprise AI agents, the real challenge shifted to internal logic design, and presents five reusable Agent Skill design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—complete with code samples, typical use cases, and best‑practice guidelines for combining and selecting them.

AI AgentsAgent SkillDesign Patterns
0 likes · 18 min read
Google’s Five Core Agent Skill Design Patterns: Elevating Agent Skills to a New Design Paradigm
Architect
Architect
May 5, 2026 · Artificial Intelligence

From Anthropic to Google: Agent Skills Enter the Design‑Pattern Era

Google Cloud Tech’s recent article outlines five Agent Skill design patterns, building on Anthropic’s earlier work that standardized Skill format and loading, and shows how the community is shifting from merely defining Skill syntax to engineering robust, reusable workflow structures for AI agents.

AI engineeringAgent SkillsDesign Patterns
0 likes · 25 min read
From Anthropic to Google: Agent Skills Enter the Design‑Pattern Era
Ubiquitous Tech
Ubiquitous Tech
May 5, 2026 · Artificial Intelligence

12 Reusable Agentic Harness Design Patterns from Claude Code

The article analyzes twelve reusable Agentic Harness design patterns extracted from the Claude Code leak, grouping them into memory & context, workflow & orchestration, tools & permissions, and automation dimensions, and explains each pattern's purpose, scenarios, and trade‑offs.

AI AgentsAgentic HarnessClaude Code
0 likes · 15 min read
12 Reusable Agentic Harness Design Patterns from Claude Code
Linyb Geek Road
Linyb Geek Road
Apr 24, 2026 · Artificial Intelligence

14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices

The article distills Anthropic’s official skill‑authoring guidance into fourteen reusable design patterns—grouped into discovery & selection, context economy, instruction calibration, workflow control, and executable code—explaining their purpose, trade‑offs, and practical examples for building effective Claude Agent Skills.

AI AgentAgent SkillsAnthropic
0 likes · 19 min read
14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices
LuTiao Programming
LuTiao Programming
Apr 22, 2026 · Fundamentals

Stop Memorizing Design Patterns: Modern Strategy Pattern with Java 21+ Sealed Interfaces and Pattern Matching

The article critiques the classic interface‑plus‑N‑implementations Strategy Pattern for causing class explosion, then demonstrates how Java 17’s sealed interfaces and records together with Java 21’s pattern‑matching switch provide a more concise, type‑safe, and maintainable modern implementation.

Design PatternsJavaJava 21
0 likes · 7 min read
Stop Memorizing Design Patterns: Modern Strategy Pattern with Java 21+ Sealed Interfaces and Pattern Matching
Top Architect
Top Architect
Apr 22, 2026 · Backend Development

Unify Multi-Channel Login with Spring Boot Factory & Strategy Patterns

Learn how to replace tangled if‑else login code with a clean, extensible architecture using Spring Boot, combining the Factory pattern to instantiate strategy beans and the Strategy pattern to encapsulate each login method (password, WeChat, SMS, etc.), enabling easy addition of new authentication types.

Design PatternsFactory PatternJava
0 likes · 14 min read
Unify Multi-Channel Login with Spring Boot Factory & Strategy Patterns
Tech Minimalism
Tech Minimalism
Apr 22, 2026 · Artificial Intelligence

14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices

Anthropic’s official skill authoring guide outlines fourteen reusable design patterns for Agent Skills—grouped into discovery & selection, context economy, instruction calibration, workflow control, and executable code—each with concrete examples, trade‑offs, and practical tips to help developers craft effective, token‑efficient Claude extensions.

AIAgent SkillsAnthropic
0 likes · 21 min read
14 Reusable Agent Skill Design Patterns from Anthropic’s Official Best Practices
Tech Freedom Circle
Tech Freedom Circle
Apr 22, 2026 · Artificial Intelligence

Mastering LangChain’s Four Core Design Patterns: A Deep Dive for Architects

This article systematically explains LangChain’s four fundamental design patterns—Command, Chain of Responsibility, Decorator, and Pipeline—showing their definitions, core implementations, and practical code examples to help developers understand and extend the framework.

Chain of ResponsibilityCommandDesign Patterns
0 likes · 34 min read
Mastering LangChain’s Four Core Design Patterns: A Deep Dive for Architects
FunTester
FunTester
Apr 21, 2026 · Fundamentals

What Real-World Code Changes Teach About Low‑Level Design

The author recounts how maintaining and evolving a long‑lived production system exposed hidden costs of poor low‑level design, leading to a shift from pattern‑first thinking to change‑driven analysis, small incremental refactorings, and ultimately a calmer, more maintainable codebase.

Design PatternsRefactoringSoftware Architecture
0 likes · 16 min read
What Real-World Code Changes Teach About Low‑Level Design
DeepHub IMBA
DeepHub IMBA
Apr 21, 2026 · Artificial Intelligence

Designing Persistent Memory for Production AI Agents: A Five‑Stage Pipeline and Four Design Patterns

Production AI agents require persistent memory to maintain continuity, learn from interactions, and recover from failures, but naïvely stuffing full conversation history into the LLM context incurs prohibitive latency and cost; this article outlines four memory types, a five‑stage pipeline, four design patterns, and practical metrics for building efficient, auditable memory systems.

AI AgentsDesign PatternsKnowledge Graph
0 likes · 27 min read
Designing Persistent Memory for Production AI Agents: A Five‑Stage Pipeline and Four Design Patterns
Data STUDIO
Data STUDIO
Apr 21, 2026 · Backend Development

Build Once, Reuse Anywhere: Generic Repository Pattern in Python

The article demonstrates how to eliminate repetitive CRUD code in FastAPI projects by creating a type‑safe, generic repository using Python generics and SQLAlchemy, showing a concrete abstract base class, concrete implementations, custom filters, error handling, and real‑world metrics that cut repository code from hundreds to a few dozen lines.

CRUDDesign PatternsFastAPI
0 likes · 13 min read
Build Once, Reuse Anywhere: Generic Repository Pattern in Python
Machine Learning Algorithms & Natural Language Processing
Machine Learning Algorithms & Natural Language Processing
Apr 14, 2026 · Artificial Intelligence

Why Harness Is the Strategic Asset for AI Agents in 2026

The article analyzes the 2026 turning point where AI model intelligence plateaued and argues that mastering Harness—an infrastructure that wraps models—has become the decisive factor for building controllable, scalable Agent systems, tracing its necessity through three decades of software engineering evolution.

AI AgentsClaude CodeContext Engineering
0 likes · 20 min read
Why Harness Is the Strategic Asset for AI Agents in 2026
Code Ape Tech Column
Code Ape Tech Column
Apr 14, 2026 · Artificial Intelligence

6 Essential AI Agent Design Patterns Every Developer Should Master

This article explores six practical AI Agent design patterns—ReAct, Tool Use, Reflection, Planning, Multi‑Agent, and Human‑in‑the‑Loop—detailing their principles, Java Spring AI implementations, advantages, drawbacks, and suitable scenarios, and provides guidance on selecting and combining them for robust AI applications.

AIAgentDesign Patterns
0 likes · 19 min read
6 Essential AI Agent Design Patterns Every Developer Should Master
Top Architect
Top Architect
Apr 10, 2026 · Backend Development

Essential Microservice Design Patterns Every Architect Should Know

This article provides a comprehensive overview of microservice architecture, outlining its core goals, design principles, and a wide range of decomposition, integration, database, event‑driven, observability, and cross‑cutting concern patterns, complete with practical examples and diagrams.

Design Patternsbackend architecturemicroservices
0 likes · 22 min read
Essential Microservice Design Patterns Every Architect Should Know
Top Architect
Top Architect
Apr 7, 2026 · Backend Development

Why Over‑Design Breaks Your Code and How a Flow Engine Restores Simplicity

The article explains how excessive if‑else branching in backend services leads to fragile code, introduces a workflow engine and plugin extension mechanism to isolate business logic, shows concrete configuration and execution steps using the open‑source MemberClub project, and provides the full Java implementation of the FlowChain executor.

Design PatternsWorkflow Enginebackend development
0 likes · 11 min read
Why Over‑Design Breaks Your Code and How a Flow Engine Restores Simplicity
Top Architect
Top Architect
Apr 5, 2026 · Backend Development

Designing a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL

This article explains the design, principles, components, database schema, configuration, and usage of a generic asynchronous processing SDK that leverages Spring AOP, transactional events, Kafka, and a Vue UI to achieve reliable async execution and eventual consistency in Java backend systems.

AsynchronousDesign PatternsMySQL
0 likes · 11 min read
Designing a Robust Asynchronous Processing SDK with Spring, Kafka and MySQL
Shuge Unlimited
Shuge Unlimited
Mar 31, 2026 · Artificial Intelligence

5 Agent Design Patterns Uncovered in Claude Code Source Leak

The article dissects the accidental public release of Anthropic's Claude Code TypeScript source, revealing five concrete AI agent design patterns—including prompt‑cache segmentation, a coordinator‑fork architecture, a four‑layer permission model, file‑system memory, and on‑demand tool loading—while also detailing the underlying tech stack, source‑map exposure, and quirky easter eggs.

AI AgentClaude CodeCoordinator
0 likes · 17 min read
5 Agent Design Patterns Uncovered in Claude Code Source Leak
Top Architect
Top Architect
Mar 30, 2026 · Databases

How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture

The article analyzes MyBatis’s 20,000‑line source code, showing how it applies more than ten classic design patterns—such as Factory, Singleton, Builder, Adapter, Proxy, Composite, Decorator, Template, Strategy, and Iterator—to decouple complex ORM scenarios, improve extensibility, and illustrate practical implementation details.

Design PatternsJavaMyBatis
0 likes · 12 min read
How MyBatis Uses Over 10 Design Patterns to Simplify ORM Architecture
Java One
Java One
Mar 28, 2026 · Artificial Intelligence

Five Core Design Patterns for Building Robust AI Agents with Google ADK

This guide translates Google Cloud Tech's Agent Skills design patterns, detailing five reusable architecture patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—that help developers create modular, maintainable, and composable AI agents using the Agent Development Kit (ADK).

AI AgentDesign PatternsGoogle ADK
0 likes · 16 min read
Five Core Design Patterns for Building Robust AI Agents with Google ADK
Golang Shines
Golang Shines
Mar 26, 2026 · Artificial Intelligence

Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?

The article explains seven multi‑agent design patterns—workflow, routing, parallel, loop, aggregation, network, and hierarchy—detailing their mechanisms, use‑cases, and trade‑offs, then surveys popular agent frameworks (AutoGPT, Dify, AutoGen, CrewAI, LangGraph) and why they are needed for complex, dynamic decision‑making tasks.

AI AgentDesign PatternsMulti-agent
0 likes · 12 min read
Essential AI Agent Design Patterns and Frameworks for Operations: Do You Know Them?
java1234
java1234
Mar 24, 2026 · Backend Development

Key Design Patterns Used in the Spring Framework

This article explains how Spring employs five core design patterns—Factory, Singleton, Proxy, Observer, and Template Method—detailing their roles, code examples, and how they contribute to Spring's modular, extensible architecture.

Design PatternsFactory PatternSpring
0 likes · 8 min read
Key Design Patterns Used in the Spring Framework
IT Services Circle
IT Services Circle
Mar 22, 2026 · Fundamentals

Bridging Incompatible C++ Logging Interfaces with the Adapter Pattern

This article explains how to use class and object adapters in C++ to reconcile mismatched logging interfaces, allowing seamless integration of third‑party loggers without modifying existing system code, and demonstrates the transition from inheritance‑based adapters to composition‑based adapters for greater flexibility.

C++Class AdapterDesign Patterns
0 likes · 8 min read
Bridging Incompatible C++ Logging Interfaces with the Adapter Pattern
Java Tech Enthusiast
Java Tech Enthusiast
Mar 22, 2026 · Backend Development

How to Bridge Incompatible C++ Logging Interfaces with Adapter Patterns

A C++ developer faces a mismatched logging API between an internal ILogger interface and a third‑party FastLogger library, and the article walks through class‑adapter inheritance, its limitations, and a more flexible object‑adapter composition solution that enables runtime switching across multiple logger implementations.

C++Design PatternsLogging
0 likes · 9 min read
How to Bridge Incompatible C++ Logging Interfaces with Adapter Patterns
ShiZhen AI
ShiZhen AI
Mar 22, 2026 · Artificial Intelligence

5 Google-Defined Agent Skill Design Patterns: From Tool Wrapper to Pipeline

Google's ADK team outlines five recurring Agent Skill design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—each solving a concrete pain point, with advantages, suitable scenarios, and ready‑to‑use YAML prompt examples for building more effective AI agents.

AI AgentAgent SkillDesign Patterns
0 likes · 17 min read
5 Google-Defined Agent Skill Design Patterns: From Tool Wrapper to Pipeline
SuanNi
SuanNi
Mar 19, 2026 · Artificial Intelligence

5 Proven Design Patterns for Building Smarter Google AI Agents

Google's engineers distilled five recurring design patterns for Agent Skills—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—providing concrete guidance, example implementations, and visual decision trees to help developers craft more reliable and context‑aware AI agents.

AI AgentsAgent Development KitDesign Patterns
0 likes · 9 min read
5 Proven Design Patterns for Building Smarter Google AI Agents
Wuming AI
Wuming AI
Mar 18, 2026 · Artificial Intelligence

5 Proven Design Patterns to Supercharge Your AI Agent Skills

This article dissects five practical design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—explaining when each solves a specific problem, showing concrete SKILL.md examples, step‑by‑step instructions, and a GitHub optimizer tool that automatically refines your agent skills.

AI AgentsDesign PatternsPrompt Engineering
0 likes · 13 min read
5 Proven Design Patterns to Supercharge Your AI Agent Skills
AI Engineering
AI Engineering
Mar 18, 2026 · Artificial Intelligence

5 Proven Agent Skill Design Patterns Google Shares After Anthropic

Google Cloud’s new guide outlines five validated Agent Skill design patterns—Tool Wrapper, Generator, Reviewer, Inversion, and Pipeline—explaining their structures, use‑cases, and how combining them can produce reliable, token‑efficient workflows for AI agents.

AIAgent SkillsDesign Patterns
0 likes · 7 min read
5 Proven Agent Skill Design Patterns Google Shares After Anthropic
Cloud Architecture
Cloud Architecture
Mar 18, 2026 · Backend Development

10 Classic Spring Boot Design Patterns to Refactor Your Business Code

This article walks through ten classic design patterns—Factory, Proxy, Template Method, Strategy, Observer, Chain of Responsibility, Singleton, Builder, Adapter, and Decorator—showing how they are realized in Spring Boot 3.x with concrete e‑commerce, payment, and user‑system examples, and explains their benefits, trade‑offs, and best‑practice usage.

BuilderDesign PatternsFactory Pattern
0 likes · 39 min read
10 Classic Spring Boot Design Patterns to Refactor Your Business Code
LuTiao Programming
LuTiao Programming
Mar 13, 2026 · Backend Development

Why Your Spring Boot Code Is Hard to Maintain—and How the Builder Pattern Solves It

The article explains how the Builder pattern in Spring Boot eliminates the telescoping‑constructor and unsafe‑setter problems of complex objects, improves readability, immutability and maintainability, shows hand‑written and Lombok implementations, provides usage examples for DTOs, API responses and queries, and offers best‑practice guidelines.

Builder PatternDesign PatternsImmutable
0 likes · 10 min read
Why Your Spring Boot Code Is Hard to Maintain—and How the Builder Pattern Solves It
Top Architect
Top Architect
Mar 11, 2026 · Backend Development

Why Over‑Engineered Architecture Fails: Real‑World Lessons from a Code Review

A senior architect recounts a code review where a colleague wrapped a simple two‑payment‑method order system in strategy, factory, and abstract‑factory patterns, then explains why such over‑design hurts maintainability, when to apply complex patterns, and practical guidelines for clean backend architecture.

Design PatternsSoftware Architecture
0 likes · 13 min read
Why Over‑Engineered Architecture Fails: Real‑World Lessons from a Code Review
SuanNi
SuanNi
Mar 4, 2026 · Artificial Intelligence

How Skills Empower Autonomous Agents: Architecture, Design Patterns, and Security Risks

The article provides an in‑depth analysis of the Skills mechanism that gives large language model agents reusable procedural memory, detailing its core components, seven design patterns, real‑world security threats, evaluation benchmarks, and the challenges of safely scaling autonomous AI systems.

AI AgentsAutonomous SystemsDesign Patterns
0 likes · 14 min read
How Skills Empower Autonomous Agents: Architecture, Design Patterns, and Security Risks
IT Services Circle
IT Services Circle
Feb 26, 2026 · Interview Experience

Master C++ friend: 5 Levels of Usage Every Interview Candidate Should Know

This article walks through the five practical levels of using C++ friend— from a quick syntax recap to operator overloads, factory functions, iterator access, swap idiom, and the Passkey pattern—explaining when and why each scenario warrants a friend declaration and how it impacts encapsulation and interview performance.

C++Design Patternsaccess control
0 likes · 14 min read
Master C++ friend: 5 Levels of Usage Every Interview Candidate Should Know
Data STUDIO
Data STUDIO
Feb 26, 2026 · Fundamentals

Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner

The article explains why a sprawling utils.py becomes a maintenance nightmare in Python projects, outlines three concrete patterns—module‑level placement, class‑based methods, and small dedicated modules—to restructure code, and provides decision criteria for when a function truly belongs in a utility module.

Code OrganizationDesign PatternsModularization
0 likes · 11 min read
Stop Using a Monolithic utils.py: 3 Design Patterns to Make Your Python Code Cleaner
Architect's Guide
Architect's Guide
Feb 26, 2026 · Backend Development

8 Essential Software Architecture Patterns and When to Use Them

This article explains eight common software architecture patterns—from single‑database apps to microservices, caching, sharding, elastic scaling and multi‑datacenter deployment—detailing their designs, typical use cases, advantages, drawbacks, and practical implementation steps.

Design PatternsElastic ScalingSoftware Architecture
0 likes · 23 min read
8 Essential Software Architecture Patterns and When to Use Them
java1234
java1234
Feb 24, 2026 · Backend Development

Why Most Backend Architecture Patterns Are Over‑Engineered

A code‑review anecdote shows that developers often apply heavyweight patterns like Abstract Factory, Event Sourcing, CQRS, and DDD to simple payment processing, leading to unnecessary complexity; the article explains why this happens, which patterns truly belong in micro‑service backends, and offers practical, lightweight alternatives together with concrete code examples and review guidelines.

Design Patternsarchitecturebackend
0 likes · 13 min read
Why Most Backend Architecture Patterns Are Over‑Engineered
Java Companion
Java Companion
Feb 22, 2026 · Backend Development

Why Most Backend Architecture Patterns Are Over‑engineered

A recent code review reveals a colleague using strategy, factory, and abstract‑factory patterns to build a payment system that only needs two methods, exposing how 90 % of classic backend architecture patterns become unnecessary over‑design in modern microservice and cloud‑native environments, and offering practical guidelines for when such complexity truly adds value.

Design PatternsSpring Bootarchitecture
0 likes · 13 min read
Why Most Backend Architecture Patterns Are Over‑engineered
DeepNoMind
DeepNoMind
Feb 18, 2026 · Artificial Intelligence

Decentralized Blackboard Collaboration: A High‑Reliability Design Pattern for Agentic AI

This article introduces the decentralized blackboard collaboration pattern for building reliable agentic AI systems, explains its shared data space and specialist agents, demonstrates a customer‑support ticket workflow with analyzer, retriever, and draftsman agents, and highlights benefits such as error reduction, deeper specialization, and auditability.

Decentralized BlackboardDesign PatternsLangChain
0 likes · 12 min read
Decentralized Blackboard Collaboration: A High‑Reliability Design Pattern for Agentic AI
LuTiao Programming
LuTiao Programming
Feb 9, 2026 · Backend Development

Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity

The article explains why design patterns often feel useless in Spring Boot projects, introduces a three‑branch decision tree that maps common sources of complexity to suitable patterns, and demonstrates a concrete refactor of an if‑else payment service into a clean, Spring‑managed strategy‑based solution.

Design PatternsSpring BootStrategy Pattern
0 likes · 9 min read
Stop Memorizing Design Patterns—Use This Engineering Decision Tree to Solve Spring Boot Complexity