BESSER Skills: Bringing Software modeling to AI Coding Agents

Agent Skills are a new, lightweight way to make an AI coding agent good at a specific tool or task. A Skill is just a folder of instructions and reference material that gives the agent an expert’s judgment about how to use a tool, instead of leaving it to improvise from whatever it picked up in training. Load a Skill and the agent stops guessing at your platform’s API and conventions, and starts using them the way someone who already knows the tool would.

Now that agents are massively used for software development, helping agents become experts in software analysis and design would be a great way to ground their generation process and make it more reliable. But, so far, agents are not good at these tasks and lack the right tools to do so. This is why we have just released BESSER skills, enabling agents to create and use software models as part of their development. BESSER is a free and open source low-code, model-driven engineering (MDE) platform built on a single principle: you describe your system as one or more validated B-UML models, and those models become the source of truth for everything downstream.

What the BESSER Skills actually encode

They follow the open Agent Skills standard, so any compatible agent can pick them up. Their purpose is to give an agent BESSER’s metamodel, generators, and workflows on demand, without loading the whole codebase into context. Our main skills are the following:

• besser-user: the modeling guide. How to build every kind of B-UML model, generate code from them, and draw UML that lives in your docs as a real, runnable model.
• besser-generators: per-generator operations for all 19 generators, plus how to safely customize output and override templates.
• besser-troubleshooting: a diagnosis guide for install, import, runtime, and deployment issues.
• besser-dev: the contributor guide, covering adding a new generator or metamodel, writing tests, building the docs, and following BESSER’s PR and release workflow.

Model first, then generate the code

The workflow the skill enforces

Ask a plain agent for “a FastAPI backend for a library” and it starts typing class Book(BaseModel): … straight into a file, improvising the code line by line. Our Skills stop that and impose a simple three-step discipline:

1. Model it. Build a B-UML model and call model.validate(), so structural mistakes are caught before a single line of code exists.
2. Generate it. Point a BESSER generator at the validated model and let it emit the code deterministically.
3. Build on top. Add your custom logic in separate files, on top of the generated baseline, so re-running a generator never overwrites your work.

See it in action

One model, many outputs that can’t drift

With the Skills, the B-UML model is the single source of truth, and every file is generated from it. Point different generators at the same validated model and each target comes out consistent with the others by construction:

from besser.generators.sql_alchemy import SQLAlchemyGenerator
from besser.generators.sql import SQLGenerator
from besser.generators.django import DjangoGenerator

# One model, three targets, none of them can drift from the others

SQLAlchemyGenerator(
    model=library_model,
    output_dir="./orm",
).generate(dbms="postgresql")

SQLGenerator(
    model=library_model,
    output_dir="./schema",
    sql_dialect="postgresql",
).generate()

DjangoGenerator(
    model=library_model,
    project_name="library",
    app_name="catalog",
    output_dir="./django",
).generate()

Need to add a field to Book? Change it once in the model and regenerate; the ORM, the raw SQL schema, and the Django app all pick it up in the same pass.

Or just document your code with embedded diagrams

For those that prefer not to follow model-driven engineering principles but still would like to better understand what the agents is creating (e.g. for communication, documentation, maintainability…) we have another skill that focuses just on that.

You can ask the agent for a diagram. Without the skill, if you ask the agent to “explain the architecture” or “add a class diagram to the README” and you usually get one of two bad outcomes: a diagram that looks nice but it’s often incorrect (in terms of notation and semantics), or a block of ASCII or pseudo-syntax trapped in a code fence that no viewer ever turns into an image.

Our skill uml-drawing.fixes this by instructing the user to create and render models thanks to the BESSER services.

Try it

Installing the skills is one line each:

npx skills add BESSER-PEARL/BESSER-Skills --all
npx skills add BESSER-PEARL/uml-drawing --all

Skills: github.com/BESSER-PEARL/BESSER-Skills
uml-drawing skill: github.com/BESSER-PEARL/uml-drawing-skill
BESSER: github.com/BESSER-PEARL/BESSER

This matters beyond BESSER. As coding agents get better, the bottleneck shifts from writing code to writing the right code, consistently, at scale. Model-driven engineering has spent two decades on that problem, and Agent Skills are a low-friction way to give an agent those answers.