Investing in Global Talent and AI Literacy: A Practical Guide

Investing in Global Talent and AI Literacy: A Practical Guide

Most organizations that stall on AI do not stall because of compute. They stall because too few people can read a model card, judge whether a generated answer is grounded, or explain to a colleague why a system should not be deployed. Closing that gap is a talent problem before it is a tooling problem, and it is the reason Google's AI blog documents work with the ITU on AI skills training under the Grow with Google umbrella, framed explicitly as investing in global talent and AI literacy.

This guide is about the operational half of that idea. The source material is a company announcement, not a curriculum specification, so the sections below separate what is verifiable from what is a reasonable design choice. The technical parts—installation, configuration, and scripts—are things you can run today to build and measure an internal AI literacy program.

Verified background, and what it does not tell you

The primary source for this article is the Google AI Blog post on investing in global talent and AI literacy, published at https://blog.google/company-news/outreach-and-initiatives/grow-with-google/itu-ai-skills-training and dated 22 September 2026. It describes an initiative connected to Grow with Google and AI skills training with the ITU.

That is the extent of what this article treats as established. The post is an announcement, not a syllabus, so it does not specify cohort sizes, completion rates, which regions are prioritized, or which competencies are assessed. Anything below that describes tiers, hour counts, or measurement thresholds is an engineering proposal from this article, not a claim about the source. Treat those numbers as starting defaults to be replaced with your own.

The practical consequence: you should not lift a curriculum from a press release. You should lift the intent—broad, cross-border AI literacy—and then build something locally measurable.

Requirements

Before writing any course material, confirm you have the following. The list is deliberately modest, because an AI literacy program that requires a GPU cluster will never reach the people who need it most.

People and process

• A named owner for the program, with authority to change onboarding requirements.
• At least one facilitator per region or language group who can run hands-on sessions.
• A privacy review covering any learner data you plan to collect.

Software

• Python 3.10 or newer.
• pip and the ability to create virtual environments.
• Git, or another version control system, for the curriculum itself.
• Optional: a local model runtime such as Ollama, if you want exercises that run without sending data to an external API.

Hardware

• A laptop per learner with at least 8 GB of RAM for the Python exercises.
• 16 GB of RAM if learners will run a small local language model during labs.
• No GPU required. Every script in this guide runs on CPU.

Access constraints to solve first

• Offline or low-bandwidth venues need pre-downloaded materials.
• Translation costs are real; budget for review by a native speaker, not just machine translation.
• Some regions have restrictions on cross-border data transfer that affect how you collect assessments.

Step-by-step installation

The goal of this section is a working environment for building curriculum files, running a coverage audit, and generating practice questions locally.

First, create an isolated Python environment so program tooling does not collide with system packages.

python3 -m venv .venv

Activate it. The command differs by platform.

source .venv/bin/activate   # macOS and Linux

.venv\Scripts\activate      # Windows PowerShell

Upgrade the packaging tools before installing anything else; older pip versions frequently fail on binary wheels.

python -m pip install --upgrade pip wheel

Install the program toolchain. Each package has a job: pandas for the coverage audit, mkdocs-material for the learner-facing site, fastapi and uvicorn for a small readiness API, and requests for talking to a local model.

pip install pandas scikit-learn jupyterlab mkdocs-material fastapi "uvicorn[standard]" python-dotenv requests

Next, install a local model runtime. The installer script below is the official Ollama install path for Linux; macOS and Windows users should use the platform installer from the same project.

curl -fsSL https://ollama.com/install.sh | sh

Pull a small instruction-tuned model. Small models are the right choice here: they run on learner laptops, respond fast, and make their limitations visible, which is itself a teaching moment. Check the runtime's current model list before choosing a tag, since available names change over time.

ollama pull llama3.2:3b

Confirm the model is present and the local service responds.

ollama list

Finally, scaffold the documentation site that will host the curriculum.

mkdocs new program-docs

Serve it locally to verify the toolchain end to end. Binding to all interfaces lets facilitators on the same network preview it.

cd program-docs
mkdocs serve -a 0.0.0.0:8000

Configuration

Create a .env file at the project root. Keeping host names and model tags out of source code means a region with no outbound internet can point at a local server without editing scripts.

cat > .env <<'EOF'
OLLAMA_HOST=http://localhost:11434
LOCAL_MODEL=llama3.2:3b
DATA_DIR=./data
COHORT_ID=pilot-cohort-01
EOF

Create the data directory and a module inventory file. The columns here define the audit that follows: each module has a tier, a region, a duration in minutes, and an optional prerequisite.

mkdir -p data
cat > data/modules.csv <<'EOF'
module_id,title,tier,region,minutes,prereq
f01,What a model actually does,foundation,global,45,
f02,Reading a model card,foundation,global,60,f01
f03,Data protection basics,foundation,emea,50,
p01,Prompting for grounded answers,practitioner,global,90,f02
p02,Evaluating outputs,practitioner,global,90,p01
b01,Fine-tuning versus retrieval,builder,global,120,p02
EOF

Register the curriculum pages in mkdocs.yml so the navigation mirrors the tier structure rather than the filesystem.

site_name: Global AI Literacy Program
theme:
  name: material
nav:
  - Home: index.md
  - Foundation: foundation.md
  - Practitioner: practitioner.md
  - Builder: builder.md
  - Facilitation guide: facilitation.md

Usage examples

With the environment configured, the next three examples cover the questions a program owner actually asks: is the curriculum complete, can we generate practice material without sending data anywhere, and what does regional readiness look like?

Audit curriculum coverage

This script reads the module inventory and reports missing tiers, total seat time per region, and modules that assume knowledge they never introduce.

# coverage_audit.py
import pandas as pd

modules = pd.read_csv("data/modules.csv")

required_tiers = {"foundation", "practitioner", "builder"}
missing_tiers = required_tiers - set(modules["tier"].unique())

minutes_by_region = (
    modules.groupby("region")["minutes"].sum().sort_values(ascending=False)
)

orphans = modules[
    modules["prereq"].isna() & (modules["tier"] != "foundation")
]

print("Missing tiers:", missing_tiers or "none")
print("\nSeat minutes by region:\n", minutes_by_region)
print("\nModules with unmet prerequisites:\n", orphans[["module_id", "title"]])

Run it after every curriculum edit.

python coverage_audit.py

The orphans check is the one that matters most. A practitioner module with no prerequisite is usually a sign that a concept was assumed rather than taught, which is exactly the failure mode that makes AI literacy programs feel inaccessible.

Generate practice questions with a local model

This script calls the local runtime to draft multiple-choice items. Running it locally means learner data and draft content never leave the machine, which simplifies review in restricted regions.

# generate_exercises.py
import json
import os

import requests
from dotenv import load_dotenv

load_dotenv()
HOST = os.getenv("OLLAMA_HOST", "http://localhost:11434")
MODEL = os.getenv("LOCAL_MODEL")

PROMPT = """You are drafting practice items for a workplace AI literacy course.
Write 3 short multiple-choice questions about: {topic}.
Return JSON only, as a list of objects with keys:
question, options (list of 4 strings), answer_index (0-3)."""

def make_items(topic: str) -> list[dict]:
    payload = {
        "model": MODEL,
        "prompt": PROMPT.format(topic=topic),
        "stream": False,
        "format": "json",
    }
    response = requests.post(f"{HOST}/api/generate", json=payload, timeout=180)
    response.raise_for_status()
    return json.loads(response.json()["response"])

if __name__ == "__main__":
    items = make_items("what a large language model does and does not know")
    for item in items:
        print("-", item["question"])

Run it, then review every item manually before it reaches a learner. Generated questions are drafts, not assessments.

python generate_exercises.py

Expose regional readiness as an API

This service returns seat time per region against an illustrative baseline. The 240-minute threshold is a placeholder chosen for demonstration; replace it with whatever your program decides is the minimum.

# api.py
import pandas as pd
from fastapi import FastAPI

app = FastAPI(title="AI Literacy Readiness API")
BASELINE_MINUTES = 240  # illustrative placeholder

@app.get("/readiness/{region}")
def readiness(region: str):
    modules = pd.read_csv("data/modules.csv")
    subset = modules[modules["region"].str.lower() == region.lower()]
    minutes = int(subset["minutes"].sum())
    return {
        "region": region,
        "modules": len(subset),
        "seat_minutes": minutes,
        "meets_baseline": minutes >= BASELINE_MINUTES,
    }

Start the server.

uvicorn api:app --reload --port 8000

Query it from another terminal.

curl http://localhost:8000/readiness/global

A response showing meets_baseline: false for a region is useful precisely because it is uncomfortable: it turns a vague commitment to global talent into a specific, arguable gap.

Measuring impact without vanity metrics

Completion counts are easy to collect and easy to game. Three indicators are more informative.

Prerequisite integrity. The share of modules whose prerequisites are actually covered by earlier content. The audit script gives you this directly.

Transfer evidence. Whether learners apply a concept in their own work within a fixed window after the module. This requires manager input, which is why the program needs an owner with organizational authority.

Escalation quality. Whether learners can identify when to stop and ask for review. A cohort that flags uncertain outputs is more valuable than one that never does.

Interpretation note: these indicators are proposed here, not drawn from the source. The source's level of detail is an announcement; measurement design is your responsibility.

Practical guardrails for a global rollout

Localize the examples, not just the text. A model card exercise using a European hiring dataset will land differently in a region with different labor law.

Assume intermittent connectivity. The local model runtime exists for exactly this reason; make offline mode the default for labs rather than a fallback.

Publish the limits. Every module should state what the tool cannot do. This reduces the chance that literacy training becomes uncritical adoption training.

Keep learner data minimal. Assessment results are personal data in many jurisdictions; collect what you can defend.

Conclusion

The verifiable claim behind this topic is narrow: an organization has publicly framed global talent and AI literacy as an investment, tied to Grow with Google and ITU AI skills training. Everything operational follows from taking that framing seriously at a smaller scale.

A workable program looks like this. Define tiers, write modules with explicit prerequisites, run the coverage audit until nothing is orphaned, generate practice material locally so review stays cheap and data stays put, and expose readiness as a number you have to defend. None of that requires a large budget. It requires deciding that the bottleneck is people and treating their skills as infrastructure worth measuring.

Start with the requirements list, run the install sequence, and audit whatever curriculum you already have. The gaps you find in the first hour are the ones worth fixing first.