"Start with a Monolith" Was Good Advice. AI Is Changing That
In a piece circulated through the Hacker News – AI channel, a Medium essay titled "Start with a Monolith" Was Good Advice. AI Is Changing That invites readers to rethink the classic software wisdom that begins with a single, large system. The article, while born on a platform known for rapid technical discourse, centers a timely question: as AI capabilities scale, should teams still chase a giant, all-encompassing solution, or is there value in building toward modularity from the start?
“Start with a Monolith” Was Good Advice. AI Is Changing That.
The argument suggested by the author is not a dismissal of complexity, but a reframing of where and how complexity should reside in AI initiatives. In practical terms, this shift reflects a world where AI systems are increasingly composed of discrete components—models, data pipelines, evaluation frameworks, and governance layers—that work together rather than living inside a single, indivisible codebase. The piece implies that adopting a modular philosophy can improve responsiveness, scalability, and trust when AI systems are deployed across teams and environments.
As AI capabilities multiply—from foundation models to domain-specific adaptations—the cost of monolithic builds tends to rise faster than the value they deliver. The article highlights a core tension: the speed of experimentation versus the stability required in production. A monolith may streamline initial experiments, but once an AI solution grows to touch multiple business domains, the boundaries blur. That is where interoperability and clear ownership become decisive advantages of a modular approach.
From a design perspective, embracing modularity does not imply sacrificing coherence. On the contrary, it invites a disciplined architecture where components can be swapped, updated, or scaled without rewriting the entire system. The essay points to several practical considerations for teams embarking on this path:
- Composable components: Breaking the system into distinct, well-defined services or modules that can be combined in different ways to serve diverse use cases.
- Interface contracts: Explicit data contracts and model interfaces that enable safe interaction between modules and prevent cascading changes.
- Governance and safety: As AI goes modular, governance must follow, ensuring consistent standards for data handling, model evaluation, and compliance across components.
- Observability and testing: End-to-end visibility remains essential; modularity should not come at the cost of blind spots or brittle integrations.
- Tooling alignment: Development and deployment tools that support modular architectures—pipelines, registries, and versioned interfaces—become critical accelerants.
For readers who operate in startups and mature teams alike, the piece offers a helpful reminder: the goal is not to abandon monoliths entirely, but to choose architectural pragmatism. Begin with a focused, testable core and design a pathway to add components as needs evolve. This approach can reduce risk, speed up iteration cycles, and enable teams to adapt to shifting requirements without an unsustainable rebuild.
In sum, the article suggests that AI is changing the calculus of software design. Monolithic beginnings are not inherently wrong, but in a landscape where AI capabilities scale across domains, modularity offers a durable route to resilience, governance, and ongoing innovation. The underlying message is clear: architecture should serve experimentation and deployment alike, not constrain them to a single, oversized entity.