🧩 What is Composition?
Composition is a design principle in software engineering. You build a complex system from smaller, reusable parts. Those parts are objects, functions, and components. Inheritance builds a hierarchy instead. Composition favors aggregation, so you assemble the parts and you leave the base class alone.
"Favor composition over inheritance" is a key tenet of modern software design.
🔧 What is Composable?
A composable system is one where the individual components are:
✅ Self-contained
🔁 Reusably designed
🔗 Interoperable (combine easily with others)
These components let you build a flexible, scalable, and testable application.
📚 Real-World Examples
1. React Components (Frontend Development)
React uses a component-based architecture. Each UI element stays self-contained, and that covers a button, a navbar, and a modal. You reuse one element on its own, or you compose it into a larger structure.
const Page = () => (
<Layout>
<Header />
<Content />
<Footer />
</Layout>
);
2. UNIX/Linux Command Line
Each tool does one job well. Compose the tools into a workflow with pipes.
cat file.txt | grep "error" | sort | uniq
3. Microservices Architecture
Each microservice handles one distinct concern, such as Auth, Billing, or Notifications. APIs let you compose those services into a larger application.
📈 Benefits
🚀 Rapid development through reuse
🔄 Easier testing and debugging
🔧 Better maintainability and scaling
📦 Encourages modular thinking
📉 Drawbacks
🧩 Can get complex with deep compositions
📡 Coordination between components needed (e.g., contracts, APIs)
🛠 Needs good tooling and design discipline
📦 PocketFlow, Real-World Example of Composition
Over the weekend, I explored PocketFlow, a 100-line minimalist LLM framework. It shows composition and composability better than anything else I read this year.
🌟 What Makes PocketFlow Special?
⚙️ Minimal & Vendor-Free: The framework carries no dependencies and creates no vendor lock-in.
🧠 Agentic-Coding Friendly: An LLM agent can read it and automate a workflow with it.
🧩 Highly Composable: The framework models an LLM application as a flow. A flow holds nodes, and actions connect the nodes.
🔄 Graph-Based Design: Each node performs one task. The output of that node selects the next node, the same way a directed graph works.
💡 Example: Expense Review Flow
review - "approved" >> payment
review - "needs_revision" >> revise
review - "rejected" >> finish
revise >> review
payment >> finish
flow = Flow(start=review)
Each node represents a task. Actions define the path forward, the same way a state machine or a decision graph does. You can also nest a flow inside another flow. Nested flows give you modular, reusable, and complex LLM applications.
📦 Composable Order Pipeline (Nested Flows)
PocketFlow is a fantastic, real-world example of clean, elegant, and composable design applied to LLM workflows.
📘 Summary
Composition means you construct software by merging smaller components. Composable describes a component that combines with other components easily.
A composable system works like Lego. Each brick is useful alone, and the set of bricks is powerful together.
Related reading: Replace a Quote Spreadsheet With a Pricing Engine and Shift Left Testing: Why Late Bugs Cost 100x.
The UNIX and React examples make this tangible. This should be mandatory post-tutorial reading.
Here's the TL;DR version of this:
• Inheritance creates rigid coupling over time.
• Composition enables flexible system design.
• Reusable units reduce architectural fear.
• Modern systems favor assembly over hierarchy.
• This principle applies to LLM frameworks directly.