The Constraint That Clarifies
Ask an AI to help you plan a feature. It gives you file paths, schemas, code snippets. You paste it into your coding agent. Half of it conflicts with what actually exists. The planning agent was guessing. Every specific it provided was fiction dressed as fact.
This isn't a bug. It's a category error.
The planning agent doesn't have access to your filesystem. It can't see your directory structure, can't read your existing code, can't know what patterns you've already established. Yet we ask it to specify paths and schemas as if it could. We treat its outputs as instructions rather than intent.
The fix is counterintuitive: constrain the planning agent to what it actually knows.
The Architect Pattern
Tell the planning agent it's an architect, not a contractor. An architect designs the building—what it should do, why it matters, how the pieces relate. A contractor builds it—navigating terrain, working with materials, solving problems the blueprints couldn't anticipate.
The architect doesn't need to see the terrain. The contractor does.
When you constrain the planning agent to strategic thinking—what and why, never how—something shifts. It stops guessing file paths. It starts describing intent. It stops inventing schemas. It starts explaining relationships. The limitation becomes a feature.
The Handoff
The pattern creates a natural separation. The strategic agent produces a directive—intent, architecture, success criteria. The tactical agent receives it, audits reality, and implements with ground truth.
The directive says what. The local agent determines how.
This isn't just workflow optimization. It's epistemic honesty. The planning agent doesn't know your filesystem—so we stop pretending it does. The executing agent doesn't know the full vision—so we give it context, not just orders. Each agent operates at its actual capability level.
Constraints as Liberation
The counterintuitive truth: constraints don't limit capability. They clarify it.
When the planning agent knows it can't specify paths, it focuses on what paths should accomplish. When it can't invent schemas, it describes what data relationships matter. The constraint forces precision at the right level of abstraction.
Without constraint, the agent fills silence with speculation. With constraint, it fills silence with intent.
The gap between blueprint and ground isn't a problem to solve. It's a boundary to respect. Strategic thinking on one side. Tactical execution on the other. The constraint that separates them is what makes each side useful.