Intent Before Execution

AI coding agents are remarkably capable. Given a prompt, they generate functional code, handle edge cases, follow conventions, and produce output that looks production-ready. This is precisely the problem.

The speed and fluency of agent output creates an illusion of alignment between what the developer intended and what the agent produced. In practice, the gap is large, consistent, and measurable. Agents do not hallucinate in the conventional sense -- they infer. When instructions are underspecified, they fill gaps with plausible but undeclared assumptions. The result is code that compiles, runs, and embeds decisions nobody reviewed.

This is not a prompt engineering problem. It is a structural one. The developer skips the step of articulating what should be built, under what constraints, with what boundaries. The agent has no mechanism to know intent was never manifested. It executes.

The industry response to unreliable agent output has been to improve the prompt, expand the context, or refactor after the fact. Each of these addresses a symptom.

None of these interventions address the root cause: the absence of a deliberate, structured reasoning step between the developer's request and the agent's execution.

Exogenesis proposes a single structural intervention: insert a reasoning step between request and execution. Before the agent writes code, intent is articulated, reviewed, and approved in the form of an intent artifact.

An intent artifact is a structured document that declares:

The intent artifact serves as a portable contract. It survives session resets, provides the agent with a verifiable reference, and gives the developer a document to review before any code exists.

Documentation describes an implementation after the fact. An intent artifact serves a different role: it exists before or above implementation, shapes implementation rather than merely describing it, and remains meaningful even if the implementation is deleted or replaced.

The right framing is that an intent artifact is an intermediate representation of intent — a durable form between human intention and executable implementation. It can survive multiple implementation passes, be read by both humans and agents, and serve as a source for downstream derivations such as tests, comparisons, and review obligations.

This distinction matters. If intent artifacts are treated as documentation, they will drift into decorative text. If they are treated as intermediate representations, they become the thing implementation should answer to, the thing comparison should reference, and the thing regeneration should preserve.

When intent is made explicit, downstream verification obligations appear naturally. Persistence expectations, reset semantics, rule-to-behavior mappings, checklists, acceptance boundaries — these emerge from the structure of the intent itself.

This matters because without explicit intent, tests may exist but target the wrong concept. Checks may be incomplete. Hidden assumptions remain untested. Review focuses on code structure instead of meaning.

With explicit intent, the system has a better chance of testing the right thing. Review can ask whether the implementation preserved the intended meaning. Missing obligations become visible. Verification does not need to be invented from scratch — it can emerge from what was already declared.

Most software practices assume the implementation is the only serious source of truth. Exogenesis rejects that assumption.

If intent is preserved well enough, then implementation can be rebuilt, migrated, partially regenerated, or re-evaluated across different stacks. Regeneration means re-materializing an implementation from the intent artifact after code loss, deletion, or replacement.

Successful regeneration is evidence that intent survived beyond a single implementation — that the artifact was meaningful enough to guide recovery. Important constraints were carried structurally rather than accidentally.

Verification and regeneration reinforce each other. Verification checks whether the implementation still answers to the intent artifact. Regeneration shows whether the intent artifact still contains enough meaning to produce a coherent implementation again. Together they support a broader principle:

Software meaning should survive beyond one transient code realization.