Before the agent runs,
intent must be governed.The discipline that earns the right to be fast.Agents generate code, schemas, and compliance logic faster than governance can catch assumptions. GDD formalizes the constraint set before the machine begins — surfacing what cannot be resolved without human judgment before a single artifact is produced.
Unify what code does with why it does it
Traditional code separates semantic anchoring (WHAT) from intent mapping (WHY). AI-assisted generation amplifies this separation. The Semantic Intent pattern eliminates it — creating atomic contracts protected by immutable governance.
// Technical flags driving business behavior
var isExecutive = analysisDepth === 'quick';
// HTTP method determining document type
async GetQuickReport(id) {
return service.generate(id, {
isExecutive: true // WRONG domain
});
}
// Result: identical 486,337-byte PDFs
// Debug time: 3+ weeks// Document semantics driving behavior
var intent = title.includes('executive');
// Observable properties → behavioral contract
var semantic = deriveFromRequest(request);
var report = service.generate(id,
protectIntent(semantic)
);
// Result: 9 pages vs 16 pages (78%)
// Debug time: one sessionAdd Semantic Intent to your codebase in 30 seconds
Pick your context — standard, debug, business, architecture, feature, or integration. Fill in the fields. Copy the template. Paste it above your function.
Template Generator
Six context-aware template types with adaptive field labels. Generate structured Semantic Intent comment blocks for any development scenario — ready to paste into your codebase.
Any system where AI generates behavior
The pattern applies wherever transformation layers can corrupt the relationship between what code does and why it does it.
Report Generation
Executive briefs vs. full reports. The original case study — where technical flags silently overrode document semantics and produced identical output for different intents.
API Contract Preservation
Endpoint behavior that drifts from its specification. MVC controllers where HTTP methods drive business logic instead of semantic intent.
Configuration Management
Settings that work in isolation but violate semantic contracts when composed. Immutable governance prevents cross-domain configuration violations.
AI-Assisted Codebases
The broadest application. Any codebase where AI generates or refactors code risks semantic drift — the pattern provides a structural defense.
A discipline for every layer
The Semantic Intent ecosystem covers the full AI-first delivery lifecycle — from formalizing intent before the machine runs to the architectural moment human judgment is required at execution.
Governance-Driven Design
Formalize the assumption set. Run the ICR cycle. Surface what cannot be resolved without human judgment before a single artifact is produced.
Semantic Intent — SSOT
Make intent the immutable source of truth at implementation. Code that carries its own meaning — auditable, AI-readable, drift-proof.
Intent-as-Infrastructure
Bounded vocabulary declares what to reach. AI compiles how. Human judgment is the designed-in architectural endpoint — not a safety valve, not a fallback.
The Synthesis Gate
The architectural node where ambiguity enters and interpreted meaning comes out. One synthesis node is enough to make an entire chain agentic.
Published, production-validated, open
A growing series of formally documented methodologies — each published under CC BY 4.0, DOI-minted, and backed by open-source implementation.
Paper Series
Semantic Intent as SSOT
10.5281/zenodo.17114972Governance-Driven Design (GDD)
10.5281/zenodo.20938778The Synthesis Gate
10.5281/zenodo.20684283Intent-as-Infrastructure
10.5281/zenodo.20681523Implementation
Complete source code with breakthrough commit (7de571c), production validation tracking IDs, and governance enforcement.
Author: Michael Shatny · ORCID: 0009-0006-2011-3258 · Founding contributor to .netTiers (2005–2010), one of the earliest schema-driven code generation frameworks for .NET. The pattern — structured input, generated output, auditable artifacts — spans 28 years of the same architectural instinct applied across domains.
Need this applied at scale?
GDD governs the intent. Phoenix extracts it from what already exists — rebuilding legacy systems in modern architecture without losing what they've learned.