DEV Community: Thomas Bonnet

How to Create Your Own Personal Blog with Astro

Thomas Bonnet — Sat, 08 Aug 2026 10:05:11 +0000

You want a personal blog without spending three months on it or paying for a CMS every month.
This site you’re reading right now is exactly that: an Astro blog.

No database, no admin panel to maintain:

Markdown files
Content Collections
A bit of Tailwind
And a static deployment on Cloudflare Workers.

Here’s how to set it up, using the same building blocks as the ones used here.

A personal blog is a project you should be able to maintain on your own, for as long as you want. No heavy external dependencies, no CMS that disappears overnight, no server to run. Just a Git repository, Markdown files, and static hosting.

Why Astro for a blog

Astro itself explains its philosophy in “Why Astro”: a framework designed for content-focused sites, server-side by default. In practical terms, this means:

Simplicity: no state management, no JavaScript framework to learn just to write an article. .astro components and Markdown that’s it.
Speed: Astro renders static HTML by default; no JavaScript is sent to the client unless you explicitly request it (client:load, etc.). For a blog, this is exactly what you need: content that’s easy to read, not a SPA.
Fast deployment: static build, no servers to run, deploys to any CDN in seconds.
Markdown content: each post is a .md file, versioned in Git, editable in any text editor.
Easy to maintain: Content collections provide data typing for front matter using Zod, which is validated directly during the build a front matter error breaks the build rather than silently crashing in production.

Create the project

npm create astro@latest -- --template minimal
cd mon-blog
npm install

Once Tailwind and the content collections have been added (next steps), the directory structure of a minimal Astro blog looks like this:

my-blog/
├── astro.config.ts
├── package.json
├── tsconfig.json
└── src/
    ├── content.config.ts       # article structure (Zod)
    ├── styles/
    │   └── global.css          # import Tailwind
    ├── data/
    │   └── blog/
    │       ├── premier-article/
    │       │   ├── index.md
    │       │   └── banner.webp
    │       └── deuxieme-article/
    │           └── index.md
    ├── layouts/
    │   ├── Layout.astro        # <head>, meta, theme
    │   └── PostDetails.astro   # The rendering of an article
    ├── components/
    │   └── Header.astro
    └── pages/
        ├── index.astro
        └── blog/
            ├── index.astro         # List of Articles
            └── [...slug]/
                └── index.astro     # article page (dynamic route)

A deliberately simplified structure to get started: in a real project, you’ll quickly add a pagination route ([...page].astro) and quite a few other components as you go.

Add Tailwind (v4, via the Vite plugin, no need to manage a tailwind.config.js file):

npm install tailwindcss @tailwindcss/vite

// astro.config.ts
import { defineConfig } from "astro/config";
import tailwindcss from "@tailwindcss/vite";

export default defineConfig({
  vite: {
    plugins: [tailwindcss()],
  },
});

And a CSS entry point that imports Tailwind:

/* src/styles/global.css */
@import "tailwindcss";

Articles in Content Collections

Each article is stored in its own folder under src/data/blog/<slug>/, along with an index.md file and its images (banner.webp, screenshots, etc.).
This keeps each article self-contained: there’s no need to search through a shared public/images folder to find an asset.

The schema is declared once, in src/content.config.ts:

import { defineCollection, z } from "astro:content";
import { glob } from "astro/loaders";

const blog = defineCollection({
  loader: glob({ pattern: "**/[^_]*.md", base: "./src/data/blog" }),
  schema: ({ image }) =>
    z.object({
      title: z.string(),
      description: z.string(),
      pubDatetime: z.date(),
      modDatetime: z.date().optional(),
      draft: z.boolean().default(true),
      tags: z.array(z.string()).default(["notes"]),
      ogImage: image().or(z.string()).optional(),
    }),
});

export const collections = { blog };

So an article is just that:

---
title: "My First Article"
description: "A short tagline for lists and SEO."
pubDatetime: 2026-08-10
draft: false
tags:
  - Astro
---

Markdown content here.

If draft is set to true or pubDatetime is in the future, the article should not appear in the listings:
This is a filter you must apply yourself when calling getCollection; Astro does not do this for you:

import { getCollection } from "astro:content";

const now = Date.now();
const posts = await getCollection("blog", ({ data }) => {
  const isPublished = now > data.pubDatetime.getTime();
  return !data.draft && isPublished;
});

Layouts: One for the list, one for the post

Two layouts are enough for the vast majority of personal blogs:

A base layout (Layout.astro) that sets the <head>, the OpenGraph meta tags, and the light/dark theme.
A PostDetails.astro that receives a collection entry, displays the title and dates, and renders the Markdown via render(post):

---
import { render } from "astro:content";
const { post } = Astro.props;
const { Content } = await render(post);
---

<article>
  <Content />
</article>

All typographic styling (headings, quotes, code) is handled by a Tailwind class like prose applied to this <article>,
not by hand-written CSS on a per-element basis.

Lightweight i18n: a dictionary, not a router

There’s no need for Astro’s native i18n routing if the site has only one content language and just interface labels to translate.
A simple dictionary is all you need:

// src/i18n/ui.ts
export const defaultLang = "fr";

export const ui = {
  fr: {
    "nav.home": "Accueil",
    "footer.rights": "Tous droits réservés",
  },
  en: {
    "nav.home": "Home",
    "footer.rights": "All rights reserved",
  },
} as const;

// src/i18n/utils.ts
import { ui, defaultLang } from "./ui";

export function useTranslations(lang: keyof typeof ui) {
  return function t(key: keyof (typeof ui)[typeof defaultLang]) {
    return ui[lang][key] ?? ui[defaultLang][key];
  };
}

In a component: const t = useTranslations(lang); t(“nav.home”).
Zero external dependencies, zero JSON translation files to load dynamically: everything is typed and validated during the build by TypeScript.

For the articles themselves, rather than having duplicate content in two languages, an optional englishUrl field in the front matter is enough to point to an English version published elsewhere (dev.to, for example), without having to maintain a complete translation that’s synchronized with every change.

Deploying to Cloudflare Workers

Astro in static mode generates a dist/ folder ready for hosting.
Cloudflare Workers can serve these static assets directly (no need for Pages) via Wrangler:

npm install -D wrangler

// wrangler.jsonc
{
  "name": "my-blog",
  "compatibility_date": "2026-01-01",
  "assets": {
    "directory": "./dist"
  }
}

npm run build
npx wrangler deploy

Each wrangler deploy command pushes assets to the Cloudflare edge.
For automated CI/CD (push = deployment), connect your Git repo in the Cloudflare Workers dashboard or add a wrangler deploy step to your pipeline (GitHub Actions, for example).

No servers to manage, no cold starts for static content.
Cloudflare’s CDN serves files directly from the edge, and you can get right back to writing.

Don’t want to start from scratch?

My website is actually based on an existing theme: AstroPaper, a minimalist, responsive, accessible, and SEO-friendly blog theme, which I then customized to my liking (Tailwind v4, lightweight i18n, TOC, etc.).

No need to build everything from scratch: the official Astro theme marketplace lists dozens of ready-to-use templates (blogs, portfolios, documentation, e-commerce) that you can clone and then customize.

Conclusion

Brick	Role
Astro	Generates static HTML; no JS by default
Content collections	Markdown articles, validated by a Zod schema
Tailwind v4	Styling, with no configuration files to maintain
i18n dictionary	Translated interface labels, without heavy routing
Cloudflare Workers	Static hosting, one-command deployment

A personal blog with Astro has very few moving parts: Markdown files organized into folders, a Zod schema that keeps the front matter clean, Tailwind for styling, and a static site generator that pushes everything to a CDN. No operations to manage, nothing to run continuously, just write, commit, push.

Learn More

Passkeys Explained Simply

Thomas Bonnet — Mon, 27 Jul 2026 21:09:04 +0000

You’ve probably seen that little prompt that says “Sign in with Face ID” or “Use a passkey” instead of the traditional password field. That’s a passkey. And no, it’s not just a password hidden behind your fingerprint.

The best password is the one you never have to type.

The Problem with Passwords

A password is a secret that you have to remember, and that the website has to store (ideally hashed). The problem is that this system relies entirely on two weak points:

You, who reuse the same password everywhere because you’re tired of coming up with a new one.
The website, which can be hacked and have its password database leaked.

Add phishing to that: a fake website that perfectly mimics the real one can steal your password without you even realizing it. And this isn’t just a minor issue: as the Verizon DBIR report reminds us every year, social engineering, phishing, and stolen credentials remain among the leading causes of hacking worldwide, alongside software vulnerabilities.

Source: Data Breach Investigations Report, Verizon

Even with a password manager and 2FA, the fundamental vulnerability remains: a secret that you could accidentally share.

What exactly is a passkey?

A passkey is based on asymmetric cryptography, the same principle as SSH, if you've ever generated a key pair to connect to a server.

When you create a passkey for a website:

Your device (phone, computer, security token) generates a key pair: a private key and a public key.
The private key never leaves your device. It is stored in a secure chip: the Secure Enclave on iPhone/Mac, the TPM on Windows, or directly on the chip of a USB key such as a YubiKey.
The public key, on the other hand, is sent to the website and stored on the server.

To log in, the site sends you a challenge (a random number), your device signs it with the private key, and the site verifies the signature using the public key. If they match, you're authenticated.

No secrets ever travel over the network only a signature. It’s written in black and white in the W3C WebAuthn spec: nothing to steal, nothing to phish.

Why It’s More Secure

Password	Passkey
Shared secret, transmitted with every login	Nothing is transmitted, just a signature
Reusable across multiple sites	Unique per site, tied to the domain
Vulnerable to phishing	Resistant to phishing (tied to the exact domain)
Can be leaked in the event of a server breach	The server stores only the public key, which is useless to an attacker
Must be memorized or managed via a manager	Unlocked via biometrics or a local code

The key point: a passkey is linked to the domain on which it was created. If you go to paypa1.com instead of paypal.com, your device won't even offer the passkey. It's the browser/OS that performs this verification, not you. Google explains it very well: unlike a password, a passkey is cryptographically bound to the site for which it was created, so it’s impossible to intercept or reuse on a fake site. They’re resistant to phishing by design, not because of the user’s good faith.

Under the Hood: WebAuthn and FIDO2

Technically, passkeys are based on the WebAuthn (W3C) standard, which is part of the broader FIDO2 standard promoted by the FIDO Alliance (whose members include Google, Apple, Microsoft, and Yubico). It is this API that browsers expose via JavaScript to create and use credentials.

Diagram of the registration flow, based on the W3C WebAuthn spec

Creating a client-side passkey looks like this:

const credential = await navigator.credentials.create({
  publicKey: {
    challenge: new Uint8Array(32), // provided by the server
    rp: { name: "My Super Site", id: "mysupersite.com" },
    user: {
      id: new Uint8Array(16),
      name: "thomas@example.com",
      displayName: "Thomas",
    },
    pubKeyCredParams: [{ alg: -7, type: "public-key" }], // ES256
    authenticatorSelection: { userVerification: "required" },
  },
});

And to log in with an existing passkey:

const assertion = await navigator.credentials.get({
  publicKey: {
    challenge: new Uint8Array(32), // provided by the server
    userVerification: "required",
  },
});

The server generates the challenge, the browser handles all the biometrics and unlocking, and sends you back a signature to verify. On the server side, libraries like @simplewebauthn/server in Node.js do most of the verification work.

What if I lose my phone?

This is the question that stumps everyone, and if this topic resonates with you, I’ve already written an entire article on the hassles of 2FA after a phone theft, the same “single point of failure” principle applies to passkeys. Since 2022, Apple, Google, and Microsoft have added passkey synchronization:

On iOS/macOS, they sync via your iCloud Keychain.
On Android/Chrome, they sync via your Google Account, using Google Password Manager, which encrypts everything end-to-end.
On Windows, via Windows Hello, although cross-device synchronization is even more limited there than with Apple or Google.

So if you lose your phone but regain access to your iCloud or Google account on a new device, your passkeys will be restored as well. You can also use a physical security key (YubiKey) as a backup, which doesn’t sync but works on any compatible device exactly the same advice as for traditional 2FA: never put all your eggs in one basket.

How to Use Them Today

More and more services already offer them: Google, Apple, GitHub, Microsoft, PayPal, Amazon, X... Google has even gone a step further by making passkeys the default for personal accounts. You’ll usually find them in your account’s security settings, under “Access Key” or “Passkey.”

The typical workflow:

Go to the service's security settings.
Click “Add an access key” or “Create a passkey.”
Your browser or operating system will ask you to confirm using Face ID, Touch ID, Windows Hello, or your phone's passcode.
That's it. The next time you log in, you won't need a password.

If you want to manage your passkeys somewhere other than your OS’s keychain (useful if you’re on multiple different platforms), ProtonPass can also create and store them—end-to-end encrypted—in the same place as your passwords.

Conclusion

Question	Answer
What is it based on?	Asymmetric cryptography (private/public key pair)
Does the password travel over the network?	No, never
Resistant to phishing?	Yes, by design (domain-bound)
Technical standard	WebAuthn / FIDO2
Device loss	Recoverable via iCloud/Google sync, or physical backup key

Passkeys aren't just “a password hidden behind a fingerprint”, they represent a complete shift in the model: nothing to remember, nothing to steal. If a service offers you the option to create one, go for it it's significantly more secure and faster than your current password.

The ProtonPass link in this article is an affiliate link, which means I may receive a commission if you decide to sign up through this link, at no additional cost to you. This helps me cover hosting and domain name fees. Thank you for your support!

Clean up Docker images that are taking up space

Thomas Bonnet — Tue, 21 Jul 2026 08:00:00 +0000

You deploy, you rebuild, you test things. And one day, you look at your server and you have only 2 GB of free space left. Congratulations, Docker has eaten it all up.

Your Docker hard drive hates you. And it’s your fault.

What exactly is the problem?

Docker accumulates images over time. Every time you run a docker build, if anything changes, it creates new layers and keeps the old ones. These old layers which have no tags, no names, and no purpose are called dangling images.

They serve no purpose. They take up space. And Docker doesn’t delete them on its own.

See where you stand

Before deleting anything, there’s just one thing to do:

docker system df

This shows you in a few lines how much space is being used—and, more importantly, how much is available. That’s your starting point.

Want to see the images in detail?

docker images --format "table {{.Repository}}\t{{.Tag}}\t{{.ID}}\t{{.Size}}"

Delete dangling images

Dangling images are intermediate layers that are left behind. They have neither a tag nor a name. To delete them:

docker image prune

Docker asks for your confirmation, shows you what it's going to delete, and you confirm. Clean, fast, and risk-free.

Go a step further

If you have entire images that are no longer used by any container (even stopped ones), you can delete them as well:

docker image prune -a

The -a option changes everything: now it no longer targets just dangling images, but all unreferenced images. That’s what you want in most cases on a production or staging server.

You can filter by age if you want to keep recent images:

docker image prune -a --filter "until=720h"

It only deletes items that are more than 30 days old. This is handy if you have regular deployments.

Reset Everything

If you want to reset everything images, stopped containers, orphaned volumes, unused networks:

docker system prune -a --volumes

I don’t recommend doing this on a production server without first checking what’s running. But on a dev machine or a VPS that you rebuild regularly, it’s perfect.

Automating All of This

Instead of doing this manually, you can set up a weekly cron job:

# crontab -e
0 3 * * 0 docker image prune -a -f >> /var/log/docker-prune.log 2>&1

Every Sunday at 3 AM, it cleans up without asking for confirmation (-f), and logs the result.

Conclusion

Command	What it does
`docker system df`	View used space
`docker image prune`	Remove dangling images
`docker image prune -a`	Remove everything that is no longer in use
`docker image prune -a --filter “until=720h”`	Same as above, but only for old images
`docker system prune -a --volumes`	Reset everything to zero

Start with docker system df. In 90% of cases, running docker image prune -a is enough to free up several gigabytes without breaking anything.

RES, my personal safeguard against AI

Thomas Bonnet — Thu, 16 Jul 2026 21:17:26 +0000

The Problem

The more I use AI in my daily life, the longer my conversations get. And the longer a conversation goes on, the greater the risk that the AI will stray from my initial instructions. A change in tone, a forgotten constraint, a format that’s no longer followed… Nothing dramatic in itself, but enough to waste time rereading each response in detail to make sure it’s still consistent.

Just to be clear: this flag doesn’t mean you can skip rereading what the AI gives you and checking it yourself—especially before taking action. It’s an extra warning sign, not a substitute for your own vigilance.

The thing is, I never realize it right away. The AI doesn’t tell me, “By the way, I skipped that instruction you gave me 10 messages ago.” I notice it after the fact, usually once it’s already a little too late.

The trick I use

I saw a tip in a YouTube video (a source I haven't been able to find again, unfortunately 🙈): ask the AI to write a specific word of your choice at the very beginning of each response.

In my case, that word is RES. I added it to my preferences:

Every time you reply to me, start with “RES.”

And since then, every reply has started like this:

RES

[response]

Why It Works

The principle is simple: it’s a constant prompt that appears in all my conversations, and I can check it at a glance. If the word is there, I know the AI still has my instructions in mind when responding. If it disappears, that’s my warning sign: something got lost along the way, so I need to reread the response more carefully—or even remind the AI of my instructions.

It’s a bit like a canary in a coal mine. 🐤 The canary doesn’t solve anything on its own; it does just one thing: signal that something unusual is happening, before it becomes a real problem.

A Comparison with Security

As I delved deeper into the subject, I realized that this concept already exists in cybersecurity, under the name canary token. It’s a unique string of characters, hidden in the system prompt of an AI application, designed to detect prompt injection attacks: if this token appears (or disappears) from the response, it indicates an attempt at manipulation.

My use of it has nothing to do with security, but the underlying principle is the same: a constant signal, the absence of which reveals an anomaly.

	Canary token (security)	My token (“RES”)
What it protects against	An attacker manipulating the AI	A natural drift of the AI itself
The word is...	Hidden; the AI must never reveal it	Visible and acknowledged; it is part of the response
How it is generated	A random string, unique to each session	A word chosen once and kept as is
Who verifies it	An automated script	Me, by eye

The key difference: the canary token protects against an external threat. My “RES” monitors an internal drift specific to how the model operates on a conversation that drags on.

What This Actually Changes

Well, it doesn't guarantee anything 100%, it's not magic. But in practice, it's helped me to:

Spot more quickly when I need to steer a conversation back on track if it strays from my initial request
Keep a simple visual cue, without having to reread everything in detail every time
Have a stable reference point, no matter the topic or length of the exchange It’s a simple, free tip that takes two seconds to set up. If you want to try it out, just add a line to your custom instructions or to the system prompt of your favorite AI.

Do you have any similar tips for staying in control of your conversations with AI? Let me know on Discord or on social media! 💬

Acronyms and Jargon in Development and Open Source

Thomas Bonnet — Wed, 01 Jul 2026 16:35:59 +0000

Introduction

You join an open-source project, read a discussion on GitHub, and then... PR, LGTM, WONTFIX, RFC. You nod politely, but you have no idea what any of that means.

That’s normal. The world of development has developed its own dialect over the years, shaped by Git tools, open-source practices, and team communication habits. Here’s a glossary to help you decode it all. ✊

Git and GitHub/GitLab

Basic Actions

Commit: a snapshot of your code at a given moment. Each commit has a message explaining what you changed and why.
Push / Pull: push sends your commits to the remote repository. pull fetches changes from the remote repository to your local machine.
Fork: a copy of a repository in your own space. You fork a project so you can contribute to it without affecting the original.
Clone: download a local copy of a remote repository to work on it.

Branches and Merging

Branch: a parallel development path. You create a branch to work on a feature or a fix without affecting the main branch.
Merge: to merge changes from one branch into another. “Merging a PR” means integrating the proposed code into the main repository.
Rebase: Reapplying your commits on top of another branch to maintain a clean, linear history.
Conflict: When two people have modified the same lines of code differently. Git doesn’t know which one to choose, so it asks you to decide.
Stash: Set aside changes you’re working on without committing them, so you can quickly switch branches.

Pull Requests and Issues

PR (Pull Request) / MR (Merge Request): A proposed change. You submit your branch so it can be reviewed and integrated into the project. PR is the GitHub term; MR is the GitLab term.
Issue: a ticket. It can be a reported bug, a requested feature, or a question. The cornerstone of open-source project management.
Review / Code Review: the process of reviewing the code proposed in a PR before it is merged. Someone leaves comments, suggestions, or approves it.
Draft PR: a PR marked as “in progress.” It indicates that the work isn’t finished, but that you want to share your progress.

Discussion Jargon

These terms often appear in PR and issue comments.

Term	Meaning
LGTM	Looks Good To Me: informal approval of a PR
SGTM	Sounds Good To Me: same idea, for a verbal proposal
WIP	Work In Progress: in progress, not yet ready
RFC	Request For Comments: seeking feedback before making a decision
WONTFIX	The bug is known but will not be fixed (intentionally)
RTFM	Read The Friendly Manual: go read the documentation (sometimes said less politely)
TL;DR	Too Long; Didn't Read: summary of a long text
nit	Nitpick: minor comment on style or form, not a deal-breaker
ACK / NACK	Acknowledged / Negative Acknowledge: “I agree” / “I disagree”
+1 / -1	Vote for or against a proposal

About Projects and Contributing

README.md: A project's welcome file. It explains what the project is, how to install it, and how to contribute.
CONTRIBUTING.md: the project’s contribution guidelines. Read this before opening a PR.
CHANGELOG.md: the history of changes between each version of the project.
ROADMAP.md: the project’s roadmap, outlining what’s planned for future versions.
AGENTS.md: supplements the README file by providing additional—and sometimes detailed—context that agents need: build steps, tests, and conventions that might clutter a README file or aren’t relevant to human contributors.
LICENSE.md / LICENCE.md: the terms of use for the code. MIT, GPL, Apache… this determines what you can do with the code.
CI/CD: Continuous Integration / Continuous Deployment. Automated pipelines that test and deploy the code with every push or merge.
upstream / downstream: “upstream” refers to the original project (the one you forked). Downstream is your version or the projects that depend on yours.
Maintainer: the person (or team) who maintains a project. They review PRs, manage issues, and make decisions.
Contributor: anyone who contributes to a project, even without direct access to the repository.

Versioning and Releases

SemVer (Semantic Versioning): the MAJOR.MINOR.PATCH convention (e.g., 2.4.1). A breaking change increments the MAJOR version. A new feature increments the MINOR version. A bug fix increments the PATCH version.
Tag: a marker on a commit, usually to indicate a version (v1.0.0).
Release: the official publication of a software version, often accompanied by a changelog and downloadable artifacts.
Breaking change: a change that breaks compatibility with previous versions. This should be clearly indicated.
Deprecation: marking a feature as obsolete before removing it in a future version.

The Right Mindset

The jargon may seem intimidating, but it’s there to speed up communication, not to exclude anyone. No one expects you to know all of this by heart right from the start.
The best way to learn: contribute. Open issues, read other people’s PRs, ask questions. Most open-source communities are welcoming to beginners, especially if you’ve read CONTRIBUTING.md and README.md beforehand. 😄

Learn More

Git - A Short Guide: The basics of Git in French
First Contributions: a step-by-step guide to your first pull request
Choose a License: understanding open-source licenses
Semantic Versioning: Understanding semantic versioning
Agents.md: A guide to writing a clear and useful AGENTS.md file

Find me on GitHub or Discord to chat about development and open source!

Which AI should you choose in 2026? Claude, Perplexity, Gemini, or ChatGPT

Thomas Bonnet — Mon, 01 Jun 2026 00:07:18 +0000

Claude Code — My daily dev tool

Claude Code by Anthropic is the one I use the most for development, by far. What sets it apart from the others: it integrates directly into the terminal and editor, it can read and modify files, navigate an entire codebase, and understand the global context of the project. Not just responding to a copy-pasted snippet in a chat window.

In practice, when I have an idea, I ask it to structure the project and challenge my choices. And to be clear: I challenge it too. 😄 I sometimes disagree with its suggestions, and that's often where the conversation becomes interesting. It's a tool, not an oracle.

Perplexity — My reference for research

Perplexity is my main tool when I need a reliable and verifiable answer. It's a response engine that systematically cites its sources — you ask a question, it answers with excerpts from real web pages and direct links. No more hallucinations without references.

However, I use it almost exclusively on desktop. On smartphone, it's flooded with messages pushing the paid version. Understandable from their side, but frankly annoying when you just want to do a quick search. 🙄

Gemini — For those in the Google ecosystem

Gemini is Google's AI, and its main advantage is integration with Gmail, Docs, Drive, Sheets, and Google Search. I have a Google Pixel, and on that side, it does integrate very well with its own ecosystem. It's practical for analyzing documents or getting a quick summary without leaving the interface.

That said, in terms of responses, it sometimes falters. 😬 Not systematically, but regularly enough that I stay on guard. And if privacy is a priority for you, it's worth thinking twice before entrusting it with your documents — I talk about this in my article on securing yourself on the Internet.

ChatGPT — The natural entry point

ChatGPT by OpenAI is the most known and most versatile AI. Writing, code, analysis, translation, summary, creativity... it does a bit of everything, often very well. The free version (GPT-4o mini) remains capable for most common uses. It's also the easiest AI to get started with if you're a beginner.

Personally, I don't really buy into it. The main reason? OpenAI's partnership with the Pentagon, which triggered a big wave of uninstallations and boycotts. This is not a technical controversy — it's a question of ethics and values. The idea that "consumer" AI could be used in a military context raises legitimate questions that each person must decide for themselves.

Also note: by default, your data may be used to improve the models — check in the settings.

Quick comparison

My opinion at the time of writing this article — subject to change.

Criterion	Perplexity	Claude Code	Gemini	ChatGPT
Sourced web search	✅ Excellent	❌ Limited	✅ Good	⚠️ Hallucinates
Development / Code	⚠️ Basic	✅ Excellent	⚠️ Correct	✅ Good
Ecosystem integration	❌ None	❌ None	✅ Google	❌ None
Mobile usage	⚠️ Subscription	✅ Correct	✅ Pixel native	✅ Good
Privacy	✅ Correct	✅ Correct	⚠️ Check	⚠️ Check
Free access	✅ Limited	✅ Limited	✅ Yes	✅ Limited
Ideal for beginners	⚠️ Oriented	❌ CLI	✅ Yes	✅ Yes

Which AI to choose based on your profile?

There is no universal answer. The right question is: what do you do most often?

You look for reliable info with sources → Perplexity (on desktop preferably)
You code or develop projects → Claude Code
You work in Google Workspace or have a Pixel → Gemini
You want to do everything without hassle → ChatGPT
You want to protect your privacy → Claude or Perplexity

And don't hesitate to combine several. Personally, I use Claude Code for dev, Perplexity on desktop when I need a sourced answer, and Gemini for anything related to my phone or Google Workspace.

Frequently asked questions

What is the best free AI in 2026?

Claude offers a solid reasoning level even without a subscription. Perplexity is better for sourced searches. ChatGPT remains an accessible option, but with the reservations mentioned above.

Can you use multiple IAs at the same time?

Yes, and it's often the best strategy. Use Perplexity for research, Claude Code for dev, and ChatGPT for writing for example. Each tool has its domain of excellence.

Are IAs safe for personal data?

It depends on the provider and your settings. By default, most use your data to improve their models. Always check privacy settings. To go further: secure yourself on the Internet (FR).

ChatGPT or Claude: which one to choose?

For code, long reasoning, and creativity → Claude. For dev integrated into the terminal → Claude Code. For sourced searches as a complement → Perplexity. ChatGPT remains a consumer option, but personally I do without it.

Conclusion

IAs are not interchangeable, and none is perfect. Each has been optimized for certain uses, with its own trade-offs — technical, ethical, and practical. What makes the difference is choosing the right tool for the right task, rather than relying on a single one for everything.

My current combo: Claude Code for dev, Perplexity on desktop for sourced searches, and Gemini for anything related to my Pixel. ChatGPT, I'm leaving aside for now — the reasons are mentioned above, and my opinion can change.

What I think of these tools today may not be true in six months. IAs advance quickly, models change, policies too. I'll update this article if needed.

And you, what do you use daily? Do you combine several or do you stay loyal to just one? Tell me on Discord or on social networks! 💬

Go further

Some of my articles, including this one, may have been AI-assisted to help me better structure or rephrase my ideas. Opinions remain my own.

My summary of 2025 as an IAM consultant and non-web developer

Thomas Bonnet — Thu, 01 Jan 2026 00:10:05 +0000

This year marks a big change in my life.

I originally taught myself web development and many other aspects of the field. At the beginning of the year, I stopped working as a freelance web developer at my web agency, Concept'Web.

I then started a new job as an IAM consultant in cybersecurity. When I began, I didn't feel I had enough knowledge to fully make it my full‑time job, and I struggled for several months. But things are now going much better: I feel more confident, I'm learning a lot every day, and I genuinely love what I do. It's a big shift from web development, which I hardly practice anymore. I contribute much less to open source and side projects (which is a bit sad, but mostly a matter of time), though I still maintain a few of them, including my personal website and a Discord bot that helps eliminate cyberbullying.

If you're curious about what I wish for this new year, you can read it here:

Thomas Bonnet

Jan 7 '25

2025, me voilà ! 🥳

#devchallenge #newyearchallenge #career #opensource

2 min read

Outside of work, I also had a lot of fun shipping several updates to my biggest Discord bot project. I notably improved my filter against insults and other offensive language, including homophobia, transphobia, conflicts, sexual content, and degrading comments. I'm very happy with how it's evolving, and I'm proud of the impact it can have on online communities.

My DEV Wrapped

Share us your project for Hacktoberfest 2025! 🎃

Thomas Bonnet — Sun, 05 Oct 2025 13:00:44 +0000

Last year:

Hacktoberfest: Maintainer Spotlight

Thomas Bonnet

Oct 2 '24

Share us your project for Hacktoberfest 2024! 🎃

#discuss #hacktoberfest #opensource #webdev

1 min read

📅 When is it happening?

From October 1st to October 31st.

👥 Who can join?

Contributors, maintainers, companies, and event organizers!

🚀 How to participate?

Throughout October, take part by contributing to Open Source and submitting 6 Pull or Merge Requests on GitHub or GitLab.

You can keep track of your progress on the Hacktoberfest dashboard.

✨ New this year: After 6 valid Pull Requests (previously 4), you will earn an exclusive Hacktoberfest T-shirt!

More details are available on the participation page.

✨ This year, I also want to know what projects you’re running that need contributors!

Feel free to share your repositories in the comments using the embed format below:

{% embed https://github.com/thomasbnt/devtoprofile %}

💚 Open Source

For more posts, check out the Hacktoberfest tag

#hacktoberfest Follow

Happy hacking! 🎃

Best tips to learn music?

Thomas Bonnet — Sun, 03 Aug 2025 16:05:41 +0000

Hello, I have the Minilab 3 from Arturia

And I would learn more with Ableton Live 12 Lite, what is your best tips?

Installing Pi-hole with an LCD screen

Thomas Bonnet — Sun, 03 Aug 2025 16:02:03 +0000

I had already made an article on Pi-hole a few years ago, this one adds the fact that there is an LCD screen.

Thomas Bonnet

Aug 14 '18

Setup your Pi-hole

#opensource #raspberrypi #pihole #privacy

2 min read

In this article, we will discover how to install Pi-hole with an LCD screen.
The reference of the screen is XPT2046 Touch 3.5" RPI Display 480x320 16bit.

Introduction

We will install Pi-hole on a Raspberry Pi 3B.

pi-hole.net

Pi-hole is used to block unwanted requests and URLs that you don't want to load on the network.
It protects you from trackers and optimizes your network traffic.

Installation

1. Prepare Raspbian

First, flash your SD drive from Etcher or another application.

Wait a few minutes until the disk is ready.

2. Update the dependencies

Connect to your Raspberry Pi and update the dependencies.

sudo apt-get update -y && sudo apt-get upgrade -y

Wait a good few minutes... in the meantime, drink a good cappuccino. ☕

Install curl and git if this is not available on your small machine:

sudo apt-get install curl -y && sudo apt-get install git -y

3. Install Pi-hole

Then, when everything is good, you can start installing Pi-hole.

You can clone from the Pi-hole repository or directly curl with this command:

curl -sSL https://install.pi-hole.net | bash

When asked if you want to install on your Raspberry and put in static IP, check yes, and remember the IP.

Then choose your preferred DNS. You can put more than one if you want. This is editable after installation.

You can select block lists:

✨ I actually have a huge list with over 1,000,000 blocked domains/IPs. The repository of this list on GitHub. Feel free to add your own domains/IPs.

It will also ask you if you want a web panel.
I strongly recommend that you leave it enabled so that you can connect to the Raspberry Pi with a password and manage your DNS/blacklist and view your statistics.

4. Configuring the web panel

As soon as you have finished installing Pi-hole, it will give you the local host address and the generated password.

To change the password :

sudo pihole -a -p

This is a preview of the panel when you are logged in 🎉

Setting up the LCD screen

The most complicated part is here!
There may be some things I've written that don't work for you, or that aren't essential to do.

1. Install the LCD screen on the Raspberry Pi

Simple part to do, just put the Display on the branches of the RPI.
I found a YouTube video that shows you how to position it.

2. Install PADD

PADD is a software that allows you to see the data transmitted by Pi-hole on your screen.

The project has been taken over by Pi-hole, and even if there are some errors, it is still usable.

To install it and make it executable :

cd ~
wget -N https://raw.githubusercontent.com/pi-hole/PADD/master/padd.sh
sudo chmod +x padd.sh

Make PADD run when the RPI is launched:

# Run PADD
# If we're on the PiTFT screen (ssh is xterm)
if [ "$TERM" == "linux" ] ; then
  while :
  do
    ./padd.sh
    sleep 1
  done
fi

If you wish, you can test the script and view it from your terminal:

./padd.sh

This gives:

After you have done everything, you need to reboot your machine.

3. Make the screen turn off at night.

On the PADD wiki, they show you how to make the screen turn off at night. The script works with cron, to modify it, do sudo crontab -e :

# PiTFT+ SLEEPY TIME
# Turn off the PiTFT+ at midnight
00 00 * * * sh -c 'echo "0" > /sys/class/backlight/soc\:backlight/brightness'
# Turn on the PiTFT+ at 8:00 am
00 08 * * * sh -c 'echo "1" > /sys/class/backlight/soc\:backlight/brightness'

Possible mistakes

During my installation, I had a few errors, including one where the screen would not turn on.
So I forced him to do it with Adafruit.

A. Installation of Adafruit

Let's already install the prerequisites:

sudo apt-get install python3-pip -y

Then Adafruit from the GitHub repository :

cd ~
git clone https://github.com/adafruit/Raspberry-Pi-Installer-Scripts.git

And finally, we will install Adafruit :

cd Raspberry-Pi-Installer-Scripts
sudo python3 adafruit-pitft.py --display=35r --rotation=90 --install-type=console

This script will modify /boot/config.txt to make adafruit-pitft run when the RPI is launched.

See how to do it manually

sudo nano /boot/config.txt

Insert at the end:

[all]
hdmi_force_hotplug=0
dtparam=spi=on
dtparam=i2c1=on
dtparam=i2c_arm=on
dtoverlay=pitft35-resistive,rotate=90,speed=20000000,fps=20
dtoverlay=piscreen,speed=16000000,rotate=90

B. Invalid number" errors

If you get this kind of error on your screen:

/home/pi/padd.sh: line 900: printf: 0,3: invalid number
/home/pi/padd.sh: line 244: printf: 42,236: invalid number
/home/pi/padd.sh: line 873: printf: 9,1: invalid number
/home/pi/padd.sh: line 900: printf: 0,91: invalid number

Leave the local of the Raspberry Pi on en_GB.UTF-8,
an issue is in progress and therefore displays errors on the Display. (View issue on GitHub)

Sources:

☕	Check my Twitter account. You can see many projects and updates. You can also support me on Buy Me a Coffee, Stripe or GitHub Sponsors. Thanks for read my post ! 🤩

Why choose DuckDuckGo as a search engine?

Thomas Bonnet — Fri, 20 Jun 2025 20:26:52 +0000

Introduction

For years, I've been testing all kinds of search engines: Google, Bing, Qwant... but nothing really convinced me in the long run. Between data collection, targeted ads, and the feeling of being constantly watched, I eventually got tired of it. So I decided to switch to DuckDuckGo, and frankly, I don't regret it.

My experience with DuckDuckGo

The first thing that struck me was the simplicity of the interface. No frills, no useless widgets, just a search bar and you're good to go. I like this minimalist approach: it gets straight to the point and loads quickly, even on an old PC or with a weak 4G connection.

But the real selling point is privacy. DuckDuckGo doesn't track me, doesn't store my history, and doesn't bombard me with personalized ads all the time. I can search for whatever I want without feeling like the entire web knows my interests. It feels good, seriously.

Another nice thing: the results are the same for everyone. No “filter bubble” where you're only shown what you want to hear. Here, there's no excessive personalization, everyone starts on an equal footing. It makes a difference, and sometimes allows me to come across sites that I would never have seen with Google.

!bang commands: a real game changer

Honestly, I didn't expect to use the !bang commands so much, but it's clearly become a reflex. For those who don't know, just type an exclamation point followed by a shortcut to search directly on a specific site, without going through the site's home page.

Here are a few examples that I use all the time:

!w to search directly on Wikipedia (example: !w Toulouse)
!yt for YouTube (!yt powershell tutorial)
!gh for GitHub (!gh automation script)
!g for Google (!g baguette)
!dpl for Deepl (!dpl how to fix a bug)

There are hundreds of them, for almost all known sites. It's super handy, saves a ton of time, and frankly, once you get used to it, you can't do without it.

Of course, it's not perfect. Sometimes the results are a little less accurate than on Google, especially for very local or highly specific searches. But honestly, for 95% of my needs, it does the job. And I'd rather sacrifice a little convenience for peace of mind.

Conclusion

In short:

Privacy respected, no data collection
Simple and fast interface, without overload
Neutral results, identical for everyone
Fewer intrusive ads
Practical features such as !bang, which are truly indispensable

I'm not saying that DuckDuckGo is perfect, but for me, it's the best compromise between efficiency and privacy. If you're tired of being tracked everywhere on the web, it's definitely worth a try.

What search engine do you use? Have you tried DuckDuckGo yet? Let me know what you think on Discord or social media!

WeCoded is back!

Thomas Bonnet — Wed, 05 Mar 2025 15:20:51 +0000

Jess Lee for The DEV Team

Mar 5 '25

Join Our First-Ever WeCoded Challenge – Celebrating Underrepresented Voices in Tech Through Stories & Code!

#devchallenge #wecoded #dei #career

165

4 min read