Blog

HyperFrames-Gradle : Transforming AsciiDoc into MP4 Video

The `hyperframes-gradle` plugin transforms AsciiDoc into MP4 video via HyperFrames. AsciidoctorJ carries the configuration DSL. The Node.js bridge is isolated behind ProcessBuilder. This plugin fills the gap between slides and standalone videos. Here is why it exists, how it interfaces with capsule-gradle, and what it brings to the content production pipeline.

Auditing my LLM Consumption: SQLite, OpenCode, Ollama Cloud, and Why My Pro Subscription Blows the Global Market Away

I opened the OpenCode SQLite database to audit my actual consumption over 73 days. 2.6 billion tokens, 1,022 sessions, total API cost of 22 cents. Comprehensive comparison with Anthropic Claude ($300K+), OpenAI GPT, Groq, HuggingFace, Together AI, and Chinese providers. Result: my Ollama Cloud Pro subscription at €20/month is the best deal on the global market, even compared to direct Chinese offers.

The "Independent Plugin + Consumer Root" Architecture: Why My Gradle Builds Are Doubling

One clone, one `./gradlew tasks`, and your Gradle plugin is functional. Zero configuration, zero READMEs to read. Here is the architecture I deployed across my 6 foundry/public/ plugins: a minimalist consumer root + an autonomous `{name}-plugin/` folder. Why this "apparent duplication" pattern is the most productive for Gradle plugin development — with native dogfooding, build isolation, and a clear DAG contract.

The Knowledge Graph as a Recommendation Engine: How I Killed Chronological "Related Articles"

Current "related articles" on cheroliv.com are simply the 4 most recent posts. A semantic aberration corrected by a three-layer recommendation engine: explicit references (xref), emerging ontology (NLP clusters), and chronological fallback. All plugged into the graphify Knowledge Graph, consumed by bakery — without engine knowing anything about it.

27× to 45× more efficient than Claude and GPT: how a fleet of 23 fine-tuned AI experts crushes the market

Efficiency factor of 27× to 45× against Claude, GPT and the like: how a fleet of 23 AI experts fine-tuned on my workspace crushes the market. Architecture, dataset, training and full deployment.

Custom Gradle Plugin to Drive Two Ollama Pro Instances in Parallel

A custom build.gradle.kts to control two Ollama Pro instances from Gradle tasks — start, stop, sign-in, model pull, and health check. From driven infra to build tool.

Running Two Ollama Pro Subscriptions on the Same Machine with Docker

Docker allows you to duplicate an Ollama Pro subscription on the same machine by isolating identity keys and network ports. Here is how to do it, step by step.

Install Kitty terminal and configure Zsh as the default shell under Xubuntu

This post presents the complete process for installing and configuring the kitty terminal on Ubuntu.

DGX Spark vs Cloud vs LLM Subscriptions — The Economic Benchmark That Kills the Local Hardware Dream

At $4,699 for the DGX Spark, $20/month for Ollama Pro, and $1.38/h for a H100 in the cloud — the math is quick. This benchmark compares all options available in 2026 for running LLMs, from inference to fine-tuning. Verdict: the Spark is a luxury item, not a profitable tool. The real reason to buy local hardware in 2026 isn't economic — it's political.

The LLM Governance Matrix — Why Your AI Security Starts with the Directory Tree

What if your AI's security depended not on a prompt, but on a file system? This architecture manifesto defines a 4×4 matrix — physical zone × LLM access right — that makes secret leaks, the mixing of open/closed source, and the publication of opinions disguised as facts mechanically impossible. No prompts to write. No rules to remember. Just folders.

OSS/CSS Granularization — Why I Split foundry/ in Two

`foundry/` mixed open source code and private code in the same folder. The RAG and the knowledge graph couldn't tell the difference. The solution? Split this functional area in two — OSS/ for the public (Apache 2.0, free indexing), CSS/ for closed source (private dataset only). No more need to tell the LLM to be careful. The file system does it for it. And I took the opportunity to move cheroliv.com where it should have always been: in office/sites/.

Automated Epistemic Compartmentalization — How the LLM Protects My Mental Garden

The STIMULUS pattern does more than just capture raw ideas and dilute them into workspace documents. It adds a critical layer: the LLM is responsible for classifying each piece of information as Vision (publishable on the blog), Opinion (confined to the private circle), or Strategy (restricted dilution). This automated epistemic segregation is what allows for free thinking in Circle 0 without fear of inappropriate publication.

Our First Hire: the Dataset Anonymizer — MVP0 on Probation

Before doing RAG, fine-tuning, or SaaS, you need clean data. Our first hire on probation — the Anonymizer — detects and cleans PII in multi-technology sources (SQL, pgvector, ONNX, Graphify, JSON, YAML, AsciiDoc). This is the MVP0. Without it, everything else is either illegal or technically degraded. Here is how this brick transforms a universal problem into a marketable product.

The Developer's Secret Garden: How Spatial Ontology Aligns LLMs Without Prompt Engineering

What if the best way to align an LLM wasn't a prompt, but a file system? My workspace is structured into four concentric circles of trust, from the most intimate to the most public. The LLM doesn't have to memorize the rules — it sees them in every file path. Here is how this spatial ontology makes agent governance more robust than a block of text rules.

Supabase → Firebase Migration: Connecting a Contact Form to Firestore Without a Backend

My contact form had been running on a mock for months. The initial Supabase plan was abandoned in favor of Firebase. I describe the project creation, Firestore configuration, rewriting the submission JS, cleaning up dead code, and what this migration says about the "finish what you started" mindset.

DeepSeek-V4-Pro, Kimi K2.6, GLM-5.1 : Three LLMs Put to the Test of Long-Context Vibe Coding

For three weeks, I ran three major models through my Gradle plugin development sessions with Opencode. 30K token context, Eager/Lazy/Hot/Warm/Cold governance, refactoring tasks, TDD, and architecture. Here is which one survived — and why the others faltered.

Agent Context Audit: When Your Own Governance Becomes the Problem — and How to Fix It Without Losing Anything

After two articles on structuring and backing up agent context, I discovered that the file documenting the method itself had become the biggest token consumer. A section-by-section audit of a 627-line `AGENT_MODUS_OPERANDI`, identification of duplicates, and an encyclopedic split solution that preserves engineering without saturating the context.

Sliding Window and Cold Wave: When Agent Context Explodes and You Need to Archive Without Losing

After months of Opencode sessions, governance files are exploding. 5200 lines loaded automatically. I am conceptualizing a sliding window and "identical cold wave" mechanism to maintain a light active context without losing anything.

When Gradle 9, Docker 29, and Testcontainers clash: debugging a JHipster build

A `./gradlew build` that fails with eleven successive errors, from a non-existent `reportsDir` variable to Docker Engine 29 rejecting the docker-java 1.32 client. Here is the complete debugging log of a JHipster build on Gradle 9, Java 21, and Testcontainers 2.0.5.

Governing an AI Agent with AsciiDoc: My Eager/Lazy Strategy for Context-Leak-Free Opencode Sessions

Faced with context leak between AI agent sessions, I developed a handcrafted governance strategy based on AsciiDoc files. The principle: an auto-loaded Eager dashboard, a Lazy owner's manual on demand, and an essential end-of-session procedure.

Why `serve` displayed an ugly site while `publishSite` was perfect

The `serve` task of my JBake Gradle plugin displayed rectangular buttons, unreadable text, and partially missing CSS, while `publishSite` produced a perfect site. Root cause: JBake CLI arguments passed with incorrect syntax. Here is the full diagnostic and how I fixed it.

OpenCode and the incomplete PATH: why your tools weren't in the agent's shell

OpenCode executes non-interactive shells that do not source .zshrc. Result: SDKMAN, NVM, ~/apps and pnpm are missing from the agent's PATH. Full diagnostic of the problem, comparison of SDKMAN vs NVM behavior, and definitive solution via .zshenv + ~/.nvm/current symlink.

Integrating Graphify into a Gradle workflow: from Knowledge Graph to PlantUML diagram in one command

Graphify extracts a Knowledge Graph from your codebase. The PlantUML Gradle plugin transforms this graph into deterministic PlantUML diagrams. Complete pipeline: pip install graphify → graphify . --no-viz → ./gradlew generateKnowledgeGraphDiagram → PNG diagrams versioned in Git.

The super tip for the fg command: when Ctrl+Z saves your terminal session

Have you launched a command that blocks your terminal? Ctrl+Z suspends it, fg resumes it. Discover how fg, bg and jobs transform your terminal productivity.

VS Code in the Home: local installation and font customization without sudo

Install VS Code in your Linux home to maintain full control without sudo. Then customize the fonts of the menu and the file explorer — a journey fraught with pitfalls that finally leads to a readable UI.

Migration of an Asciidoctor RevealJS plugin to buildSrc Kotlin: reverse engineering a Groovy API

How to migrate the configuration of an `AsciidoctorJRevealJSTask` task from the root buildscript to a standalone buildSrc Kotlin plugin, replacing the Groovy DSL `ruby { gems() }` with its underlying mechanisms discovered via bytecode introspection.

JBake Architecture Portfolio - Vision and Use Cases

Discover how I solved a series of complex Mockito mocking problems in Gradle plugin tests, from "Wanted but not invoked" errors to cascading "Unfinished Stubbing".

Hybrid Architecture: The Best of Both Worlds with Supabase and Spring Boot

Combine Supabase for simple CRUD and Spring Boot for complex logic. A pragmatic, scalable, and cost-effective hybrid architecture.

The Art of Preloading: Eliminating Theme "Flash" with JavaScript and CSS

Efficient Logging in Gradle Plugin Functional Tests

Complete guide to implementing a robust and independent logging system in Gradle plugin functional tests with SLF4J and Logback

Displaying Colored Squares in AsciiDoc: A Practical Guide

A practical guide for integrating color samples in AsciiDoc using the `pass:[]` macro with inline HTML and CSS. Compatible with JBake and all processors.

Internationalization of a JBake static site with Thymeleaf

Complete guide to implementing internationalization in JBake with Thymeleaf: message files for the UI, folder organization for multilingual articles.

Install and Verify Tor Browser on Ubuntu

Complete procedure for downloading, verifying, and launching Tor Browser on Ubuntu, with reflections on cryptographic verification and ethical and educational browsing within the Tor network.

Article 5: The Adventure of the Shared libs.versions.toml

A deep dive into the Gradle version catalog (libs.versions.toml) and how to share it in a composite build, through a concrete problem encountered with our site-baker plugin.

Article 4: The Gradle Configuration Cache Trap

An unexpected debugging adventure that plunged us into the intricacies of Gradle's configuration cache. Discover why our builds were behaving strangely and how we solved the problem.

Article 3 : Integrating Jackson for YAML Parsing with TDD in a Gradle Plugin

Discover how to integrate the Jackson library to parse YAML configuration files into Kotlin objects within a Gradle plugin, following a Test-Driven Development (TDD) approach.

Article 2 : Developing a Gradle Plugin with a TDD Approach

In this article, we will explore how to set up a solid development base for a Gradle plugin using a Test-Driven Development (TDD) approach.

Article 1: Creating a Gradle Plugin from A to Z with the gradle init command

A step-by-step guide to initializing a Gradle plugin project using the standard `init` task, understanding the generated structure, and running the first build commands.

Article 0 : Setting Up the Environment for Creating Gradle Plugins

Before coding our first plugin, we need to prepare our machine. This guide shows you how to install and configure the essential tools: a JDK, IntelliJ IDEA, Gradle, and JBake.

Python CI/CD – Part 3: Going Further with Poetry, Docker, and Advanced Publishing

Part 3 - Comprehensive guide to setting up a robust CI/CD pipeline with GitHub Actions, from linting and automated tests to automatic deployment on PyPI during releases.

Part 2: Industrializing and Securing an Advanced Python CI/CD Pipeline

Part 2 - Complete guide to setting up a robust CI/CD pipeline with GitHub Actions, from linting and automated tests to automatic deployment on PyPI during releases.

Part 1: Setting up a simple CI/CD pipeline for Python and PyPI

Part 1 - Complete guide to setting up a robust CI/CD pipeline with GitHub Actions, from linting and automated tests to automatic deployment on PyPI during releases.

Developing a Musical Discord Bot: Functional Architecture and Log Driven Development

Cooling and monitoring laptop temperature under Ubuntu

Debugging Story: Taming Firefox's Quirks with Bootstrap 5

Solving the Gradle Unit Testing Challenge with `gradle.properties`

Discover an effective technique for unit testing Gradle plugins that depend on `gradle.properties`. This article explains how to use `ExtraPropertiesExtension` to simulate properties, ensuring isolated, reliable, and maintainable tests, illustrated with PlantUML diagrams.

Optimizing Gradle Task Management with Kotlin DSL and buildSrc

Optimize Gradle with buildSrc and Kotlin DSL for reusable tasks and cleaner builds.

TDD of a configurable Kotlin Gradle Plugin with JBake and JGit

This post presents the complete design and testing process (TDD) of a Gradle plugin written in Kotlin DSL. This plugin automates the generation of static sites with *JBake* and *Git deployment* via *JGit*, all from a YAML configuration file.

AsciiDoc: Discover and Master the Syntax for Effective Documentation

Dive into AsciiDoc syntax and learn how to write clear, structured, and powerful documents for all your documentation and publishing needs.

Exposing a local service on the Internet from Ubuntu: Complete guide to port forwarding

How to configure port forwarding to make a local service running on Ubuntu accessible from outside your home network.

Debugging Mockito: Solving the "Wanted but not invoked" error in Gradle plugin tests

Discover how I resolved a series of complex Mockito mocking issues in a Gradle plugin test, from the "Wanted but not invoked" error to cascading "Unfinished Stubbing".

Kotlin Arrow: Mastering Either Monad Navigation

Découvrez les techniques avancées pour naviguer efficacement dans les côtés right et left de la monade Either avec la bibliothèque Kotlin Arrow.

Practical Guide: Searching for Files under Linux

Apprenez à rechercher efficacement des fichiers sous linux avec Zsh en utilisant find, locate, et grep.

Linux memo

Simple mémo sur unix/linux et le terminal bash

Expose a Linux subsystem port to the Windows host

Exposer un port linux subsystem pour l'hôte windows, avec la commande `wsl --install`.

Install Pandoc

Installer Pandoc qui est un tranformateur de document, sur linux et windows wsl

Implementation of kotlin.Triple in JavaScript, TypeScript, and Python

Proposons une implémentation de kotlin.Triple en JavaScript, TypeScript et Python

Introduction to Google Apps Script

Introduction complète à Google Apps Script

Express Training on Google Form Script and Automation

Formation Express sur Google Form Script et Automatisation

Python Memo

simple Python memo

Web dev

Training Web dev

Trading card games (TCGs)

Training trading card games (TCGs)

TypeScript Memo

simple mémo Typescript

CSS Memo

simple mémo CSS

HTML Memo

simple mémo HTML

Javascript Memo

simple mémo Javascript

Scoping Memo

simple memo on project scoping.

Kotlin Memo

simple kotlin memo

JVM Memo

simple JVM memo

Gradle Memo

simple gradle memo

Training - kotlin: enum, sealed classes

Kotlin programming: enum, sealed classes

Training - Kotlin

Kotlin programming, plan.

Design system memo

Simple memo of useful links and references in the design system

Kubernetes, MicroK8s, Docker: first steps

Installation, mise en place de micro kubernetes, docker, et lancement d'un helloworld sur linux/unix

Gradle: Running an external process from a Gradle task

Comment lancer un binaire externe depuis une tache gradle

Kotlin: NotImplementedException, NotImplementedError

Pas encore implémenté, permet de lever la bonne exception.

Untar

l'application untar

Gradle: Rerun tests even when tests are UP-TO-DATE

ajouter l’argument --rerun-tasks à la ligne commande.

Docker does not install the application but pulls it instead.

docker optimisation

Gherkin in French:

BDD, cucumber, gherkin en français

Gradle CLI: overriding a parameter

./gradlew -Pparam_component=CUSTOM

Git memo

simple mémo git

Download from a URL

wget aspirateur d'URL

Create a bootable disk

faire son disque bootable

Unzip via CLI into a target folder

dezipper en ligne de commande

Display the sum of file sizes in the directory list

la somme des tailles de fichiers dans un dossier

Delete a branch on GitHub

complément mémo git

Asciidoc/Markdown Cheat Sheet

simple mémo ascidoc/markdown

Debian: Install a .deb file via the command line

installer des .deb en ligne de commandes

Gradle: resources folder visible in the IDE

ajouter un dossier au classpath d'un build gradle

Groovy script, grab ivy configuration

gradle groovy ivy

Groovy: a bit of algebra, the GCD and the LCM

de l'algebre en groovy

Bash: Finding files by extension and outputting to a file with find

un peu de bash avec find

Managing a digital project with a waterfall methodology

un peu de methodo des projets digitals avec la méthodologie en cascade

List the databases in a PostgreSQL instance

tatonnement de postgres

Groovy: Rename files recursively

recursion en groovy

Groovy: File search with criteria, copy selection

recherche de fichier par motif en groovy

Groovy: File manipulation, search and deletion

manipulation de fichiers et recherche de caracteres en groovy

Groovy: Replacing a character sequence in a String and loading Properties from a file

manipulation de Properties et recherche de motif en groovy

Groovy: ASCII Characters

du groovy, des boucles et de la manipulation de code ascii