SolidOps FR
Burgr

Stop burning tokens. Grill Burgr.

A deterministic, model-driven code generator: a small YAML model and a template set give the same code, on every machine.

Measured with an AI agent: 31 to 47% lower cost to create or evolve a project, a little more on small tasks. How

How it works

1. A small model

Describe the domain in a short YAML file: entities, properties, relations, which endpoints exist.

2. A deterministic generator

Burgr hydrates a template set into C#, TypeScript, SQL or PlantUML. Same model and same templates give the same files, byte for byte.

3. Your code where it matters

Generated files are rewritten at each run, never edited. Hand-written logic goes in the extension points the templates provide.

The structural part of an application (entities, DTOs, persistence, API) is the same shape for every entity, so it is written once, in a template. What varies from one project to the next stays in the model.

For example, these 11 lines:

burgr-model-version: 1.0.0
aggregate_roots:
  book:
    properties:
      title:
        field_size: 200
      copies: int
    api:
      query:
      get:
      add:

give, with the Mini set, 157 lines of C# that build, in four files: the Book entity, its DTOs and their validation, its EF Core configuration, and the GET /books, GET /books/{id} and POST /books endpoints. See the template and the code it produces.

Template sets

Mini (default)

One project: ASP.NET Core Minimal API, DTOs, EF Core, CRUD endpoints. Public packages only.

Onion

Domain, Application, Infrastructure, Api and Tests projects: rights, rules, events, paged queries, a light framework.

Template sets are NuGet packages. Use these, or write your own for your architecture and language: templates are text. More on template sets.

With an AI agent

The AI writes the model, a deterministic generator writes the code, the tests decide.

A YAML model is a small surface an agent writes well. The generated code costs no tokens and needs no review. Each template set ships a harness (AGENTS.md, and a hook that keeps agents out of the generated files) that /harness: installs. It is opt-in: nothing in Burgr needs an AI.

Measured on the same tasks and prompts, with and without Burgr, Claude Sonnet 5.5, 5 runs per case:

TaskCostOutput tokens
Create a simple / a complex project−31% / −37%−51% / −63%
Evolve a complex project−47%−54%
Small fix, question about the code+12% / +18%0% / −9%

Small tasks cost a little more: the harness has an entry cost. Input tokens go up when creating, and the first build of the complex case is never green with Burgr. The share of generable code decides the gain: hand-written business logic costs the same either way. Protocol and caveats.

Try it

With the .NET 10 SDK, install the tool and create the project the code is generated into:

dotnet tool install --global Burgr
dotnet new web -o src/Todo
dotnet add src/Todo package Microsoft.EntityFrameworkCore.Sqlite

Describe the domain in a specs/ folder, next to a burgr.json:

# specs/burgr.json
{ "ProjectName": "Todo", "NamespaceName": "MyApp", "BuildingDirectory": "../src/" }

# specs/aggregate_roots.yaml
burgr-model-version: 1.0.0
aggregate_roots:
  task:
    properties:
      title:
        field_size: 100
      due_date: datetime
    api:
      query:
      get:
      add:

Generate:

dotnet burgr specs/ /harness:.

The default Mini template set generates an ASP.NET Core Minimal API with EF Core, from public packages only. Leave out /harness:. if you do not use an AI agent. The quick start wires the generated code in Program.cs and runs it.