Nicola Rizzo

Automating Anki Deck Creation with LLMs

Wed, 30 Jul 2025 00:00:00 +0000

Creating high-quality Anki flashcards manually can be time-consuming, especially when dealing with large amounts of content. I’ve developed a workflow that leverages Large Language Models (LLMs) to automate much of this process, making it significantly more efficient while maintaining quality control. The key to this approach is providing clear, detailed prompts that guide the LLM’s output. An example of a part of the prompt I use to define the rules that LLMs should follow to create, complete or fix my cards:

French-Italian Idioms CSV File Rules

This document outlines the structure and formatting rules for the french_idioms_italian.csv file.

File Format

Fields are separated by semicolons (;)

String values containing semicolons, spaces, or special characters are enclosed in double quotes (")

File uses UTF-8 encoding to support special characters

Columns The CSV contains the following columns in order:

French Expression - The complete French idiom

French Definition - The meaning of the idiom in French

Italian Translation - The equivalent idiom in Italian

Example1 - A complete sentence using the idiom with the full expression visible (not masked)

PartialCloze1 - A sentence where only the beginning of the idiom is masked with [...]

Example2 - A second complete sentence using the idiom with the full expression visible (not masked)

PartialCloze2 - A sentence where only the ending of the idiom is masked with [...]

FullCloze - A sentence where the entire idiom is masked with [...]

Register - The formality level of the idiom (Neutre, Informel, Familier)

Cloze Test Rules

[...] is used as the placeholder for masked portions of text

PartialCloze1: Masks the beginning of the expression, keeping the ending visible

PartialCloze2: Masks the ending of the expression, keeping the beginning visible

FullCloze: Masks the entire expression

All cloze examples must maintain grammatical correctness and natural flow

Example sentences should provide sufficient context to infer the missing expression

Use completely different sentences for different fields (Example1, Example2, PartialCloze1, PartialCloze2, > FullCloze) to provide varied contexts

I use placeholders ("[…]") and not cloze card types because I think it’s not possible to create cloze cards AND front/back cards in the same note.

I use CSV files as intermediate files to interact with the content of the decks. I’ve tried to use an MCP server (that I wrote using Claude Code, the MCP TypeScript SDK and the Anki Connect API specification) to connect LLMs to Anki Connect API and it works well, but it’s slow if you interact with thousands of notes. I prefer using LLM to create a Python script that loads the complete CSV file into the deck using the Anki Connect API.

I use LLMs also to reflect on card types: how to structure them? Which fields should be shown in front? Which ones in back? How to style them? Unfortunately, at the moment, Anki Connect does not allow creating or editing card types, so I had to create/edit the card types by hand.

It’s obviously an iterative process, but using LLM to create Anki decks is, by far, more productive than doing it by hand. I start, for example, by listing French expressions in a new CSV file:

1
2
3


French Expression
prendre le taureau par les cornes
chercher une aiguille dans une botte de foin

and then I ask an LLM to add a new column, French Definition for example, following the rules I listed above. When I’ve verified a sample of the results, I add the other columns, one by one. And at the end I use the Python script written by the LLM to create a new deck.

Notes on A Tour of Webauthn

Wed, 30 Jul 2025 00:00:00 +0000

This is a Work In Progress (WIP).

A Tour of WebAuthn

Problems of passwords:

too little entropy to resist brute-forcing
password database leaks => hacker can sign in to the site AND credential stuffing
vulnerable to phishing
they can leak from many other parts of the software stack (e.g. logging, Javascript-injection attack => exfiltration)

U2F and Webauthn are systems of authentication based on public key signature schemes, like ECDSA, RSA, ML-DSA.

Abstractly, a public key signature scheme provides three operations:

$$ \text{generate}: \text{random_bits} \mapsto (\text{public_key}, \text{private_key}) $$

$$ \text{sign}: (\text{private_key}, \text{message}) \mapsto \text{signature} $$

$$ \text{verify}: (\text{public_key}, \text{message}, \text{signature}) \mapsto \text{boolean} $$

There are also some properties:

it’s impossible to compute the private key from the public key
it’s impossible to compute a signature without the private key

Simple authentication schemes using public key signature:

sequenceDiagram
participant User
participant Computer
participant Website
User->>Computer: Enter username
Computer->>Computer: Run sign(privateKey, "let me in") → signature
Computer->>Website: Send {username, signature}
Website->>Website: Retrieve stored publicKey for username
Website->>Website: Run verify(publicKey, "let me in", signature)
alt signature valid
Website->>User: Sign-in successful
else signature invalid
Website->>User: Sign-in denied
end

2025 - Week #28

Thu, 10 Jul 2025 00:00:00 +0000

A Framework for Understanding AI Companies

AI companies can be categorized into three distinct groups:

Model companies focus on developing and training large language models and foundation models.
Infrastructure companies build the tools, platforms, and services that enable AI development and deployment.
Application companies create end-user products and services powered by AI.

This framework is helpful for understanding how different players in the AI ecosystem create value.

Sources:

The Pragmatic Engineer podcast episode with Janvi Kalra
“AI Engineering” by Chip Huyen

The Four Pillars of Product Discovery

Product discovery should systematically address four critical risks:

Value risk: customers will actually buy or use what you’re building?
Usability risk: users can figure out how to use your product effectively?
Feasibility risk: your team can actually build the solution?
Business viability risk: the solution makes sense for your business model and constraints?

Source: chapter 33 of “Inspired” by Marty Cagan, which provides a clear framework for de-risking product development before significant investment.

Understanding Temperature in Language Models

Language models work by predicting the next token in a sequence of text. They calculate probability distributions across their entire vocabulary to determine what comes next.

For example, after “Hi! How are you?” the model might predict “Hi” with 70% probability, “Hello” with 15%, “Fine” with 5%, “Why” with 0.4%, and so on.

The challenge is choosing which token to present to users—a process called sampling. Greedy sampling simply picks the highest probability token (“Hi” in our example). Probabilistic sampling follows the calculated distribution, presenting “Hi” 70% of the time, “Hello” 15% of the time, and so forth.

The temperature parameter adds flexibility to probabilistic sampling by redistributing these probabilities. Higher temperatures increase the likelihood of rarer tokens, producing more creative and varied responses. Lower temperatures favor the most probable tokens, creating more consistent and predictable outputs.

Source: Chapter 2 of “AI Engineering” by Chip Huyen

What I’m Listening To

The Pragmatic Engineer: From Software Engineer to AI Engineer – with Janvi Kalra

What I’m Reading

How to evaluate model, infrastructure, and product companies in AI by Janvi Kalra
I Shipped a macOS App Built Entirely by Claude Code by Indragie Karunaratne
AI Engineering by Chip Huyen. I started reading this book this week, and it appears to be an excellent introduction to the world of large language models, providing practical guidance for using these tools more effectively
Inspired by Marty Cagan
Deploy Empathy by Michele Hansen
Holly by Stephen King. I finished reading it this week. Personally, I preferred Fairy Tale and 11/22/63, the two other books I’ve read by this author. While it’s not a bad book—it’s a page-turner like the others—it explores different compelling themes, particularly evil and aging.

What I’m Working On

I’m continuing the development of my macOS app that lets users chat with multiple LLM providers. Following Indragie Karunaratne’s inspiring post, I’m building it using also Claude Code.

Using AI agents has improved my productivity in ways that are hard to appreciate without direct experience. The quality of Claude Code often impresses me, though success requires following best practices to avoid getting stuck in unproductive cycles (for example: Claude Code - Best practices).

2025 - Weeks #29, #30, #31

Thu, 10 Jul 2025 00:00:00 +0000

What I’m Listening To

What I’m Reading

Encrypting Files with Passkeys and age, by Filippo Valsorda
A Tour of WebAuthn, by Adam Langley. I’m taking some notes here

What I’m Working On

I’m using LLM to help me creating two Anki decks:

English collocations
French idiomatic expressions

You can read some notes about how I use AI with Anki here.

2025 - Week #27

Thu, 03 Jul 2025 00:00:00 +0000

What I’m listening

Startups for the Rest of Us - Episode 781

Podcast episode page

In this episode, Rob Walling talks about mistakes has done during his founder’s career. I’ve found some interesting points in the episode. I would like to focus on one point in particular here.

Mistake #5: “Trying to do everything solo”

Rob had tried to do everything without hiring full-time employees; firstly completely alone, and later with some contractors, but he says:

There was no loyalty and there was no cohesion. The contractors didn’t even really know each other, so it was barely a team. And the approach wound up sucking because my entire job was managing contractors, managing projects, assigning things, checking on things, and it’s like it’s not fun […] I don’t want to just be a paper pusher in essence or a project manager. I want to actually get s**t done with ambitious people who really want to build something incredible

Using his words, he had hired “task level thinkers”, but he needed also “project level and owner level thinkers”. He developed this concept in the episode #551 of his podcast.

About task level thinkers, he says:

For years, I operated with task-level thinkers, and I was happy […] These are folks who were doing design work, folks who were doing administration, folks who were doing email support, developers […]

About project level thinkers, he says:

But what I realized is I was then doing all the owner-level thinking which was longer-term stuff, and the project-level thinking which was this project needs—this is project management—seven things to happen, so now I get to manage all those people […] I hired a couple of people who were more project-thinkers. I can hand an entire project and they would then either manage the resources for me or they could do the whole thing themselves […].

About owner level thinkers, he says:

[…] after we were acquired […] I started seeing folks working inside a company who were not the C-suite, they were not owners, they were not founders of the company, but they really owned an entire segment and they thought creatively around it. So someone who’s a marketing strategist who ran this whole team of people, wasn’t just thinking about projects. Actually, each of his people have their own projects, but he was thinking long-term, what do we need to do in 12–18 months? Coming up with new ideas, listening to the audio books, listening to the podcast, reading the books, and being what I call an owner-level thinker where it’s not about the equity that he owned but it was about ownership of the the results […] from the vision to the implementation, and working with the team to do it.

What I’m reading

Inspired, by Marty Cagan. This is a book full of useful information for anyone interested in tech product management
Deploy Empathy, by Michele Hansen. The go-to resource for customer interviewing
Holly, by Stephen King. Reading a fiction book every now and then is not a bad idea

What I’m working on

My Substack newsletter
A (closed-source, sorry folks) MacOS app where users can chat with multiple LLM providers using an OpenRouter key. It’s my first MacOS app and I’m learning a ton. I’m using the same approach that Mitchell Hashimoto is using with his terminal, Ghostty. He details the idea in his blog. He’s using Zig, I’m using Go.

About me

Wed, 09 Aug 2023 00:00:00 +0000

Hi! I’m a software developer. I live in Italy. I’m currently working as a remote co-lead dev contractor for a French company, Helfrich (advanGO project).

Mastodon: https://hachyderm.io/@nicolarizzo (@nicolarizzo@hachyderm.io)
LinkedIn: https://www.linkedin.com/in/rizzonicola/
GitHub: https://github.com/nicolanrizzo
Send me an email: heavy.plan1680 at fastmail dot com

WIP - Work In Progress in my blog

Tue, 08 Aug 2023 00:00:00 +0000

In my blog I prefer to share as soon as possible what I’m working on and what I’m writing about. When there is a small amount of value in what I’m writing, I don’t wait to end it to publish it. Obviously these WIP (Work In Progress) pieces could be incomplete (duh!), not entirely correct (waiting factchecking), and/or readable (waiting editing).

I use this Hugo shortcode

1

{{% wip %}}

to include WIP sections in my posts. This shortcode corresponds to this rendered section:

This is a Work In Progress (WIP).

I’ve also found a simple solution for a problem in the RSS feed: when I’m working on a WIP piece I dont’t want to send an RSS item for every single editing, but I would like to create a new RSS item after an important update. To do that, I use the guid tag (https://www.rssboard.org/rss-specification#ltguidgtSubelementOfLtitemgt) in the RSS Hugo template:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
 <channel>
 <item>
 <!-- ... -->
 {{ if (not (.Params.rssGuid)) }}
 <guid>{{ .Permalink }}</guid>
 {{ else }}
 <guid>{{ .Params.rssGuid }}</guid>
 {{ end }}
 <description>{{ .Content | html }}</description>
 </item>
 <!-- ... -->
 </channel>
</rss>

and in the frontmatter of the WIP post I write:

1
2
3
4


---
# ...
rssGuid: f0632b25-fb5c-404c-977c-c0e7f17f1afb
---

I use UUIDv4 for the rssGuid. When I want to send an update to my RSS feed followers, I generate a new UUID and remplace the value in the rssGuid parameter.

A double RSS item (Published writers' notebooks) in my feed after changing the guid value

Compile and load SQLite extensions

Sat, 05 Aug 2023 00:00:00 +0000

How to compile the UUID extension:

1
2
3
4
5
6
7


wget https://www.sqlite.org/src/tarball/sqlite.tar.gz
tar xzf sqlite.tar.gz
mkdir bld
cd bld
../sqlite/configure
make
gcc -g -I. -fPIC -dynamiclib ../sqlite/ext/misc/uuid.c -o uuid.dylib

Run the sqlite3 command-line program:

1

./sqlite3

Try to use the UUID extension without loading it:

1
2
3
4


sqlite> select uuid();
Parse error: no such function: uuid
 select uuid();
 ^--- error here

Load the UUID extension and use it:

1
2
3


sqlite> .load ./uuid
sqlite> select uuid();
945ef12d-f428-4b8a-831c-3a2fbe7c60b4

Tested on an Intel Macbook Pro.

Source: https://stackoverflow.com/a/61850934

Essays One, by Lydia Davis

Sat, 05 Aug 2023 00:00:00 +0000

This is a Work In Progress (WIP).

Recommended books by the author

Chapter “Thirty Recommendations for Good Writing Habits”

“The 3 A.M. Epiphany”, by Brian Kiteley (a book of writing exercises for fiction writers)
“Works and Days”, by Bernadette Mayer (a diary, with brief entries in prose and poetry from April into June)
“My Struggle” by Karl Ove Knausgård (Norwegian author) (a series of six autobiographical novels)
“Artful Sentences: Syntax as Style” by Virginia Tufte
“Autobiography of Red”, by Anne Carson (a narrative poem)
“Death in the Family”, by James Agee
“The Autobiography of an Unknown Indian”, by Nirad C. Chaudhuri
“Let Us Now Praise Famous Men”, by James Agee
“A House for Mr. Biswas”, by V. S. Naipaul (notable for its descriptions)

Other recommended authors

How to create tables with primary key UUID columns in SQLite

Sat, 05 Aug 2023 00:00:00 +0000

After loading the UUID extension, in SQLite you can create tables with a UUID primary key with an automatic value defined by its default value:

1
2
3


create table my_table (
 uuid blob primary key default(uuid_blob(uuid())),
);

Something like autoincrementing for UUID columns.

Published writers' notebooks

Sat, 05 Aug 2023 00:00:00 +0000

This is a Work In Progress (WIP).

The Weight of the World, by Peter Handke (even if he’s a controversial writer)
Virginia Woolf (A Writer’s Diary, Diaries)
The Diaries of Franz Kafka
Journal de Eugène Delacroix (in French, “The Journal of Eugène Delacroix” in English. Yeah, he’s an artist, not a writer, but his notebook is interesting)
Zibaldone di pensieri, by Giacomo Leopardi (in Italian)
The Unabridged Journals of Sylvia Plath

Automating PDF Table of Contents Creation Using AI and PDFtk

Sat, 25 Feb 2023 00:00:00 +0000

Adding a Table of Contents (ToC) to a PDF file can be a tedious process, but with the right tools, it can be almost automated. In this guide, we’ll use AI to generate the ToC entries from images and PDFtk to integrate them into the PDF.

Step 1: Create a CSV File Containing the Table of Contents Entries

To generate the ToC entries, we can use AI to extract them from images of the book’s table of contents. Use a prompt like the one below:

You are a system that, given an image of part of a book’s table of contents, extracts the data and tabulates it. The columns are:

level (1 for chapters, 2 for sections)
page (for chapters, use the page of the first section)
title

The output must be the contents of a CSV file.

Do not respond with anything other than the contents of the CSV file. All provided images must be tabulated without asking for confirmation.

Customize the prompt as needed and send it to an AI model along with images of the book’s table of contents. The AI will return structured text, which you can save as a CSV file.

Step 2: Check and Clean the CSV File

Before converting the CSV file to a format suitable for PDFtk, review the extracted data. Ensure that:

The page numbers are correct.
The section titles are properly formatted.
There are no missing or extra entries.

Step 3: Convert CSV to PDFtk Table of Contents Format

Once the CSV file is cleaned, convert it into the format required by PDFtk using the following Python script:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import csv

# Define the path to your CSV file and the output text file
csv_file = 'bookmarks.csv'
output_file = 'bookmarks.txt'

# Open the CSV file and read the content
with open(csv_file, newline='', encoding='utf-8') as file:
 reader = csv.reader(file)

 # Open the output text file in write mode
 with open(output_file, 'w', encoding='utf-8') as output:
 # Loop through each row in the CSV file
 for row in reader:
 # Extract title, page number, and bookmark level
 title = row[0]
 page_number = row[1]
 bookmark_level = row[2]

 # Write the formatted bookmark information to the text file
 output.write(f"BookmarkBegin\n")
 output.write(f"BookmarkTitle: {title}\n")
 output.write(f"BookmarkLevel: {bookmark_level}\n")
 output.write(f"BookmarkPageNumber: {page_number}\n")

print(f"Bookmarks have been written to {output_file}")

This script transforms the structured CSV data into a format that PDFtk can interpret for adding bookmarks to the PDF.

Step 4: Extract Data from the PDF File Using PDFtk

To integrate the Table of Contents, first extract the existing PDF metadata with the following command:

1

pdftk input.pdf dump_data_utf8 > in-utf8.info

This will produce a file containing the metadata of the PDF, which we will modify in the next step.

Step 5: Edit the PDFtk Data File

Open the extracted data file and insert the Table of Contents entries obtained in Step 3. Ensure that:

The entries are properly structured.
They align with the correct page numbers.
The hierarchy is maintained (if applicable).

Step 6: Generate the Final PDF with the Table of Contents

Finally, apply the modified data file to the original PDF using the following command:

1

pdftk input.pdf update_info_utf8 in-utf8.info output out.pdf

This will create a new version of the PDF with the Table of Contents integrated.

How to improve performances for SQL queries with IN and thousands of values

Wed, 09 Nov 2022 00:00:00 +0000

Today I’ve had to optimize an SQL query with this structure:

1
2
3


SELECT ...
FROM ... tbl
WHERE tbl.id IN (435, 3456, 77432, ...) -- thousands of values here

A very simple query, but having thousands of values after IN causes very bad performances.

Some Internet searches have allowed me to find an equivalent query to do that, but faster:

1
2
3
4
5
6


CREATE TEMPORARY TABLE tmp (id INT NOT NULL, PRIMARY KEY (id));
INSERT INTO tmp (id) VALUES (435), (3456), (77432), ..... -- thousands of values here
SELECT ...
FROM ... tbl
INNER JOIN tmp ON tmp.id = tbl.id;
DROP TABLE tmp; -- optional, it depends on following requests

I’ve had to create a temporary table and insert into it all IDs and INNER JOIN it. Optionally, you can drop the table after the request, but the table lives only during the session anyway.

About SVGs flexibility: dark mode

Mon, 07 Nov 2022 00:00:00 +0000

As an owner of a cheap Wacom tablet, it’s quite simple for me to create “handmade” SVG files using, for example, a vector graphics editor, like Inkscape, Adobe Illustrator or Affinity Designer. After creating the file, with a text editor or IDE you can open it and read its code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg
 width="100%"
 height="100%"
 viewBox="0 0 516 517"
 version="1.1"
 xmlns="http://www.w3.org/2000/svg"
 xmlns:xlink="http://www.w3.org/1999/xlink"
 xml:space="preserve"
 xmlns:serif="http://www.serif.com/"
 style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">

 <path d="M176.207,107.015c2.995,..."/>

 <path d="M180.577,208.347c6.706,-20.119 13.374,..."/>

 ...
</svg>

It turns out that you could change this code and adapt to your needs. For example, you can style it to adapt its color according to the dark mode option:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


<svg>
 <style>
 path {
 fill: black;
 }
 body.dark path {
 fill: white;
 }
 </style>

 <path
 d="..."
 fill="currentcolor"
 />
<!-- ... -->
</svg>

In this code snippet, the CSS class dark is the class I use to activate the dark mode in the body.

The same SVG file with the dark mode option enabled and disabled

Document your project adding Sphinx to docker-compose.yml

Mon, 02 Sep 2019 12:00:00 +0000

I strongly believe that a web application project has to be thoroughly documented. And that’s more important for larger and longer project, where developers come and go in an unstoppable turnover that risks to slow down the project. A documentation is the only chance for new developers to become rapidly productive.

But how we, as developers, can document a project? What tools exist out there that can facilitate this task? Well, there are dozens of tools. One of them is Sphinx, the Python Documentation Generator. This library can be used to document everything you want. You can think it as a static site generator, like Jekyll, Hugo or Gatsby, but more oriented to technical documentation. You can host it somewhere, like on the Read The Docs, or keep it locally. In this article I will explain how to use it locally with a project already using Docker Compose.

The Dockerfile

Let’s begin writing a simple Dockerfile for Sphinx:

1
2
3
4
5
6
7
8
9


FROM alpine:latest
WORKDIR /etc/
RUN mkdir -p /etc/Sphinx/build

RUN apk add --no-cache python3 make git
RUN pip3 install git+https://github.com/sphinx-doc/sphinx && \
 pip3 install sphinx-autobuild

CMD sphinx-autobuild -b html --host 0.0.0.0 --port 80 /etc/Sphinx/source /etc/Sphinx/build

Here, after using the latest Alpine image and creating some folders, I install some dependencies (python3, make, git); after that, I install sphinx and its autobuild. The Sphinx-autobuild project automatically rebuild the documentation after a change in the documentation folder is detected, and it works like a charm also with Docker. With its livereload web server, this library serves also the documentation web page, allowing you to access to the documentation with a browser visiting a URL like http://localhost:8100.

The docker-compose.yml file

Let’s add now a service to the docker-compose.yml already used in the application project:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


version: "3"

# ...
services:
 # ...
 service_doc:
 container_name: service_doc
 build: docker/doc
 volumes:
 - ./doc:/etc/Sphinx/source
 ports:
 - 8100:80
# ...

The folder structure of the project is something like:

.
├── doc
├── docker
│ └── doc
│ └── Dockerfile
└── docker-compose.yml

I’ve defined a volume in the folder ./doc, where there will be the documentation folders and files. The Sphinx Dockerfile presented above is in the folder ./docker/doc and the docker-compose.yml is in the root folder. The URL to use to visit the documentation is http://localhost:8100.

The Sphinx quickstart

I can now run the command:

1

docker-compose up -d

With this command, I’ve created a container with Sphinx. To continue, I have to create a configuration file, conf.py, in the folder ./doc. To do that, I’ve run the following command in the container (after running docker-compose exec service_doc /bin/sh):

1

sphinx-quickstart

After answering some questions about my project, the command generates some files. I’ve moved the autogenerated conf.py and index.rst in the /etc/Sphinx/source folder in the container:

1
2


mv conf.py /etc/Sphinx/source
mv index.rst /etc/Sphinx/source

Writing the documentation using Sphinx

We can now access the (empty) documentation at http://localhost:8100. If we try changing the index.rst file, after some seconds the browser auto refresh to show the updated documentation. Following the Sphinx documentation site you can now document your project using Sphinx.