TL;DR - Vibe-coding with AI feels fast and creates technical debt. I develop with structure - end-state first, decomposed into parts, a concise spec per part, and I let the agent execute against it. The result is production code with no debt hangover.
The problem
AI makes it trivially easy to generate code, which makes it trivially easy to skip the thinking. You prompt, it produces something that looks done, and you move on. Then the technical debt from never actually understanding the feature comes due. I've paid that bill. It's real.
The fix isn't more discipline in the moment. It's a structure you can't skip.
What I did
I apply the same software-engineering principles I'd use on any serious system, just adapted so the AI agent is a first-class participant in the process.
- Define the end-state. What does the whole system look like when it's done?
- Decompose into parts. Split into features/domains, not "build everything at once."
- Spec each part concisely before writing code. The spec is a map, and it's where the understanding lives.
- One part per session. Build domain by domain, so scope stays tight and the agent's task is clear.
- No code before the spec exists. That's the non-negotiable that keeps the whole thing honest.
Everyone participates in that structure, me and the agents. A well-scoped, spec-backed task is one an agent can actually succeed at; a vague one produces garbage.
The result
- Features ship without the debt hangover.
- The build stays diffable and maintainable.
- Because each task is scoped, the agent's success rate goes way up.
- The engineering maturation is literally visible in the commit history.
The lesson
AI made execution nearly free. The remaining constraint is understanding the feature before you build it, and structure + specs are where that understanding happens. A senior's edge isn't typing speed; it's refusing to write code before the spec exists.
Related - the accommodation lifecycle platform case study, where I learned this the hard way.