Most architectural lessons come from running code, not from documents nobody executes. AI helps when it shortens the path to that run through boilerplate and disposable wiring; it hurts when it replaces judgment about ownership boundaries, failure modes, and public contracts. The win is cheaper experiments that still stress the real system, not shorter typing.
What AI Is Good For Here
Generating folder structure, CRUD stubs, migration drafts, and test scaffolds from an agreed schema or API sketch. Summarizing an existing module to propose refactors you still read before merging. Producing two or three implementations of the same interface so you can compare trade-offs in code review instead of in imagination.
Those uses share a rule: the human keeps the invariants. Authentication flows, authorization checks, and anything that moves money or PII stay review-first. AI output is input to judgment, not a merge-by-default artifact.
What Stays Manual
Naming ownership boundaries between domains. Choosing consistency versus flexibility in your module graph. Deciding what is allowed to fail open versus closed. Picking observability hooks that will matter when the prototype is gone and the incident is real. Those decisions do not get cheaper because the surrounding lines were generated faster.
If you skip them, you get a fast pile of code that still fails the same integration tests, just with more files to delete.
Guardrails That Actually Matter
Keep prototypes on branches or environments that cannot leak credentials. Require tests or typechecks on the parts that encode invariants, even when the rest is disposable. Prefer thin generated layers over deep inheritance trees that become archaeology in week three. When something feels “production-ready” because AI wrote a lot of it, that is exactly when to slow down and map failure paths.
The Loop You Still Need
Cheap scaffolding should buy more runs through the same validation loop: run, measure, adjust constraints, repeat. If generation replaces that loop with vibe checks, you only move faster toward the wrong abstraction.
Use AI to pay down repetition, not to outsource architecture. The win is more attempts at the same honest question (what breaks first when this meets reality), not more lines per hour.