Llm on Janik von Rotz

Confidently Wrong

Thu, 30 Apr 2026 17:35:27 +0200

In two days I had two customers that sent me a zip file containing an Odoo module and asked to install it on their server. This is new and for some reason made me angry.

Developing Odoo modules and maintaining them over many Odoo versions is what I am doing as an Odoo developer for the past six year. My experience and learning from others has been accumulated into many best practices and patterns.

Is this only about pride or much more? Let’s find out.

When I checked the code of the modules sent be these customers, I knew right away that it has been generated by Claude. Compared to what I build, it was utter garbage. And believe me, this is not gate-keeping. The code lacked any good practices and implemented almost any anti-pattern there.

But the request of the customer was clear. And the customer felt very confident that the module will solve his problem. In my opinion he was confidently wrong

Should I just move along and let the code break the entire system and then ask the customer to fix it? This is not a risk I am willing to take. Also I am still responsible for the system. But how to move forward from this kind of situation?

I decided to push back. At least a little and ask some basic questions that were obviously not asked by Claude:

Who is the actual author of the code?
Who is taking responsibility?
Are there any specifications?
What prompts / skills have been used to implement the modules?
How should this code be maintained?
Has the code been tested?
If yes, which Odoo environment has been used to do so?
…

For my company I answered these questions many years ago. In that regards everything feels like a regression. For sure I do not have to explain how frustrating this situation is. Two very different expectations collide.

In order to move onwards I prepared the following texts:

Generating the code is the easy part, we already do that for many years. Even before LLMs and ChatGPT is was possible to generate code from simple instructions.
Instead of sending us the code, we would rather see a specification with your requirements.
In case you want to vibe-code new modules, we ask you to setup our Odoo development environment. It provides all the tools (guidelines, skills) so you can develop your own Odoo modules.

Pick your poison.

Setup opencode with Infomaniak AI Tools

Wed, 01 Apr 2026 16:16:12 +0200

No Aprils fool here. Instead you get the instructions to run opencode with Infomaniak AI Tools.

Setup Infomaniak

If not already done, create an API token here.

Select “ai-tools” for scope. Then open a shell and export the API token:

export API_TOKEN="******"

Now we can get info on the AI service with this curl request:

curl -G \
 -H "Authorization: Bearer $API_TOKEN" \
 -H "Content-Type: application/json" \
'https://api.infomaniak.com/1/ai'

The result will look something like this:

{"result":"success","data":[{"product_name":"Ai-Tools","product_id":103281,"account_name":"Janik von Rotz (Org)","status":"ok"}]}

For the next step you need the product_id. This id is tethered to your account.

export PRODUCT_ID="103281"

Now we can list the LLM models:

curl -G \
 -H "Authorization: Bearer $API_TOKEN" \
 -H "Content-Type: application/json" \
"https://api.infomaniak.com/2/ai/${PRODUCT_ID}/openai/v1/models" | jq

Now we have all the info to connect opencode with the Infomaniak OpenAPI.

Setup opencode

If not already done, install opencode:

pnpm install -g opencode-ai

Then we setup a custom config for opencode:

mkdir ~/.config/opencode
vi ~/.config/opencode/opencode.json

Copy the following config file and replace $PRODUCT_ID and $API_TOKEN with your values:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "infomaniak": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Infomaniak AI",
      "options": {
        "baseURL": "https://api.infomaniak.com/2/ai/${PRODUCT_ID}/openai/v1",
        "apiKey": "$API_TOKEN"
      },
      "models": {
        "llama3": {
          "name": "Llama 3 (Infomaniak)"
        },
        "mistral3": {
          "name": "Mistral 3 (Infomaniak)"
        },
        "qwen3": {
          "name": "Qwen 3 (Infomaniak)"
        },
        "gemma3n": {
          "name": "Gemma 3n (Infomaniak)"
        }
      }
    }
  },
  "model": "infomaniak/qwen3"
}

Make sure the model keys are matching the previous list.

Now start opencode and you should be able to code with Qwen 3 (Infomaniak).

Working with LLM agents

Tue, 17 Feb 2026 16:17:07 +0100

In the last few days I tinkered with Cortecs and OpenCode. It seems LLM agents are here to stay and I need to deal with them. I admit that I am very skeptic of the AI hype. However, I see a lot of benefits when working with LLM agents in a controlled environment.

People have built great tools and practices. There are many providers that host LLMs or route between multiple providers. The ecosystem as matured and this led me to explore more and put in more effort to understand what is going on.

The goal of this exploration was to find a new coding workflow that includes an LLM agent and fits well into my existing workflow.

As the good engineer that I am, I first wrote down some requirements for the workflow.

Requirements

No unnecessary features

The workflow should not encourage me to build more stuff, but to fix issues and improve features.

Code is technical debt and the theory of code is cognitive debt. Building a lot of features and not using them is producing waste and noise.

No digressions

In my experience, if the agent does not satisfy the requirements, you start explaining the issue over and over again. You often end up in argument and LLM always promises to do better.

This kind of arguing and guessing can be a huge waste of time and defeats the very reason for using an agent. Instead of having an ongoing conversation and a bloated context, it is often easier to start over.

And thus the workflow should encourage me to abort and refine my initial prompt.

Spec-driven prompts

Form experience it is worth to write an elaborate prompt. The initial prompt is a specification of of the new feature or bug to resolve.

Before starting an agent session, a well defined prompt must already exist.

Quick boostrap

I have many software projects with a different layout and framework. Before letting an agent go rough in the repo, I want to provide clear guideliens.

The workflow should make it easy to provide the necessary context for very different projects.

Task file integration

This is the most important requirement. I manage all my software projects with taskfile.build. It is a standard for a bash script and also a library for commands. It allows me to manage and bootstrap very different software projects.

Whatever workflow I am going to build, it can be called from a task file.

Workflow

Now let me show you how the coding workflow looks like.

After iterating on many ideas, practices, scripts and commands, I ended up with three step workflow:

Setup: Prepare the project to run an LLM agent
Run: Create and run a prompt
Finish: Summarize and commit the changes

The commands I use in my workflow are imported from https://taskfile.build/library/#llm.

Setup

First, I enter an new or existing project and run the init project command:

task init-project

This command creates several files and folders. The relevant files are:

AGENTS.md: Tempalted guideline for the LLM agent
README.md: Guide for the user and the LLM agent
prompts: Folder that contains spec-driven prompts
task: Templated project-level task file

I update these files according to the context of the project.

Run

I create new prompt file with this command:

task create-prompt "Add prompt commands"

This creates and opens the file prompts/08_add-prompt-commands.md in the default editor. Then I update the task section with the specification.

Here is an example of what the prompt file might look like before being executed:

---
title: Add prompt commands
---

# Run 08

Replace the `==` marked instructions in this file while you work on the task.

## Context

Read the `AGENTS.md` and `README.md` to get understanding of the project.

## Task

Add two new commands `create-prompt` and `list-prompt` to the `bin` folder.

The first command asks for a title. The user is expected to enter something like `Title of the prompt`.
Then the command creates a file `prompts/NN_title-of-the-prompt.md` from a template `prompt.md.template`. It writes the title of the prompt into the frontmatter.
Once the file is created it uses the `$EDITOR` to open the file.
The number sequence starts at 01 and continues upwards.

Similar to `list-dotenv` the `list-prompt` commands lists all prompts. It shows a simple table:

```markdown
| ID  | title               |
| --- | ------------------- |
| 08  | Add prompt commands |
```

The title is retrieved from the frontmatter. The table width should be dynamic.

Add the new commands to the `library.md` in the LLM section. Update the `task.template` with `task update-template`.

## Worklog

==Fill this in as you work on the task==

## Summary

==Fill this once you completed the task==

In order to execute the prompt I launch opencode in the root of the project and simply copy-paste the path to the prompt file. Open Code then starts working on the task.

If it does not get the instructions, I either create a new session or give some manual inputs.

Finish

After a few seconds the task has been completed. The worklog and summary section should completed by the agent.

It is crucial to not blindly trust the completeness of your spec or the output of the LLM. So I check the git diff. If somethings seems off, I either update the prompt or make manual inputs.

If I am happy with the result, the changes are staged gaa and I run task update-changelog-with-llm. This will update the CHANGELOG.md according to the keep a changelog specification.

To commit the changes I use task commit-with-llm. This command generates the commit message from the git diff according to the Conventional Commits specification.

And that’s it!

Afterthoughts

This workflow works well for trivial and well defined tasks. Once you try more complex task and multiple agents, the quality of the project erodes pretty fast.

Some researchers have demonstrated that LLMs can create entire browsers within a week. Browser engines are well specified, but their creation takes a very long time. The result met all requirements, but was very slow and inefficient.

I believe that the AI hype is a challenge for the entire software industry. It’s not just salespeople who are hyping AI, but also engineers who should know better.

Until the bubble pops, I’ll try my best.

AI is not abstraction

Mon, 10 Nov 2025 10:02:32 +0100

The concept of abstraction has been applied to software engineering. But it never made sense. Software is flexible. Software can be changed even after it has been put into production.

Software is flexible 🌊

The layer of abstraction in software is always moving. The definition of software abstraction has nothing in common with the definition of abstraction of engineering a physical product.

Software is fluid, always changing, often hard to reproduce, it is configurable, riddled with bugs and most of all - it has to be made sense of. As the code base changes you always have update your mental model of the how the software works.

We intend to write more code than less. We tend to make software more complex than simple. We add more and more features than deprecating them. Everything is done under the umbrella of increasing productivity.

However, developing software does not have to be more productive - it has to be contained.

The bloat is real 🍔

Once you start engineering software with the help of AI you will experience a productivity gain. Not for the overall production of software, but for solving well defined problems in a well known domain. Problems such as bug fixing, commenting, documenting, boiler-plating and explaining are straightforward tasks for AIs.

As a developer you get hooked on running agents in your code base. Solving multiple problems at once. Trying new strategies like git work trees to run multiple agents at the same time.

The sense of productivity and squishing those bugs overwhelms you. This works until you hit the ceiling. The context window, the amount of token to burn through, the invoice, the dependency juggling, the agent getting lost, these are all hard limits that put a stop to the trip.

But what is really happening here? Lets take a step back and have look. Actually you are not improving the software product, you are bloating the code base! It gets bigger and bigger. There are not limitations for adding new features. The computing resources are limitless. Of course this makes sense, you are not getting paid to write smart code, you are getting paid to produce new features.

So this apparent level of abstraction and productivity gain is in reality just bloat. A waste of resources.

Environmental resources 🏭

Producing software with Big Tech services has now a direct link to environmental damage. It is well documented that their data centers are not sustainable and are not using sustainable energy sources. They have become an environmental hazard.

In regards to the climate crisis you have a moral obligation to not use their data centers.

So what if we treat AI as what it is? An environmental hazard.

Safety procedures ☢️

Read this part if you failed to contain the AI and a agent chain reactions has destroyed your code base.

In case your code is radiating and has been polluted by AI-written code, it is time to run the contamination protocols and safety procedures.

First, isolate the AI-written code. Containerize the application and sandbox the execution environment. Add warnings and comments that can be understood years after. Treat your software the same way as you would treat legacy systems.

Once contained, bury the code in the deepest /dev/null you can find. Never touch it again, but also never forget about it. Future generations of coders might be able to untangle and decompose the mess that has been created.

Work with LLMs on the command line

Mon, 27 Jan 2025 16:28:35 +0100

I used VSCodium and Codeium to develop Python code. VSCode is my editor of choice and Codeium is a well integrated AI-tool that helps writing code. While it solved a lot of problems for me, especially writing boilerplate code, I became more and more frustrated using this setup.

No longer I wanted to understand the actual problem or piece of code, but just to prompt out a solution. Often I was eagerly waiting for the auto-complete feature to fix my code. I copied pieces of code to LLM chats in the browser and then updated the code in the editor. This workflow didn’t feel right. This isn’t coding.

The obvious solution would be to to stop using these AI-tools and write code as I used to. On one side I really would like to do that, but on the other side, I feel pressured to use this technology. I believe in the LLM technology and the promise of more efficient coding. However, I do not like the products and services built around LLMs.

This is also what annoyed me about Codeium. Every prompt is funneled through their service. If they change the terms of agreement the only option is to agree. Coding should not be on a providers agreement. Especially if the terms are to their favor.

Inspiration

So I was looking for different angles on this topic. I was not looking for alternatives. Alternatives often don’t solve the actual problem. While reading Hacker News (HN) I got an inspiration. In comment section of Yek: Serialize your code repo (or part of it) to feed into any LLM I stumbled this:

https://github.com/simonw/files-to-prompt/ seems to work fine especially for Claude as it follows the recommendations and format.

In the HN sphere Simon Willison (guy in the picture) is well-known for his blog and insights. He writes a column on how he uses LLMs to code and most importantly is he the author of the llm command line interface (cli).

The link in the command shows an example on how Simon feeds multiple files into an LLM using his cli. The llm cli allows he to switch between remote models and even use local LLMs! There is a well maintained plugin directory to attach any kind of models.

Files to prompt

So I started to introduce the files-to-prompt solution into my development workflow. My worklow is heavily based on taskfile.build. For every project there is a task script file to run selected commands.

For the Odoo.Build project I added a new command:

printf "| %-${cmd_width}s | %-${opt_width}s | %-${desc_width}s |\n" "update-with-llm" "[path][prompt]" "Update files with LLM prompt."

And here is the function that does the magic:

function update-with-llm() {
    if test -z "$1"; then 
        echo "\$1 is empty."; 
        exit 1; 
    fi

    # Get files from path
    if [ -f "$1" ]; then
        FILES="$1"
    elif [ -d "$1" ]; then
        FILES=$(find "$1" -type f \( -name "*.md" -o -name "*.yml" -o -name "*.yaml" -o -name "*.conf" -o -name "*.nginx" \) \
            | grep -vFf <(git -C "$1" ls-files --ignored --exclude-standard --others))
    else
        echo "$1 is neither a file nor a directory."
        exit 1
    fi
    echo -e "Loaded these files into prompt:\n\n$FILES\n"

    # Prompt task description
    if [ -z "$2" ]; then
        read -p "Enter the task description: " TASK_DESCRIPTION
    else
        TASK_DESCRIPTION="$2"
    fi

    # Prepare the files content for prompt
    FILE_CONTENTS=""
    for FILE in $FILES; do
        FILE_CONTENTS+="<<<$FILE>>>
$(cat "$FILE")

"
    done

    # Define prompt content
    mkdir -p tmp
    PROMPT_FILE="tmp/llm_update"
    echo -e "\nWrite prompt to $PROMPT_FILE."
    cat << EOF > "$PROMPT_FILE"
Look at the code files below and do the following:

$TASK_DESCRIPTION

Output all files that you need to change in full again, including your changes. 
In the same format as I provide the files below. Under no circumstances output any other text, 
no additional infos, no code formatting chars. Only the code in the given format.

Here are the files:

$FILE_CONTENTS
EOF

    # Run the llm command
    echo -e "Send prompt and wait for the response of the $LLM_MODEL LLM."
    RESULT=$(cat "$PROMPT_FILE" | llm -m "$LLM_MODEL")

    # Check if result is empty
    if [ -z "$RESULT" ]; then
        echo "No response from the model. Exiting."
        exit 1
    fi

    # Save the result to a file
    RESULT_FILE="tmp/llm_update_result"
    echo "$RESULT" > "$RESULT_FILE"
    echo -e "Saved response to $RESULT_FILE.\n"

    # Show a preview of result file
    less "$RESULT_FILE"

    # Ask for confirmation before updating files
    read -p "Do you want to apply these updates to the files? (y/n): " CONFIRM
    if [[ ! "$CONFIRM" =~ ^[Yy]$ ]]; then
        exit 0
    fi

    # Parse the response from the file and update the files directly
    echo -e "Parsing the response and updating files...\n"
    CURRENT_FILE=""
    while IFS= read -r LINE; do
        if [[ $LINE =~ ^"<<<"(.*)">>>" ]]; then
            CURRENT_FILE="${BASH_REMATCH[1]}"
            echo "Update file $CURRENT_FILE."
            > "$CURRENT_FILE"
        elif [[ -n $CURRENT_FILE ]]; then
            echo "$LINE" >> "$CURRENT_FILE"
        fi
    done < "$RESULT_FILE"
}

Executing the function does:

Collect all Python and XML files from the provided path.
Ask for task instructions.
Generate a prompt with the instruction and files that asks for a response with file content only.
Pass the prompt to the llm command.
Store the response into a file.
Show a preview of the file with less.
Ask if the changes should be applied.
Apply the changes on confirmation.

In Action

Let me show the function in action. In this scenario I have an Odoo module board_user_acl and would like to rename a definition.

First I run the task file with the update-with-llm command and give the path to the module as parameter:

task update-with-llm addons/server_tools/board_user_acl "Rename restricted to restrict"
Loaded these files into prompt:

addons/server_tools/board_user_acl/__manifest__.py
addons/server_tools/board_user_acl/security/security.xml
addons/server_tools/board_user_acl/views/menu.xml

The function asks for a task description:

Enter the task description: Rename restricted to restrict

And then it waits for the response.

Write prompt to tmp/llm_update.
Send prompt and wait for the response of the gpt-4o LLM.
Saved response to tmp/llm_update_result.

Once its done, a preview of the updated files is shown:

<<<addons/server_tools/board_user_acl/__manifest__.py>>>
{
    "name": "Board User ACL",
    "summary": """
        Restrict access to dashboards app.
    """,
    "author": "Mint System GmbH",
    "website": "https://www.mint-system.ch",
    "category": "Technical",
    "version": "16.0.1.0.0",
    "license": "AGPL-3",
    "depends": ["base_user_acl"],
    "data": ["security/security.xml", "views/menu.xml"],
    "installable": True,
    "application": False,
    "auto_install": False,
    "images": ["images/screen.png"],
}
tmp/llm_update_result (END)

Quit the less preview with q and confirm the change.

Parsing the response and updating files...

Update file addons/server_tools/board_user_acl/__manifest__.py.

That’s it.

I will most likely add new commands and other prompts.

Edits:

Removed prompt response with git patch file as it was often not working correctly.
Renamed llm-update to update-with-llm
Updated how files are searched

Digital Sustainability and LLMs

Fri, 22 Nov 2024 12:36:17 +0100

This week I experienced:

Dinacon 2024 - a yearly conference about digital sustainability
Playing the game Factorio Space Age
Not having access to Codeium and therefore writing code “offline”
Not being able to buy an H100 GPU

And even though these events seem unrelated, I think they have a lot in common. This is all about over consumption and resource availability. Let me elaborate …

Power for the hungry

At Dynacon there was a lot of talk about how tech companies and the tech industry can use any amount of power to train their large language models (LLMs) without being accountable to the actual usage of them.

To train a model you need a lot of graphics processing units (GPU). That is why Nvidia is now one of the most valued companies. However, at the time of writing, it is not possible to buy the popular GPU H100. At least for small companies. It seems big tech can have all the shiny gpus that they want.

Acquiring these resources to compute is limited, but once you have the means to compute there are no limit. This fact presents itself in stark contrast to the climate crisis. Over consumption of common resources is the main cause for the climate crisis.

Put on shackles

Why don’t we apply the same limit to resources to the tech industry as we already do for other industries (transport, automotive, electronics, …)? This sure is a difficult question. My current assumption is that we simply depend on the tech industry too much. They themselves claim that “they are too big to care”.

Internet lock-in

When coding I am using an LLM as a Service. My code editor sends the code that I am typing to an API and it returns a completed version of the code. This is a powerful way of coding. However, when I found myself coding without internet connection I instantly felt powerless. I relied on this service to complete my code. And this is now how I want to lead!

Taking the lead

Taking the leadership in this context is taking the full responsibility and accountability for the used services. To simply depend on a service and buy the responsibility for a monthly subscription is not the way. We have to take the lead when it comes to solving real world problems.

The solution

What I am trying to explain here can be simulated in games. In Factorio you build, automate and expand a factory that produces goods with growing complexity. The game constantly confronts you with resource limits and attacks on the factory. When producing too much pollution the inhabitants of the planet will try to destroy the factory. You can choose to produce sustainable energy (which is hardly enough to run the factory) or improve the defensive capabilities.

So much about the game. But, what it makes really interesting is the fact that you can play this with many friends. You have to cooperate, negotiate and make difficult decisions. Not often you end up arguing about a virtual blueprint of a non-existing part of the factory. You have to build a complex train network and share the workload to build this among the players. The tasks don’t feel fullfilling and some would say playing Factorio can feel like work. This all seems ridiculous at first glance, but the process of solving these problems within those game parameters, can produce meaningful strategies for the real world.

What this is all about

We cannot prompt our way out of the climate crisis. We have to take responsibility for the tools that we are using and the impact they have on our ecosystem.