Venez à bout de votre liste de tâches grâce aux nouvelles fonctionnalités des forfaits IA de Google : un guide pratique

Cochez votre liste de tâches avec les nouvelles fonctionnalités des offres Google AI : un guide pratique

Le 9 septembre 2026, le blog IA de Google a publié un billet intitulé « Tackle your to-do list with new features in our Google AI plans. » Ce titre est la prémisse de cet article — et il constitue aussi, délibérément, la quasi-totalité des affirmations que je suis prêt à faire sans réserve. J'ai vérifié que la source primaire existe et est accessible publiquement à l'URL ci-dessous. Je n'ai pas vérifié les noms de fonctionnalités, les tarifs, les déploiements régionaux ni les identifiants de modèles ; aucun de ces éléments n'apparaît donc ici.

Ce qui suit est donc un article de préparation plutôt qu'un récapitulatif d'annonce. Si la gestion des tâches migre vers les offres d'abonnement IA de Google, le travail utile que vous pouvez faire aujourd'hui n'est pas de rafraîchir un journal des modifications. C'est de construire le tissu conjonctif autour de vos données de tâches — extraction, normalisation, déduplication, revue — afin que les fonctionnalités au niveau de l'offre puissent se brancher sur un pipeline que vous possédez déjà. Ce guide vous fournit ce pipeline : exigences, commandes d'installation, script d'extraction fonctionnel, configuration, exemples d'utilisation et garde-fous.

Ce qui est vérifié, et ce qui relève de l'interprétation

Distinguer les deux n'est pas de la pédanterie. C'est la différence entre une intégration fonctionnelle et une autre bâtie sur des hypothèses qui se brisent silencieusement.

Vérifié (niveau de preuve A — une source primaire a été confirmée) :

• Un billet du blog AI de Google existe avec le titre « Tackle your to-do list with new features in our Google AI plans. »
• Son emplacement canonique est https://blog.google/products-and-platforms/products/google-one/fall-2026-ai-plan-updates.
• L'enregistrement source porte un horodatage de 2026-09-09T17:00:00.000Z.

Interprétation, clairement identifiée comme telle :

• Le titre suggère que les capacités liées aux tâches sont présentées comme un avantage des offres d'abonnement IA de Google plutôt que comme des outils autonomes. C'est une lecture raisonnable de la formulation, pas une spécification documentée.
• « Nouvelles fonctionnalités » est au pluriel et non spécifié. Je ne sais pas ce qu'elles sont, comment elles se comportent, ni quelles offres les incluent.

Limites ouvertes :

• La source primaire est un unique billet de blog. Aucune corroboration indépendante n'est disponible pour moi concernant une capacité spécifique.
• Tout ce qui, ci-dessous, fait référence aux API Google décrit l'API Gemini destinée aux développeurs et l'API Google Tasks comme des briques de base génériques. Cela ne signifie pas que les fonctionnalités de l'annonce utilisent ces interfaces.

Considérez le code de cet article comme une infrastructure que vous contrôlez, et non comme l'implémentation d'un ensemble de fonctionnalités non vérifié.

Pourquoi préparer avant l'arrivée des fonctionnalités

La plupart des IA de productivité échouent au même point : le passage entre une entrée non structurée et un système de référence. Vous collez un fouillis de notes dans une fenêtre de chat, récupérez une liste bien ordonnée, puis la copiez manuellement dans un gestionnaire de tâches. L'intelligence n'a jamais été le goulot d'étranglement — la plomberie, si.

Trois propriétés méritent d'être conçues dès maintenant, car elles sont indépendantes de ce que Google publiera :

1. Un schéma de tâche stable. Titres, échéances, priorités, projets et notes. Si votre schéma est stable, n'importe quelle méthode d'extraction en amont peut l'alimenter.
2. Une ingestion idempotente. Exécuter deux fois le même dépôt ne doit pas créer de tâches en double. C'est un problème de hachage, pas un problème d'IA.
3. Un point de revue humaine. L'extraction propose ; vous approuvez. Automatiser l'étape d'écriture avant de faire confiance à l'étape de lecture, c'est ainsi que les gens se retrouvent avec 400 tâches fantômes.

Réussissez cela et une nouvelle fonctionnalité d'offre devient une source d'entrée supplémentaire. Ratez-les et chaque nouvelle fonctionnalité devient un projet de migration.

Prérequis

Avant d'exécuter une commande de ce guide, vérifiez les éléments suivants :

• Python 3.10 ou plus récent. Les annotations de type utilisées dans les scripts ci-dessous — list[dict], str | None — l'exigent.
• `pip` et `venv`. Standards sur la plupart des distributions ; sur Debian et Ubuntu, vous aurez peut-être besoin de python3-venv séparément.
• Une clé API pour l'API Gemini. Obtenez-en une via votre compte développeur Google AI. Je n'affirme rien sur le niveau d'offre qui accorde tel quota — vérifiez votre propre console de compte.
• Un identifiant de modèle que vous avez confirmé pour votre compte. Ne codez pas en dur un identifiant provenant d'un billet de blog, y compris celui-ci. Interrogez plutôt votre compte ; le script ci-dessous fait exactement cela.
• Facultatif : un projet Google Cloud avec l'API Google Tasks activée, si vous voulez pousser des tâches dans Google Tasks plutôt que dans un fichier JSON local.
• Un terminal, et environ quinze minutes.

Si l'un de ces éléments ne vous est pas disponible, arrêtez-vous ici. Le reste de l'article suppose que tous sont présents.

Installation étape par étape

1. Créer un environnement isolé

Créez un environnement virtuel pour que les SDK n'entrent pas en collision avec les paquets système.

python3 -m venv .venv
source .venv/bin/activate

Sous Windows, la ligne d'activation est plutôt .venv\Scripts\activate.

2. Installer les SDK

Installez le SDK Google Gen AI pour Python, qui fournit le client utilisé dans le script d'extraction.

pip install --upgrade google-genai

Si vous comptez écrire dans Google Tasks, installez aussi les bibliothèques d'authentification Google et de client API.

pip install google-auth google-auth-oauthlib google-api-python-client

3. Exporter vos identifiants

Exportez votre clé API sous forme de variable d'environnement plutôt que de la coller dans des fichiers source. Le SDK la lit depuis l'environnement.

export GEMINI_API_KEY="your-key-here"

Ne validez jamais cette valeur. Ajoutez GEMINI_API_KEY à .gitignore si vous gardez un fichier .env en local.

4. Découvrir quels modèles votre compte peut utiliser

Ne devinez pas un nom de modèle. Listez ce que votre compte peut réellement appeler et choisissez dans cette sortie.

python -c "from google import genai; [print(m.name) for m in genai.Client().models.list()]"

Exportez ensuite votre choix pour que le reste des scripts reste agnostique quant au modèle.

export GEMINI_MODEL="the-model-name-you-selected"

Si cette commande renvoie une erreur, votre clé ou la version du SDK en est probablement la cause — réglez cela avant de continuer.

5. Créer l'arborescence du projet

Une structure de répertoires prévisible rend l'exemple cron ultérieur trivial à écrire.

mkdir -p todo-bridge && cd todo-bridge
touch inbox.txt tasks.json config.json
echo "Email the revised deck to Priya by Friday" > inbox.txt

Configuration

Gardez le schéma dans un fichier plutôt que caché dans une chaîne de prompt, afin de pouvoir le modifier sans toucher au code.

Créez config.json :

{
  "priority_values": ["high", "medium", "low"],
  "default_priority": "medium",
  "date_format": "YYYY-MM-DD",
  "never_invent_dates": true,
  "max_tasks_per_run": 50
}

Deux de ces champs comptent plus que les autres. never_invent_dates empêche le modèle de deviner que « un jour la semaine prochaine » signifie un mercredi précis. max_tasks_per_run est un disjoncteur : si un dépôt malformé amène le modèle à produire un millier de tâches, vous voulez que le pipeline s'arrête, et non qu'il les écrive.

Le script d'extraction

Créez todo_bridge.py. Il lit un fichier texte libre, demande au modèle un tableau JSON de tâches, déduplique par rapport à ce que vous avez déjà, et n'ajoute que les éléments réellement nouveaux.

#!/usr/bin/env python3
"""Turn a free-form to-do dump into structured, deduplicated tasks."""
import hashlib
import json
import os
import pathlib
import sys

from google import genai

MODEL = os.environ["GEMINI_MODEL"]
CONFIG = json.loads(pathlib.Path("config.json").read_text())
DUMP = pathlib.Path(sys.argv[1] if len(sys.argv) > 1 else "inbox.txt")
OUT = pathlib.Path("tasks.json")

SYSTEM = """You convert messy notes into a JSON array of tasks.
Each element must have exactly these keys:
  title    (string, imperative, no trailing period)
  due      ("YYYY-MM-DD" or null)
  priority ("high" | "medium" | "low")
  project  (string or null)
  notes    (string or null)

Rules:
- One element per actionable item. Do not merge unrelated items.
- Never invent a due date. If the text is vague, use null.
- Output JSON only. No prose, no markdown fences."""

def extract(text: str) -> list[dict]:
    client = genai.Client()
    response = client.models.generate_content(
        model=MODEL,
        contents=f"{SYSTEM}\n\n---\n{text}",
        config={"response_mime_type": "application/json"},
    )
    tasks = json.loads(response.text)
    return tasks[: CONFIG["max_tasks_per_run"]]

def task_id(task: dict) -> str:
    basis = f"{task['title'].strip().lower()}|{task.get('due') or ''}"
    return hashlib.sha1(basis.encode("utf-8")).hexdigest()[:12]

def main() -> None:
    existing = json.loads(OUT.read_text()) if OUT.exists() else []
    known = {t["id"] for t in existing}

    candidates = extract(DUMP.read_text())
    new = []
    for task in candidates:
        task.setdefault("priority", CONFIG["default_priority"])
        task["id"] = task_id(task)
        task["done"] = False
        if task["id"] not in known:
            new.append(task)

    OUT.write_text(json.dumps(existing + new, indent=2))
    print(f"parsed={len(candidates)} new={len(new)} skipped={len(candidates) - len(new)}")

if __name__ == "__main__":
    main()

Exécutez-le :

python todo_bridge.py inbox.txt

La déduplication est volontairement naïve — un hachage du titre plus la date d'échéance. C'est justement l'idée. Elle est déterministe, inspectable et ne peut pas halluciner. Si la même tâche apparaît avec deux titres différents (« Email Priya » et « Send Priya the deck »), elle passera au travers ; c'est un problème de revue, pas un problème d'extraction.

Exemples d'utilisation

Exemple 1 : Un dépôt matinal en désordre

Écrivez une note vraiment chaotique dans inbox.txt — projets mélangés, dates vagues, phrases inachevées. Exécutez ensuite le script et inspectez le résultat :

python -m json.tool tasks.json

Vous voulez voir de la structure, pas de l'astuce. Si le modèle a attribué une date concrète à « bientôt », resserrez le prompt système et relancez.

Exemple 2 : Filtrer le travail du jour

Une fois tasks.json peuplé, filtrez avec jq plutôt que d'ouvrir un éditeur.

jq '[.[] | select(.done == false and .priority == "high")]' tasks.json

C'est la même requête que vous exécuteriez depuis n'importe quel outil en aval, ce qui constitue le véritable avantage d'un schéma : votre boucle de revue cesse de dépendre d'une interface de chat.

Exemple 3 : Ingestion planifiée

Exécutez le pont chaque lundi à 08:00, en ajoutant à un journal pour pouvoir auditer ce qu'il a fait.

0 8 * * 1 cd /opt/todo-bridge && .venv/bin/python todo_bridge.py inbox.txt >> bridge.log 2>&1

Installez-le avec crontab -e. Notez que cron n'hérite pas de votre environnement shell — exportez GEMINI_API_KEY et GEMINI_MODEL dans la crontab ou sourcez explicitement un fichier .env au début de la commande.

Exemple 4 : Pousser les tâches approuvées dans Google Tasks

N'ajoutez ceci qu'après avoir fait confiance à l'étape d'extraction pendant au moins une semaine. L'extrait ci-dessous montre la forme de l'authentification ; confirmez la chaîne de scope exacte et la surface d'API par rapport à la documentation actuelle de l'API Google Tasks avant de vous y fier.

from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = ["https://www.googleapis.com/auth/tasks"]

def service():
    flow = InstalledAppFlow.from_client_secrets_file("client_secret.json", SCOPES)
    creds = flow.run_local_server(port=0)
    return build("tasks", "v1", credentials=creds)

def push(svc, tasklist_id: str, task: dict) -> None:
    body = {"title": task["title"], "notes": task.get("notes") or ""}
    if task.get("due"):
        body["due"] = f"{task['due']}T00:00:00.000Z"
    svc.tasks().insert(tasklist=tasklist_id, body=body).execute()

Gardez ceci derrière un drapeau --push. Par défaut, écrivez uniquement tasks.json.

Garde-fous qui tiennent vraiment

• Exécution à blanc par défaut. Si votre script écrit où que ce soit au premier lancement, vous avez supprimé votre propre point de revue.
• Plafonnez la sortie. Le champ max_tasks_per_run n'a rien de glamour et évite le pire mode de défaillance.
• Journalisez chaque exécution. parsed=, new=, skipped= — trois nombres qui vous disent si le pipeline dérive.
• Versionnez votre configuration. Quand la qualité d'extraction change, vous voulez savoir si c'est le prompt, le schéma ou l'entrée qui a changé.
• N'enchaînez pas l'automatisation sur l'automatisation. Une extraction qui alimente un planificateur qui alimente un notificateur, c'est trois points de défaillance pour un seul point de revue.

Modes de défaillance courants

Le problème le plus fréquent est l'inflation de dates : les modèles veulent être utiles, et « la semaine prochaine » devient une date précise. Activez never_invent_dates et vérifiez avec un dépôt de test contenant trois éléments délibérément vagues.

Le deuxième est la duplication silencieuse lorsque les titres varient légèrement. Normalisez la casse et la ponctuation dans task_id — l'exemple gère la partie casse — et acceptez que le reste relève d'une tâche de revue.

Le troisième est la dispersion des identifiants. Une clé, une variable d'environnement, un seul endroit où la faire tourner.

Conclusion

Le fait vérifié est étroit : le blog IA de Google a publié un billet le 9 septembre 2026 intitulé « Tackle your to-do list with new features in our Google AI plans. » Tout ce qui concerne ce que font ces fonctionnalités reste, au moment de la rédaction, non confirmé par les sources dont je dispose.

Cette étroitesse n'est pas un problème pour votre flux de travail. Le pipeline ci-dessus — un schéma stable, un script d'ingestion idempotent, une entrée cron et un point de revue strict — est utile aujourd'hui et le reste après n'importe quelle annonce. Construisez d'abord la plomberie. Quand les fonctionnalités d'offre arriveront, vous aurez où les acheminer, et vous saurez faire la différence entre une véritable amélioration et une fenêtre de chat aux meilleures manières.