Why architecture design still matters — even when AI can generate the code
Navigate with arrow keys or → button
How the system interacts with the outside world — other services, APIs, teams, and users.
HLD answers the "what and where" before any line of code is written.
Most systems have a natural membrane — the boundary between what is internal and what is external. HLD defines that membrane; LLD defines what lives inside it.
How the system works internally — implementation strategy, component architecture, and content decisions.
LLD answers the "how and why" — the decisions that cause scrambling at the last minute when left undefined.
Inter-system integration went smoothly — the external contracts were clear.
But with no LLD, implementation decisions were left undefined. Last-minute scrambling on UI details, content decisions, and cross-team alignment that mocks hadn't covered.
The absence of LLD is invisible until the very end.
No HLD meant the broader system's sources of truth were unclear — ongoing churn on what the correct experience should even be.
No LLD meant every implementation decision was made ad hoc — architecture patterns, shared components, caching strategy, edge cases.
The churn wasn't a people problem — it was a missing design problem.
The fastest way to learn what your HLD should be is to let AI help you build a throwaway POC first.
A vibe-coded spike forces decisions into the open quickly — you discover the natural cell wall, the real external dependencies, and the integration friction you didn't know existed.
That is the beginning of your design — not the end of it.
Vibe code a POC → Eval → extract HLD → write LLD → build with AI ↺
Eval gates what you learned from the POC before committing to a design. In theory, an agent team can run this whole cycle autonomously.
Skipping HLD or LLD doesn't save time — it defers the cost to the worst possible moment: launch week.
Take an existing codebase. Add solid end-to-end tests. Then run an agent loop repeatedly:
Iterate until Eval scores hit a quality threshold. In theory, this is a workflow you can just apply to improve any codebase.
The HLD step is where you steer — you can generate an HLD from the existing code but guide it toward a target architecture. The agent loop does the rest.
Say you want to move a service from one runtime to another — or restructure it entirely. You don't start from scratch.
The tests are the contract. The Eval is the judge. The loop is the engine. The designs are the steering wheel.
For any important app, service, or feature: write an HLD and an LLD before you build for real.
Neither has to be a 20-page doc. A half-page HLD and a one-page LLD are infinitely better than none.
System integration works. Last-mile implementation decisions cause scrambling — often right before launch.
Churn at every level: sources of truth unclear, experience undefined, every decision made twice.
AI can generate code faster than you can review it. Without an HLD and LLD, it will confidently build the wrong thing — coherently and quickly.
The design work is now the bottleneck. Treat it accordingly.
"Hindsight is 20/20 — but one learning is to always do an HLD and an LLD if it's an important app or service."