AI workflow for audio training that built behavioural change in a non-tech, non-desk team in ninety days — sourced via NotebookLM, scripted with Claude, voiced with ElevenLabs, delivered on WhatsApp.
For the first ninety days, the team didn’t know they were being trained.
They thought their morning huddle had picked up a new ritual — a sixty-second audio clip on the WhatsApp group, played right after the 10-minute standup, sometimes followed by a quick “haan, yeh hua tha last week, remember?” from someone on the floor. No agenda. No “training program” framing. No LMS login, no certificate at the end, no module names.
Just an audio file a day.
Three months in, when we told them the audios had been a structured curriculum the whole time — twelve modules, twelve lessons each, mapped to Bloom’s taxonomy, scripted, fact-checked, voiced — two things happened. They went back and re-listened to specific lessons. And the behavioural shifts we were already seeing got sharper. The reveal didn’t break the magic. It compounded it.
This is the build, end to end. The full project file is replicable, and we are packaging the prompt structure so any operator with a frontline or non-desk team can run it themselves. The tools matter less than the design choices behind them. If you steal nothing else from this post, steal the design choices.
The constraint that wrote the brief
The team we were training had three properties that broke every standard L&D playbook.
They didn’t sit at desks. They didn’t read English comfortably. And they checked WhatsApp roughly forty times a day but had never opened a learning management system in their lives.
Every other consultant who had walked through this client’s door had proposed a portal, a video library, classroom days that would pull people off the floor. None of it had stuck. The client wasn’t the problem. The format was.
So we did what embedded operators are supposed to do — we let the constraint design the solution.
Audio, not video. Sixty seconds, not six minutes. WhatsApp group, not LMS. Delivered after the working huddle so it sat inside an existing ritual rather than competing with one. Twelve files per module, fixed across all modules, so anyone could say “module 4, lesson 7” and locate it instantly in their head — the same way you know which song is track three on an album you’ve heard a hundred times.
Once those four constraints were locked, the AI workflow practically wrote itself.
The AI workflow: NotebookLM, Claude, and ElevenLabs in sequence
Here is the build order. Sample prompts are templates — plug your sector and audience in.
Step 1. Aggregate the raw material in NotebookLM.
We pulled twenty-plus YouTube lessons on adjacent topics — the good ones, the ones with high comment engagement and operator-grade trainers. We added Perplexity deep-research outputs on the same themes. All of it went into a single NotebookLM notebook as the source corpus.
NotebookLM’s job at this stage isn’t to be smart. It is to be the librarian. It holds the cited ground truth so every downstream artefact has something honest to point back to.
Step 2. Ask NotebookLM to draft the training flow structure as a deck.
The prompt looked roughly like this:
“Based on the sources in this notebook, give me an effective training flow structure for a [non-tech, frontline, vernacular-comfortable] team. Output as a presentation with one slide per module. Each module slide must have: (a) module title, (b) one sentence on the behavioural outcome we want, (c) twelve lesson titles that build toward that outcome, (d) prerequisite knowledge if any. Use plain language a shop-floor supervisor would understand.”
This gave us a first-cut PPT — a skeleton, not a script.
Step 3. Validate the structure with Claude.
We didn’t trust the NotebookLM draft to be the final architecture. We took the deck into Claude and stress-tested it: are the modules in the right order? Do the lesson titles inside each module actually build toward the stated behavioural outcome? Is anything missing that a practitioner would expect to see? Is anything bloated?
This is where pure-LLM dialogue beats RAG-grounded tools. Claude is freer to argue with the structure. NotebookLM is honest, but it is bounded by what is in the corpus. You need both.
Step 4. Layer the audience and the real challenges.
Generic training fails because it answers questions no one is asking. So we ran a second prompt against the validated structure:
“Here is the audience: [profile]. Here are five real challenges they face on the floor: [actual examples from the client’s last quarter]. Re-examine the twelve lessons in each module. For every lesson, tell me: which of these real challenges does this lesson directly address, and how? If a lesson does not connect to a real challenge, flag it for replacement.”
About 30% of the lessons got rewritten in this pass. Yeh wala step skip mat karna. This is where the training stops being a syllabus and starts being a remedy.
Step 5. Take it to the decision-maker for sign-off.
Before any script was written, before any audio was generated, the client’s senior person reviewed the module-and-lesson architecture and said yes. This is the cheapest checkpoint in the whole workflow and the one most consultants skip. Shuru mein ek sawaal pooch lo, baad mein sau jawaab nahi dene padenge.
Step 6. Lock the format. Sixty seconds. Twelve per module.
The constraints from the deployment design now became hard rules for the script. Each lesson had to deliver one idea, one takeaway, in under sixty seconds of conversational Hindi-English. No multi-part lessons. No “to be continued.” If something needed two minutes, it became two lessons.
Step 7. Write the scripts using Bloom’s taxonomy as the spine.
Inside each module, the twelve lessons were sequenced from Remember → Understand → Apply → Analyse → Evaluate → Create, lightly. Lesson 1 was always recall. Lessons 2–4 built understanding. Lessons 5–8 forced application through scenarios. Lessons 9–12 made the team analyse, judge, and propose. By the end of the module, they were not being told what good looked like — they were defining it.
We wrote the scripts in Claude. Not because Claude is the only tool that can write — but because we were already burning credits on validation and structure work, and consolidating saved real money. Jahan se kaam ho jaaye, wahan se karo.
Step 8. Fact-check and coherence-check via Perplexity deep research.
Before any audio was generated, every script was run through a Perplexity deep-research pass with one specific question: is anything claimed here factually wrong or inconsistent with what was claimed in earlier lessons of this module? Catching a factual error in text takes thirty seconds. Catching it after audio has been generated and pushed to WhatsApp takes a public apology.
Step 9. Generate audio inside Claude using Cowork.
We voiced the scripts using ElevenLabs, called from inside Claude’s Cowork environment. One workspace, one project file, one prompt library. The advantage isn’t the audio quality — eleven other tools can do that. The advantage is that the script, the prompt that generated the script, the source it was grounded in, and the audio file all live in the same project. When the client wants a Module 7 lesson rewritten in eighteen months, they don’t have to archaeologise. They open the project file.
This is the part that makes the whole AI workflow for audio training replicable — the project file, not just the audio output, is the deliverable.
How the audio training was deployed via WhatsApp
If the build was 40% of the value, the deployment was 60%.
One audio per day, dropped in the WhatsApp group ten minutes after the morning huddle. Not before. After. This matters — the team had already gathered, already aligned on the day’s targets, already had blood flowing. The audio landed into a warm room, not a cold one.
No one said this was a training program. The client’s floor manager just played it on speaker, paused at the end, and asked a single question: “koi yeh experience hua hai apne saath?” Sometimes there was a story. Sometimes there wasn’t. Either way the lesson got reinforced through the team’s own language, in real time, against real cases.
Those stories — the ones the team volunteered after the audio — were the second product of this engagement. We fed them back into the prompt library to refine future lessons. The training program got smarter because the team was teaching it back.
At month three, when we revealed the architecture, we also gave the team the full module map. They went back. They re-listened to the lessons that had connected to recent incidents on the floor. The retention numbers we were already tracking went up — not because anything new was added, but because the team now had a frame to hang the prior 90 days on.
What we are handing over so anyone can run this
The reason this blog exists is that the workflow is meant to be replicated, not gatekept.
We are packaging the NotebookLM source structure, the validated module template, the seven core prompts (structure-generation, audience-layering, Bloom’s-script-drafting, fact-check, coherence-check, audio-generation, refinement-loop), and the project file architecture. Any operator running training for a non-tech, no-desk team — beauty, retail, logistics, manufacturing, F&B — should be able to take this kit, swap in their sector context, and run.
The deeper point
Tools age in months. NotebookLM, Claude, ElevenLabs, Cowork — every one of these will look different a year from now, and some will not exist.
What ages slowly is the design thinking underneath. Sixty seconds because that is what a non-desk attention span will give you. WhatsApp because that is where they already are. Post-huddle because rituals are best built on existing rituals. No “training” label because the moment you call something training, half the room mentally checks out.
We didn’t teach the team. We gave them a daily moment, in their language, in their format, in their existing rhythm — and let learning happen as a side effect.
That is the whole game. The AI just made it cheap enough to do at scale.
— Team ProdifyTeam