There's extensive literature on several software architecture patterns and styles whose benefits are well known, but which are often ignored due to the cost of their boilerplatic layers and abstractions.
For example: Domain-Driven Design is cool, but it probably won't be applied to a CRUD-heavy startup backend; Clean Architecture is great, but defining a database schema via some annotations on entity fields is simpler and faster.
It's clear that having a single `FooService` mapped to endpoints and directly hitting the database (as an extreme case) would be much faster to ship than introducing `FooRepository`, `AddFooCommand`, `AddFooCommandHandler`, `FooValidator`, et cetera (including the respective interfaces and plumbing).
At least it was faster.
Nowadays, an LLM can spit out ten times that scaffolding in roughly the same amount of time, so it seems like one of the main costs of "heavy" architectural patterns has become almost irrelevant.
On the other hand, their benefits may have been amplified, as highly structured codebases (especially those that can statically enforce and/or test that structure) could serve as a better leash for code-spitting machines, keeping their autonomous design adventures in check.
So, as my first HN interaction — hello! — I wanted to ask the community for their opinion on this topic: do you think the rise of LLMs will/should make heavy architectural patterns more prevalent, even in scenarios where they would otherwise be discarded?
For example: Domain-Driven Design is cool, but it probably won't be applied to a CRUD-heavy startup backend; Clean Architecture is great, but defining a database schema via some annotations on entity fields is simpler and faster.
It's clear that having a single `FooService` mapped to endpoints and directly hitting the database (as an extreme case) would be much faster to ship than introducing `FooRepository`, `AddFooCommand`, `AddFooCommandHandler`, `FooValidator`, et cetera (including the respective interfaces and plumbing).
At least it was faster.
Nowadays, an LLM can spit out ten times that scaffolding in roughly the same amount of time, so it seems like one of the main costs of "heavy" architectural patterns has become almost irrelevant.
On the other hand, their benefits may have been amplified, as highly structured codebases (especially those that can statically enforce and/or test that structure) could serve as a better leash for code-spitting machines, keeping their autonomous design adventures in check.
So, as my first HN interaction — hello! — I wanted to ask the community for their opinion on this topic: do you think the rise of LLMs will/should make heavy architectural patterns more prevalent, even in scenarios where they would otherwise be discarded?
For greenfield I tend to defer to the llm on structure. I've gone into hundreds of thousands of lines without a structural bottleneck, in my opinion.