How it is built

The language

One language for the logic of every tier

Write the logic once, inside the Intended Design, in a typed language any C# developer can read. It is checked against every entity, screen and service it touches.

function Domain.InteractionDTO CreateInteraction(
    Domain.InteractionDTO data) {
    var owner = Domain.PMOUser.GetAll()
        .First(o => o.Roles.Any(
            r => r.Name == Application.Roles.SalesMan));

    int accountId;
    if data.AccountId > 0
    {
        accountId = data.AccountId;
    }
    else
    {
        accountId = data.Account.CreateAccount().Id;
    }

    var lead = Domain.Lead.Init(
        data.FlowId, accountId, data.Title, owner);
    data.UpdateLead(lead);
    lead.Save();
    return Domain.InteractionDTO.Fill(lead);
}

Produced, not copied

The engine turns the language into the language of the chosen stack: C# for .NET today. Because the logic is not written in that language, other targets can be added.

function Domain.InteractionDTO CreateInteraction(
    Domain.InteractionDTO data) {
    var owner = Domain.PMOUser.GetAll()
        .First(o => o.Roles.Any(
            r => r.Name == Application.Roles.SalesMan));

    int accountId;
    if data.AccountId > 0
    {
        accountId = data.AccountId;
    }
    else
    {
        accountId = data.Account.CreateAccount().Id;
    }

    var lead = Domain.Lead.Init(
        data.FlowId, accountId, data.Title, owner);
    data.UpdateLead(lead);
    lead.Save();
    return Domain.InteractionDTO.Fill(lead);
}

public MyApp.BO.InteractionDTO CreateInteractionImplementation(
    MyApp.BO.InteractionDTO data) {
    MyApp.BO.PMOUser owner = new MyApp.DAL.Repository()
        .GetAsQueryable<MyApp.BO.PMOUser>()
        ?.FirstOrDefault((o) => o.Roles.Any(
            (r) => r.Name == "SalesMan"));
    int? accountId = new int?();
    if ((data?.AccountId ?? 0) > 0) {
        accountId = (data?.AccountId ?? 0);
    }
    else {
        accountId = (data?.Account?.CreateAccount()?.Id ?? 0);
    }
    MyApp.BO.Lead lead = MyApp.BO.LeadExtensions.Init(
        (data?.FlowId ?? 0), accountId, (data?.Title ?? ""), owner);
    data?.UpdateLead(lead);
    new MyApp.DAL.Repository().Save<MyApp.BO.Lead>(lead);
    return MyApp.BO.InteractionDTOExtensions.Fill(lead);
}

Illustrative example in the style of a real operation. Logic that calls .NET libraries stays tied to .NET. The documentation has the full reference.

Batteries included, and extensible

The language ships with sixteen libraries. When you need more, you extend it, without leaving the Intended Design. AI agents can look up the language and its libraries through the MCP server, so they write against the real definitions.

Descriptions are summaries of each library’s contents. The documentation has the full reference.

When the editors run out

The escape hatch is back into the Intended Design. Generated files are overwritten on every build, so you never patch the output. You extend the Intended Design instead, in three ways.

Customising the platform was the subject of a public workshop at the MDENet Annual Symposium in 2022: watch the recording.

The engine

How the engine works

What the engine encodes

Engineering judgement about your target stack, captured once and applied to every file of every application. It is not advice to be interpreted. It runs as part of the build.

for each element in the model
  choose the right pattern
  apply the security rules
  use the proven libraries
  emit consistent code

Knowledge in a program, not in a document

Most engineering knowledge lives in wikis, guidelines and people’s heads. It has to be read, understood and applied by each person, every time. The engine applies it for you.

Expertise, written once. AI helps write it and your experts review it. Then it runs on every application.

Every page, the same structure

One screen in the Intended Design, and the files produced for it.

517 of 517 pages in one real business application have the same nine client files, and each has its own controller and view model. Counted from the generated solution, build 801.

Targets

One Intended Design, more than one target

Each target is produced by an implementation strategy that runs inside the engine.

AI decides what. The target knows how.