# Atomicity The property of being indivisible. An atomic unit does one thing completely or not at all. The concept appears across multiple domains with the same core meaning: irreducible, self-contained, single-purpose. ## In software An atomic operation either fully completes or fully rolls back. Database transactions are the canonical example. Applied to design, atomicity means each unit (function, class, module, service) owns exactly one responsibility. This is the foundation of the Single Responsibility Principle in [[SOLID Principles]]. ## In knowledge management [[Atomic notes]] contain one idea per note. A note about "SOLID Principles" should not also explain dependency injection in detail; that deserves its own note. Atomic notes are easier to link, reuse, and maintain because changing one idea does not risk breaking another. ## In AI skills An atomic AI skill has one purpose and one reason to change. A skill that searches the vault should not also format results for a newsletter. [[AI Skill Composability]] handles combining atomic skills into complex workflows. Atomicity in skills directly enables [[Loose Coupling]], testability, and reuse across agents. ## The pattern across domains | Domain | Atomic unit | What "one thing" means | |--------|------------|----------------------| | Database | Transaction | One logical operation | | Software | Function/class | One responsibility | | Knowledge | Note | One idea | | AI skills | Skill | One purpose | | AI agents | Agent | One role | The underlying principle is the same: keep units small, focused, and self-contained. Composition handles complexity. ## References - ## Related - [[ACID]] - [[Database]] - [[SOLID Principles]] - [[Atomic notes]] - [[Benefits of atomic notes]] - [[Separation of Concerns]] - [[AI Skill Composability]] - [[AI Skill Best Practices]] - [[High Cohesion]]