AI agents that “figure it out as they go” create messes that neither humans nor AI can manage.
You begin a feature with a detailed prompt. The AI makes decisions on the fly. Weeks later, the codebase contains inconsistent patterns, conflicting decisions, and technical debt that compounds daily.
There is a better way.
The core principle
Design everything up front. Develop iteratively. Never let AI make consequential product or architecture decisions on the fly.
This is not about slowing delivery. It is about preventing the exponential slowdown caused by accumulated ambiguity and rework.
The anti-patterns to eliminate
- “Let’s figure it out as we go.” AI makes inconsistent decisions and code drifts from intent.
- “The AI will know what I mean.” Ambiguous specifications produce plausible but incorrect implementations.
- “We’ll add tests later.” Untested code accumulates risk and makes refactoring harder.
- “Let’s build everything at once.” Big-bang releases are difficult to review, test, and debug.
A six-phase design pipeline
Before an AI agent writes code, complete these six phases:
- Features and stories — define what to build, with clear user stories and acceptance criteria.
- UX design — explore how people will use it; mock-ups expose requirements that prose misses.
- Detailed design — establish APIs, data models, integrations, boundaries, and architectural rules.
- Test planning — define seed data, test scenarios, edge cases, and expected outcomes.
- Iteration planning — group work by value, risk, dependencies, and small shippable increments.
- AI agent handoff — give the agent complete, unambiguous context and guardrails.
Development and deployment with guardrails
Once the design is complete, AI agents can move quickly through implementation, automated testing, code review, security checks, deployment, and assisted user acceptance testing. Humans retain responsibility for architecture, critical business logic, risk decisions, and production release.
The loop is deliberate:
AI development → automated testing → automated review → human review → security review → staging → human and AI UAT → production → next designed increment.
What changes
When agents receive a complete and testable design:
- code remains aligned with intent;
- rework falls because ambiguity is resolved earlier;
- multiple agents can work safely on bounded increments;
- tests protect against regressions; and
- changes remain small enough for meaningful human review.
The takeaway
The goal is not rigid waterfall delivery, and it is not the abandonment of Agile. It is a hybrid discipline: design a meaningful body of work thoroughly, prepare the tests and boundaries, then unleash AI coding agents in small iterations.
Design first. Iterate small. Let AI execute—not decide.
The original article on LinkedIn includes the full discussion and tool examples.