Tackle Your To-Do List With New Features in Google's AI Plans: A Practical Guide

Tackle Your To-Do List With New Features in Google's AI Plans: A Practical Guide

On 9 September 2026, Google's AI blog published a post titled "Tackle your to-do list with new features in our Google AI plans." That headline is the premise of this article — and it is also, deliberately, close to the entire set of claims I am willing to make without hedging. I verified that the primary source exists and is publicly accessible at the URL below. I did not verify feature names, price points, regional rollouts, or model identifiers, so none of those appear here.

What follows is therefore a preparation article rather than an announcement recap. If task management is moving into Google's subscription AI plans, the valuable work you can do today is not refreshing a changelog. It is building the connective tissue around your task data — extraction, normalization, deduplication, review — so that plan-level features can plug into a pipeline you already own. This guide gives you that pipeline: requirements, installation commands, a working extraction script, configuration, usage examples, and guardrails.

What Is Verified, and What Is Interpretation

Separating these two is not pedantry. It is the difference between a working integration and one built on assumptions that quietly break.

Verified (evidence level A — a primary source was confirmed):

• A Google AI Blog post exists with the title "Tackle your to-do list with new features in our Google AI plans."
• Its canonical location is https://blog.google/products-and-platforms/products/google-one/fall-2026-ai-plan-updates.
• The source record carries a timestamp of 2026-09-09T17:00:00.000Z.

Interpretation, clearly labelled as such:

• The title implies that task-related capabilities are being framed as a benefit of Google's AI subscription plans rather than as standalone tools. That is a reasonable reading of the wording, not a documented specification.
• "New features" is plural and unspecified. I do not know what they are, how they behave, or which plans include them.

Open limits:

• The primary source is a single blog post. There is no independent corroboration available to me for any specific capability.
• Anything below that references Google APIs describes the developer-facing Gemini API and Google Tasks API as general-purpose building blocks. It is not a claim that the announcement's features use these interfaces.

Treat the code in this article as infrastructure you control, not as an implementation of an unverified feature set.

Why Prepare Before the Features Land

Most productivity AI fails at the same point: the handoff between unstructured input and a system of record. You paste a messy brain dump into a chat window, get a tidy list back, and then manually copy it into a task manager. The intelligence was never the bottleneck — the plumbing was.

There are three properties worth engineering now, because they are independent of whatever Google ships:

1. A stable task schema. Titles, due dates, priorities, projects, and notes. If your schema is stable, any upstream extraction method can feed it.
2. Idempotent ingestion. Running the same dump twice must not create duplicate tasks. This is a hash problem, not an AI problem.
3. A human review gate. Extraction proposes; you approve. Automating the write step before you trust the read step is how people end up with 400 phantom tasks.

Get these right and a new plan feature becomes an additional input source. Get them wrong and every new feature becomes a migration project.

Requirements

Before running any command in this guide, confirm the following:

• Python 3.10 or newer. The type hints used in the scripts below — list[dict], str | None — require it.
• `pip` and `venv`. Standard on most distributions; on Debian and Ubuntu you may need python3-venv separately.
• An API key for the Gemini API. Obtain one through your Google AI developer account. I am not asserting anything about which plan tier grants what quota — check your own account console.
• A model identifier you have confirmed for your account. Do not hardcode one from a blog post, including this one. Query your account instead; the script below does exactly that.
• Optional: a Google Cloud project with the Google Tasks API enabled, if you want to push tasks into Google Tasks rather than a local JSON file.
• A terminal, and roughly fifteen minutes.

If any of those are unavailable to you, stop here. The rest of the article assumes all of them.

Step-by-Step Installation

1. Create an isolated environment

Create a virtual environment so the SDKs do not collide with system packages.

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

On Windows, the activation line is .venv\Scripts\activate instead.

2. Install the SDKs

Install the Google Gen AI SDK for Python, which provides the client used in the extraction script.

pip install --upgrade google-genai

If you intend to write into Google Tasks, also install the Google authentication and API client libraries.

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

3. Export your credentials

Export your API key as an environment variable rather than pasting it into source files. The SDK reads it from the environment.

export GEMINI_API_KEY="your-key-here"

Never commit this value. Add GEMINI_API_KEY to .gitignore if you keep a .env file locally.

4. Discover which models your account can use

Do not guess a model name. List what your account can actually call and pick from that output.

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

Then export your choice so the rest of the scripts stay model-agnostic.

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

If this command errors, your key or SDK version is the likely cause — resolve that before continuing.

5. Create the project layout

A predictable directory structure makes the cron example later trivial to write.

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

Keep the schema in a file rather than buried in a prompt string, so you can change it without editing code.

Create config.json:

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

Two of these fields matter more than the rest. never_invent_dates keeps the model from guessing that "sometime next week" means a specific Wednesday. max_tasks_per_run is a circuit breaker: if a malformed dump causes the model to emit a thousand tasks, you want the pipeline to stop, not to write them.

The Extraction Script

Create todo_bridge.py. It reads a free-form text file, asks the model for a JSON array of tasks, deduplicates against what you already have, and appends only genuinely new items.

#!/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()

Run it:

python todo_bridge.py inbox.txt

The deduplication is intentionally naive — a hash of title plus due date. That is the point. It is deterministic, inspectable, and cannot hallucinate. If the same task appears with two different titles ("Email Priya" and "Send Priya the deck"), it will slip through; that is a review problem, not an extraction problem.

Usage Examples

Example 1: A messy morning dump

Write a genuinely chaotic note into inbox.txt — mixed projects, vague dates, half-sentences. Then run the script and inspect the result:

python -m json.tool tasks.json

You want to see structure, not cleverness. If the model assigned a concrete date to "soon," tighten the system prompt and rerun.

Example 2: Filtering for today's work

Once tasks.json is populated, filter with jq rather than opening an editor.

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

This is the same query you would run from any downstream tool, which is the real benefit of a schema: your review loop stops depending on a chat interface.

Example 3: Scheduled ingestion

Run the bridge every Monday at 08:00, appending to a log so you can audit what it did.

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

Install it with crontab -e. Note that cron does not inherit your shell environment — export GEMINI_API_KEY and GEMINI_MODEL inside the crontab or source a .env file explicitly at the start of the command.

Example 4: Pushing approved tasks into Google Tasks

Only add this after you have trusted the extraction step for at least a week. The snippet below shows the authentication shape; confirm the exact scope string and API surface against the current Google Tasks API documentation before relying on it.

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()

Keep this behind a --push flag. Default to writing tasks.json only.

Guardrails That Actually Hold

• Dry-run by default. If your script writes anywhere on the first run, you have removed your own review gate.
• Cap the output. The max_tasks_per_run field is unglamorous and prevents the single worst failure mode.
• Log every run. parsed=, new=, skipped= — three numbers that tell you whether the pipeline is drifting.
• Version your config. When extraction quality changes, you want to know whether the prompt, the schema, or the input changed.
• Do not chain automation on automation. Extraction feeding a scheduler feeding a notifier is three points of failure with one point of review.

Common Failure Modes

The most frequent problem is date inflation: models want to be helpful, and "next week" becomes a specific date. Set never_invent_dates and verify with a test dump containing three deliberately vague items.

The second is silent duplication when titles vary slightly. Normalise case and punctuation in task_id — the sample does the case part — and accept that the rest is a review task.

The third is credential sprawl. One key, one environment variable, one place to rotate it.

Conclusion

The verified fact is narrow: Google's AI blog published a post on 9 September 2026 titled "Tackle your to-do list with new features in our Google AI plans." Everything about what those features do remains, at the time of writing, unconfirmed by the source material available to me.

That narrowness is not a problem for your workflow. The pipeline above — a stable schema, an idempotent ingestion script, a cron entry, and a hard review gate — is useful today and remains useful after any announcement. Build the plumbing first. When the plan features arrive, you will have somewhere to route them, and you will be able to tell the difference between a genuine improvement and a chat window with better manners.