Abstract
Artificial intelligence is transforming software engineering, but not in the way many expected. The fundamental shift is not that AI can write code, it is that code is no longer the primary artifact of software development. As implementations become inexpensive to generate and regenerate, the enduring asset becomes the product’s intent: the collection of concepts, constraints, behaviors, and outcomes that define what the software should be.
This article introduces Intent Engineering, a software engineering paradigm in which intent is the primary engineering artifact, executable specifications become the authoritative representation of that intent, AI synthesizes implementations, and adversarial cooperation among specialized agents continuously validates that the resulting system preserves conceptual integrity and fulfills product objectives.
The consequence is a shift from implementation-centric development to intent-centric development, where software is continuously regenerated from validated intent rather than manually evolved through source code.
What is Intent Engineering?
Intent Engineering is the discipline of defining, preserving, synthesizing, and continuously validating product intent throughout the software lifecycle.
Rather than treating source code as the primary artifact, Intent Engineering treats intent as the system of record.
Intent encompasses:
- the product’s purpose
- its domain concepts
- architectural principles
- business constraints
- user expectations
- quality attributes
- behavioral invariants
Everything else, including source code, is a derived artifact.
In this paradigm:
- humans engineer intent;
- executable specifications encode intent;
- AI synthesizes implementations;
- adversarial AI validates correctness;
- continuous regeneration replaces manual maintenance.
This inversion fundamentally changes the economics of software engineering. If implementations can be regenerated on demand, preserving intent becomes far more valuable than preserving code.
Shifting from Implementation to Intent
For decades, software engineering has been centered on source code. Requirements produced designs. Designs produced implementations. Implementations were tested, maintained, and gradually evolved over years.
AI disrupts this model.
Modern language models can already generate production-quality implementations from relatively small descriptions. As synthesis improves, writing code becomes less expensive than understanding whether the generated software actually represents the intended product.
The bottleneck shifts upward. The central engineering challenge is no longer implementation. It is preserving intent. This is the defining insight behind Intent Engineering.
Conceptual Integrity is the Foundation of Intent
Intent is more than a list of requirements.
Fred Brooks described conceptual integrity as the defining quality of successful systems: every component should express a coherent set of ideas.
Intent Engineering extends this principle.
Conceptual integrity becomes an executable engineering constraint rather than an architectural aspiration.
Every generated implementation should preserve:
- shared domain concepts
- consistent abstractions
- architectural boundaries
- naming conventions
- behavioral expectations
- user experience semantics
When AI generates software, maintaining conceptual integrity becomes significantly more important because implementations can diverge much faster than humans can review them.
The question changes from
“Is this code correct?”
to
“Does this implementation preserve the product’s intent?”
Executable Specifications as the Source of Truth
Intent cannot remain trapped inside documents. Natural language is inherently ambiguous.
Executable specifications transform intent into something machines can reason about continuously.
They include:
- acceptance tests
- contracts
- domain invariants
- state machines
- behavioral specifications
- property-based tests
These specifications no longer document software. They define software.
Instead of validating implementations against documents, implementations are synthesized and evaluated directly against executable intent. Source code becomes an implementation detail.
AI Becomes an Implementation Engine
Within Intent Engineering, AI assumes a different role. Its responsibility is not to invent products. Its responsibility is to realize validated intent.
AI translates executable specifications into:
- implementations
- APIs
- tests
- documentation
- deployment artifacts
Because synthesis is inexpensive, implementations become disposable. Whenever intent changes, software can simply be regenerated. The engineering effort moves away from modifying source code toward refining intent itself.
Adversarial Cooperation Enables Continuous Validation
Generating software is only half the problem. The greater challenge is determining whether the generated software actually satisfies product intent. Intent Engineering addresses this through adversarial cooperation. Rather than relying on a single AI assistant, multiple specialized agents collaborate while deliberately challenging one another.
Examples include:
- an Intent Agent that protects product semantics
- an Architecture Agent that preserves conceptual integrity
- an Implementation Agent that synthesizes software
- a Verification Agent that attempts to falsify assumptions
- a Security Agent that searches for vulnerabilities
- a Product Agent that evaluates user value
These agents cooperate through structured disagreement. Each attempts to expose weaknesses that the others may overlook. The objective is not consensus. It is continuously increasing confidence that the implementation faithfully represents the intended product.
Product Validation Becomes Continuous
Traditional software development validates products near the end of development. Intent Engineering validates products continuously.
Every iteration follows the same cycle:
- Product intent evolves.
- Executable specifications are updated.
- AI synthesizes new implementations.
- Independent agents critique the result.
- Executable specifications validate behavior.
- Detected inconsistencies refine the intent.
- Software is regenerated.
Rather than maintaining software, teams continuously maintain intent. The implementation is always temporary. The intent is permanent.
Why This Matters
Software engineering has experienced several paradigm shifts. Assembly language gave way to high-level languages Procedural programming gave way to object orientation. Monoliths evolved into distributed systems. Cloud computing separated infrastructure from applications. Artificial intelligence introduces another transition, from engineering implementations to engineering intent. The primary artifact of software development is no longer source code, it’s the executable representation of product intent.
Conclusion: Engineering Intent, Not Code
Intent Engineering proposes a simple but profound inversion. Software is no longer the artifact we preserve. Intent is. Everything else can be regenerated.
Executable specifications become the living expression of that intent. AI becomes the implementation engine. Adversarial cooperation becomes the validation mechanism. Conceptual integrity becomes the optimization objective that ensures every generated artifact remains faithful to the product’s original vision.
As AI continues to reduce the cost of implementation toward zero, the value of engineering shifts toward defining, protecting, and continuously validating intent. Teams that master this discipline will spend less time writing code and more time refining the models, constraints, and behaviors that make their products unique.
Intent Engineering is therefore not simply a collection of AI techniques. It is a new software engineering paradigm in which intent replaces source code as the primary artifact, software is synthesized from executable specifications, validated through adversarial cooperation, and continuously regenerated as intent evolves.
Resources
https://wiki.c2.com/?ConceptualIntegrity
https://www.infoq.com/presentations/Executable-Specifications
