How to Turn Generic AI Into a Pro Content Creator in Four Steps
Aka, context engineering for L&D
Hello folks 👋
Two weeks ago, as part of development and implementation week on my AI & Learning Design Bootcamp, I built bot in ~30 minutes. The aim was to demo to my students that when it comes to content creation, the real value of AI lies in designing better inputs, not blindly chasing better outputs.
The “Scriptwriter Bot” I built takes raw content — a policy doc, SME notes, whatever you have — and produces input-ready video scripts for AI video tools (in my case, Colossyan). Generic Claude gave me a wall of text I’d need an hour to fix. The bot gave me a 9-scene production script with quizzes, branching scenarios, and a Doc2Video file I could upload directly — plus a full reasoning chain explaining every design decision before a word of script was written.
In this post I’ll walk you through three things:
The Bot — what it does, how I built it, and a real before-and-after comparison
The Framework — the four-layer model behind it, why it works, and how to apply it to any AI tool
What this means for you — the shift from prompt engineering to context engineering, and why learning designers are perfectly positioned for it
Let’s dive in.
Part 1: The Build
The power of any AI lies primarily in the context works with. By default, this is its training data but we can also shape what AI knows and how it thinks and behaves by uploading documents which intentionally shape its knowledge, skills and behaviour.
When we’re working with AI to create content, two pieces of context are critical:
1. Info on How the Tools Work
Because of their training data, generic LLMs tend to have limited understanding of how specific AI tools work. By giving the LLM a simple summary of the functionality of the tool we’re using, we 100X its power to deliver well in a way that optimises the power of the tool in question.
In my case, I asked Perplexity (web search & social switched on) to create me a document which summarises Colossyan’s key features & capabilities.
This context ensures that — rather than making a best guess at what the platform can do — AI has the specific, up to date context it needs about the platform’s features and capabilities to ensure it designs in line with those capabilities.
In practice, this means:
scenes are produced at the right length
suggested interactions align with features the tool actually supports
the output file uploads easily & directly to the platform in question
you save hours on reformatting and friction at the point of build.
A “how to” guide on building video in Colossyan (generated with web-search), to upload to AI as context. Read the full version here.
2. Info on How to Think Like a Learning Designer
Because of their training data, generic LLMs know what a training video looks like — but they don’t know what makes one effective. They’ll produce something fluent and well-formatted that violates basic learning science: scenes overloaded with concepts, no retrieval practice, recall-level quizzes, narration that duplicates on-screen text. It looks like training. It isn’t.
By giving the LLM a clear set of pedagogical design rules — and a worked example showing what “good” looks like — we close this gap completely.
Using Perplexity academic search (any LLM which can look only at academic sources will work), I asked AI to create me a practical "how to" guide suitable for a junior instructional designer on how to design instructional videos.
When uploaded to AI, this context ensures that — rather than applying generic “best practice” from its training data — AI follows your learning science rules and your quality standards automatically and consistently on every script.
In practice, by uploading this context to AI its behaviour changed as follows:
every scene is mapped to a stated learning objective
cognitive load is managed by design, not by luck
knowledge checks use realistic distractors based on common misconceptions, not trivia
behaviour-change topics are handled with branching decisions with consequences
the bot self-audits against a 15-point quality checklist before presenting output
I save time when reviewing design decisions instead
How I Built It: Step by Step
I used Perplexity for the research phase and Claude for the build. In total, I created four documents:
Document 1: Platform mechanics (~3 min) — I asked Perplexity (web & social search switched on) to surface Colossyan’s current functionality.
Output to upload as context: Colossyan: First-Timer’s Guide to Creating Online Course Videos.
Document 2: Scriptwriting guidelines (~3 min) — Then, I asked Perplexity (academic search only) to create the evidence-based practices for instructional video scripts.
Output to upload as context: Designing Instructional Videos: A Research-Based Practical Guide for Instructional Designers.
Document 3: Pedagogical design rules (~2 min) — Next, I asked Perplexity to turn the scriptwriting guidelines into a set of non-negotiable pedagogical rules for my Instructional Designer to follow. This is an extra “nice to have” which helps to reinforce optimal instructional design practices.
Output to upload as context: Instructional Video Design: Non-Negotiable Pedagogical Rules.
Document 4: Annotated example script (~2 min) — Finally, I asked AI to give me an fully worked 10-scene script showing what “gold” looks like: instructional intent, narration, visual directions, interactivity, and production notes for every scene. This single “exemplar” document teaches the AI more about quality than the other three combined.
Once you have your docs ready, setup is pretty easy:
1. Create a new project or custom bot. I used Claude Projects (go to claude.ai → Projects → Create Project), but the same approach works in ChatGPT's Custom GPT builder, ChatGPT Projects, Microsoft Copilot Studio, or Google Gemini Gems. Any tool that lets you upload reference documents and set persistent instructions will do. The platform matters less than what you put in it. I named mine "Colossyan Scriptwriter."
2. Upload your four documents. Click the “+” next to Files and upload all four. Claude will read them before every conversation in this Project. You’ll see them listed in the sidebar — that’s your knowledge base.
3. Write the instructions. Click “Edit” next to Instructions and paste in the rules that tell the bot how to behave. This is where you define the workflow — not the knowledge (that’s in the documents), but the process:
Read all four knowledge files before every task
When a user provides content, summarise what it covers and check whether it’s too broad for a single video
Ask for what’s missing — audience, objectives, length, tone, avatar — in one message, not one at a time
Don’t generate any script until you have at minimum: content, audience, objectives, and video length
Before writing, explain your structural plan: what’s in each scene, which objectives each supports, which learning science principles you’re applying, and what trade-offs you made
Produce two outputs every time: a detailed production script (with instructional intent, narration, visuals, and interactivity for every scene) and a Doc2Video-ready plain text file
Before presenting, self-audit against the pedagogical design rules
That’s it. Four documents as knowledge base, one set of instructions as workflow. Every new conversation in this Project starts with the bot reading all four documents — so your expertise is applied automatically, every time, without you pasting anything.
4. Test it. Open a new conversation within the Project, upload a source document, and type your prompt. Compare what you get to a blank Claude chat with the same prompt and the same source document. That comparison is the before-and-after you saw above.
Before & After
So, what difference does this effort make? Here’s a the demo I shared with my students so you can see for yourself.
I uploaded Mastercard’s 9-page Supplier Code of Conduct (publicly available on Mastercard's website) and gave both generic Claude (Opus 4.6) and the bot (Opus 4.6 plus my instructions & knowledge base) the exact same prompt: “Write me an intro video script for a course on this code of conduct.”
The difference is visible immediately, but scroll down in each conversation and the gap gets wider.
Generic Claude went straight from prompt to a finished script — five scenes of narrator voiceover covering all 9 topic areas in one video, with stage directions like “Quick montage — diverse professionals collaborating” that Colossyan can’t produce. Zero quizzes. Zero scenarios. No objectives. No reasoning.
The bot started by scoping: “This is 4–5 videos’ worth of content — which topic should we focus on?” Then it asked for audience, objectives, and length. Only then did it produce a structural plan — every scene mapped to an objective, with learning science principles and trade-offs explained before a word of script was written:
The script itself followed: a hook that speaks to the learner’s situation (“You’re new here”) instead of the brand (“At Mastercard, every connection matters”). A quiz where “check with your manager” is a realistic trap — because internal approval doesn’t override the Supplier Code. A branching scenario where all three options are things people actually do in real life. Plus a Doc2Video file ready to upload directly.
Same source, same AI model, same prompt — but massively different output quality.
Part 2: The Principles
The Scriptwriter Bot is is a great example , but the principles behind it are what really matter.
If you strip away the specifics of Colossyan and video scripts, every decision I made maps to a broader principle for working with AI to create learning content. Here are the five that make the biggest difference.
1. Design the input, not the output
Most people try to improve AI output by writing longer, more detailed prompts. That helps — a little. But the real leverage is in the knowledge system around the prompt: persistent documents that shape what AI knows, how it thinks, and what it refuses to do. A prompt is a one-off instruction. A knowledge base is a reusable standard. Build the input well and the output takes care of itself.
2. Give AI two types of context — not one
Most AI-generated learning content fails in one of two ways: it ignores the platform (generic formatting, impossible stage directions, no awareness of what the tool can do) or it ignores the pedagogy (no objectives, no retrieval, overloaded scenes, recall-level quizzes). These are two separate problems that require two separate types of context:
Tool context (how the platform works) — ensures the output is implementable
Pedagogical context (how learning works) — ensures the output is effective
You need both. One without the other produces content that’s either technically correct but pedagogically empty, or pedagogically sound but impossible to build.
3. Show AI what “gold” looks like
Rules tell AI what to do. Examples show it the standard. Both are necessary — but if you could only upload one document, upload the example. AI models learn formats, quality bars, and structural patterns from worked examples far more reliably than from written instructions. In AI terms, this is called few-shot learning — and it’s the single highest-leverage technique for any learning designer building AI tools.
4. Make AI ask before it answers
The generic Claude script skipped the design phase entirely — straight from prompt to output. The bot refused to start until it had audience, objectives, and length. This isn’t a limitation. It’s a feature. You can build this behaviour into any AI tool by adding one line to your instructions: “Don’t generate until you have X, Y, and Z.” The questions a good designer would ask before starting a project are exactly the questions your AI should ask too.
5. Make AI show its reasoning
The reasoning chain — the structural plan, the learning science principles, the trade-offs — is not decoration. It’s the mechanism that makes the output reviewable. When AI explains why it put a quiz in Scene 4 and why it cut the Government Official definition to one principle, you can evaluate the design decisions, not just the final script. You move from proofreading to design review. That’s a fundamentally different — and more valuable — use of your time.
Apply this to any tool
These five principles work for any AI output tool in your stack. The specific documents change. The framework doesn’t:
Part 3: What This Means for You
The AI world has a name for everything you just read.
In mid-2025, Andrej Karpathy (co-founder of OpenAI) and Tobi Lütke (CEO of Shopify) started calling it context engineering — the art of providing all the context for a task to be plausibly solvable by the LLM. Karpathy noted that people associate “prompts” with short instructions, but in every serious AI application, the real skill is filling the context window with just the right information.
That’s exactly what the four documents do — and the distinction from prompt engineering matters:
Prompt engineering = writing a better instruction. One-off. Ephemeral. Gone when you close the chat.
Context engineering = building a better knowledge system. Persistent. Reusable. Applied automatically every time.
At the end of 2024, I predicted that 2025 would be the year of prompt engineering for L&D. 2026 is the year of context engineering — and it’s where most of us need to be building right now.
Here’s the good news for us learning designers: context engineering isn’t a technical skill. It’s a design skill. The person who knows how to write pedagogical design rules, create quality examples, and define what “good” looks like is the person whose expertise becomes gold.
So, my one top tip for 2026? Stop writing longer prompts, start building better inputs.
To get started: pick one output you produce regularly — a video script, an assessment bank, a storyboard. Spend 30 minutes creating the documents. Test it with real content. Compare the output to what you get from a blank chat.
Happy designing!
Phil 👋
PS: Want to learn more about working with AI with me? Apply for a place on my AI & Learning Design Bootcamp.
