Blog on Antoine Sauvinet - Technical Blog & Portfolio

The Many Roles of a CTO: One Title, Multiple Realities

Tue, 06 Jan 2026 00:00:00 +0000

Behind the ‘CTO’ title lie vastly different missions and scopes depending on the organization. A deep dive into ground realities and a framework to clarify the role.

Build vs Buy in 2026: The Paradigm Has Shifted

Mon, 05 Jan 2026 00:00:00 +0000

Ten years ago, the “make or buy” question often boiled down to a simple calculation: do we have the developers to build it? Today, with agentic AI accelerating development and standardizing practices, the equation deserves to be revisited.

Not that the answer has become simpler. It’s still “it depends.” But the criteria on which it depends have evolved.

Overview of the decision framework

The Myths That Lead to Bad Decisions

Let’s start by clearing out the reflexes that lead to dead ends — on both sides.

SD Generator CLI: No More Cargo Cult with Stable Diffusion

Tue, 21 Oct 2025 00:00:00 +0000

I’m open-sourcing SD Generator CLI, a tool to stop fighting with Stable Diffusion workflows.

SILK-CLI: A Writing Workflow with LLM Integration

Tue, 17 Jun 2025 00:00:00 +0000

Introducing SILK-CLI, a CLI tool for authors integrating LLMs into their writing workflow.

Will LLMs Replace Developers?

Wed, 04 Sep 2024 00:00:00 +0000

The answer is no. LLMs won’t replace developers, at least not in their current form.

[EnhanceYourCode] : the Builder Pattern, Part2

Wed, 16 Sep 2015 09:59:55 +0000

Hello,

In the previous article, we explored the theory of the builder pattern.

Let’s see a more concrete example :

Let’s assuming that we are building a Role Playing Game core model. Here are the basic rules:

A player can be a Hero : a Warrior, a Wizard, or a Thief (we keep it simple)
Every Hero has 4 main characteristics: Health, Strength, Spirit, and Speed, that are counted in points.
Heroes have a Level, and starting characteristics are based on this level (Health starts at Level * 10, Strength and Spirit start at Level * 5, and Speed starts at Level * 3)
Warrior has a (+2 Strength, -2 Spirit) Modificator, Wizard has (+2 Spirit, -2 Strength) Modificator
Player can improve 2 Characteristics of 1 points each or 1 characteristic of 2 points, in order to cutomize his Hero.

A naive implementation of the Hero class would be :

[EnhanceYourCode] : the Builder Pattern

Wed, 09 Sep 2015 14:58:47 +0000

Hello,

In this article, I’d like to present you the Builder pattern and how I use it in my C# code.

The Builder Pattern is a Creational design pattern, like the Factory Method Pattern I already covered un this previous article. Its main focus is to provide a light DSL to build objects by settings startup properties, by seperating the process of constructing an object from the object itself.

Basically, the idea is to create a class with mutable fields, that will be initialized with dedicated methods, and a final method that create the object itself from thoses values. Here is an abstract example :

Canopy : Automate your browser tests the F# way!

Mon, 31 Aug 2015 10:15:15 +0000

Hello,

I’d like to introduce you Canopy, a Selenium overlay written in F#. It brings you the concision and the clarity of F# to your selenium tests.

First of all, we have to create a new F# console application, then we install canopy in our project:

As you can see, the canopy nuget will bring back the selenium ecosystem.

Lets create our first test. It will check that a search of “canopy F#” in google will feature the official Canopy website as the first result. Here is the little bootstrapping needed by Canopy :

[Node.js] Build a clean process manager

Sun, 30 Aug 2015 12:06:56 +0000

In this article, I’ll demonstrate how to buid a simple and maintainable process manager for Node.js, leveraging its Event Loop.

The main idea is have a core processor that will be able to run a serie of tasks, in a synchronous way. As you may know, Javascript is by essence an asynchronous language. Let take simple example :

1
2
3
4
5
6
7
8


function CrawlingAWebPageAndGetLinks(){
 // do the stuff the method pretend;
}

(function program(){
 var result = CrawlingAWebPageAndGetLinks();
 console.log(result);
})();

As the execution flow is asynchroneous, the result variable will not be valued before the crawling method ends, and the usage of the variable will occurs before its valuation The standard solution in javascript to handle this issue is to use a callback method :

[EnhanceYourCode] : the Factory Method Pattern

Wed, 22 Jul 2015 21:33:31 +0000

The Factory Method pattern is one of the most useful creational design patterns. It allows us to delegate the creation of an object to a dedicated class, improving testability and respecting the Single Responsibility Principle.

Are Estimates business critical?

Tue, 16 Jun 2015 09:12:27 +0000

Thanks to my first post, i had the chance to have very interesting chat with some cowokers.

One of the main concern was the mandatory apsect of the estimates in specific situations, mostly in order to arbitrate between two projects.

First of all, let me clarify my thoughts about estimates. In order to provide reliable estimate, the following criteria have to be gathered :

Team should know itself perfectly, knowing precisely what are the strenghts and weakness of each member.
Team’s codebase should be either blank or without defects
product should entierely identified and specified, and the Product Owner, as the domain experts, 100% sure of what the final product should be.

I’ll post more on this later, but in my opinion, thoses conditions are at best anti-agile and at worst impossible to get.

(No)Estimates!

Mon, 08 Jun 2015 18:12:39 +0000

This is a daily struggle of the developper nowadays : to give accurate estimates of the work we are doing, or we’ll have to do. When was the last time you succeeded to give an actually accurate estimate? You know, the one that perfectly fits the amount of work to do, in the exact time frame, with a clear vision of what you were meant to do? It’s been a while, isn’t it?