AI is stealing your time.

Diff the Intent, not the Code

ModelHike is the intent compiler for the AI era. Spec-driven development has the right intent, but the wrong implementation.

$ npx modelhike demo Watch it work

~/booking-service · zsh

$ npx modelhike demo
→ reading booking.modelhike ·  18 lines
→ resolving types ·  Booking, User, Reservation
→ compiling intent ·  blueprint = nestjs
✓ emitted 142 files ·  deterministic hash 7af3·c910·ee01
✓ bootstrapping api on :3000
ready in 0.84s

Rethink the workflow

Stop staring at the source code.

Code is abundant now. Human attention isn't. Shrink the review surface.

Source code is evidence, not the decision

The generated source only proves a decision was made. The decision itself — the intent — is what matters and what should be reviewed.

Clear thinking matters more

Faster agents don't remove the need for thinking — they raise the cost of unclear thinking. Vague intent compounds into broken code at scale.

Move the source of truth up

Declare the why. Let the compiler emit the what. Code stays where it belongs — underneath.

A developer standing above cascading source files, looking at the intent document through a telescope

Human attention is the scarce resource now. Code is downstream now.

How it works

Diff the why. Not the what.

You write twenty lines. ModelHike compiles five hundred files, within a second. You diff why you wrote — not what fell out.

booking.modelhike declaration

Booking
==========
** id      : ID
*  user    : Reference@User
-  status  : String
*  total   : Decimal

~ cancel(id: Int) : String
|> DB Booking WHERE b -> b.id == id
|> IF b.status == "confirmed"
|   UPDATE b.status = "cancelled"
|   return "cancelled"

@ apis:: create, cancel, list

booking-service/ 0.84s

apps/
│ api/
│ │ src/
│ │ │ main.ts
│ │ │ app.module.ts
│ │ │ booking/
│ │ │ │ booking.module.ts+ from intent
│ │ │ │ booking.controller.ts+ from intent
│ │ │ │ booking.service.ts+ from intent
│ │ │ │ booking.repository.ts+ from intent
│ │ │ │ booking.entity.ts+ from intent
│ │ │ │ dto/
│ │ │ │ │ create-booking.dto.ts
│ │ │ │ │ cancel-booking.dto.ts
│ │ │ │ │ list-booking.dto.ts
│ │ │ │ guards/
│ │ │ │ │ owner.guard.ts
│ │ │ │ pipes/
│ │ │ │ │ booking-id.pipe.ts
│ │ │ user/
│ │ │ │ user.module.ts
│ │ │ │ user.entity.ts
libs/
│ database/
│ │ data-source.ts
│ │ migrations/
│ │ │ 1700000000000-init.ts
test/
│ booking.e2e-spec.ts
package.json
tsconfig.json
nest-cli.json
README.md

The why is yours. The what is automatic.

The spec-driven trap

Spec-driven has the right intent and the wrong implementation.

Spec-driven AI coding tools are intent-guessed. Prose in. LLM guess out. Different every time. Three flaws, compounding.

The spec is English. English is ambiguous.

Natural language leaves room for interpretation. If implementation details are still debatable, the foundation is already weak.

The AI is non-deterministic. The output drifts every run.

Same prompt, same spec, same model. Two different code. Two different bugs.

The human is in the loop. The loop is the bottleneck.

Spec-driven puts a human in front of every generated diff. Five hundred files of AI output, reviewed line by line, by an exhausted senior at 4:47pm Friday.

A confused robot standing beside broken generated documents

The Answer

Intent-Native Development

ModelHike fixes all three, by moving up from source code to source intent.
Built for AI Agents: 100% deterministic, zero hallucinations.

A deterministic compiler machine producing structured application outputs

Declaration, not prose

Stop describing your app in English and hoping AI interprets it correctly. Define your system architecture, APIs, and data models precisely in a unified DSL.

Compilation, not generation

Same declaration twice produces the same code. Forever. Auditable. Reproducible. Shippable. No drift, no surprises.

Review at source intent

You diff 20 lines of why, not 500 files of what. The loop tightens to where review is cheap.

AI in the Loop

AI in your editor authors and refines the declaration. The transpiler handles the rest — grounded, repeatable, and reviewable.

ModelHike is Intent-native. Not prompt-guessed.

Intent-native

Prompts guess. Compilers don't.

You write twenty lines of why. It compiles five hundred files of what. Same input, same output. No drift. Forever.

−

Prompt the same AI twice. Get two different codebases. Ship both. Get two different bugs.

Compile the same intent twice. Get the same code. Forever.

That's not a tooling preference. It's the line between hoping and shipping.

ModelHike is Intent-native. Not prompt-guessed.

You stay a developer

Still the developer. Just not the typist.

The craft doesn't go away. The keystrokes do. Here's the shift.

What you keep

You still design.
You still hit flow.
You still ship at 4pm.
You own the source intent, not just the source code.

What you stop

You stop typing what the machine can type.
You stop reviewing generated code line by line.
You stop losing intent into source code.

Source intent is the new source code.

No lock-in

The output is yours. Always.

ModelHike creates a codebase, not a cage. Engineers stay in full control.

Edit the output directly

The output is clean, idiomatic source code — not a generated artifact you're afraid to touch.

Let AI close the loop

Use the ModelHike MCP or Skill in your editor to reverse-engineer changes back into the declaration — so the next transpile reflects your intent.

Evolve the system over time

Declaration, blueprint, and output stay in sync — not by locking you in, but by giving you the tools to keep them aligned.

# 1. Transpile the declaration
modelhike generate --input app.modelhike \
  --blueprint api-nestjs-monorepo \
  --output ./src

# 2. Edit the output directly
code ./src/orders/orders.service.ts

# 3. In your AI editor, prompt:
> "Update the ModelHike declaration and blueprint
   (if needed) to reflect the changes I made in
   orders.service.ts"

Get started

Command to running backend.
Thirty seconds. Fully Local.

GitHub Docs

FAQ

Questions developers ask.

Isn't this just MDA / UML repackaged?

UML and MDA promised something similar — declare a model, generate the code. It failed because humans had to author the model by hand, and that was slower than just writing the code. The overhead killed adoption.

ModelHike flips that: AI authors the declaration for you. The labor problem is gone. What remains is determinism — same input, same output, every time — and that's the part that actually ships.

How is this different from spec-driven dev?

Specs describe. Declarations compile. Same input twice in spec-driven gets you two codebases. Same input twice in ModelHike gets you the same code. Forever.

What about agent frameworks like LangGraph?

Different layer. Agent frameworks help the AI act. ModelHike makes the AI's output deterministic. Use both.

What if I want to edit the generated code?

Edit it. Then tell your AI editor to pull the change back into the declaration through the MCP. The declaration stays the source of truth. The code stays editable. Both stay in sync.

Is the DSL hard to learn?

If you've written a schema or a route definition, you know 80% of it. Most developers are fluent in an afternoon.

What languages and frameworks does it support?

NestJS and Spring Boot monorepos today. More blueprints shipping. The DSL is target-agnostic by design.