Aaron Murray | @funkytek | July 2026
In 2017, a paper taught machines attention. Attention taught them to code. By 2024, the world was Vibe Coding (even before Karpathy coined the term), and researchers from Cambridge and Microsoft named the destination for development: Requirements Are All You Need — end users owning the software lifecycle from conception to deployment, armed with nothing but requirements, by 2030. The problem is requirements are the hard part.
<aside> 💡
Humans are generally bad at writing specifications, but we’re great at storytelling —in fact, we're wired for it. Or see: Darmok and Jalad at Tanagra
</aside>
I've run modeling workshops for decades, mostly inspired by Domain-Driven Design-adjacent tools. They work. Domain experts love them, but the output quickly becomes outdated in a tool like Miro or a text document. Every method ends in a handoff to developers, and the handoff is where the important meaning dies.
Vibe coding industrialized the problem. Security breach postmortems are getting the spotlight, but the quiet failures are much worse. A good prompt is a domain model, then it's discarded with the chat log. Validation lands on the wrong party: domain experts can't validate code, developers can't validate domains, and LLMs can't reliably do either. A survey of 1,000+ papers on AI-assisted development found five development models emerging from Vibe Coding. None of them included domain modeling.
Earlier this year, I gave a talk at HalfStack Conf titled "From Vibe Coding to Vibe Modeling: Domains, DSLs, Determinism and You," where I presented a naive DSL: a Domain Storytelling-inspired grammar that imposes structure around writing specs. It looked like this:
Customer submits Order to System
System validates Order against Inventory
System confirms Order to Customer
The grammar fit on one slide: capitalization marks the nouns, position assigns the roles, the first noun is always the Actor, plus a few more rules for properties, compounds, and annotations. The results were not terrible. With this simple DSL, we could deterministically extract Actors, Work Objects, and actions — no LLM in the parse loop. Eight lines of story produced an entity list, a relationship graph, and an inferred state machine with the open promise of verifiability: Order → Submitted → Validated → Charged → Confirmed → Shipped.
The grammar fit on one slide: capitalization marks the nouns, position assigns the roles, the first noun is always the Actor, plus a few more rules for properties, compounds, and annotations. The results were not terrible. With this simple DSL, we could deterministically extract Actors, Work Objects, and actions — no LLM in the parse loop. Eight lines of story produced an entity list, a relationship graph, and an inferred state machine with the open promise of verifiability: Order → Submitted → Validated → Charged → Confirmed → Shipped.
The talk's last open question was meant as a provocation: are we building a DSL or an ontology language?
"Customer submits Order to System" parses identically whether Customer is a person, a company, or a database table. The parse gives structure, not meaning. Is Order a commitment that must eventually be balanced in an economic transaction? Can a Seat be sold twice? The grammar has no opinion. A grammar catches what's malformed. It can never catch what's missing from the human’s intent.
A DSL like this without an ontology is a parser without semantics. The answer to my own question was yes — both.
But we kept generating. We can’t stop.
By 2026 the premise was widespread. Kiro, spec-kit, Tessl, the spec-driven CLI tool wave, Sean Grove’s "The New Code", all treat captured intent as the source of truth and code as “the last mile”.
The issue is that as soon as we hand off the spec to a generation step, the system has already drifted. Böckeler's taxonomy (spec-first, spec-anchored, spec-as-source) found that in practice a spec drives one task, then becomes stale. The one tool aspiring to spec-as-source (Tessl) regenerated different code from the same spec, and by January had pivoted to agent governance.