A Filmmaker's Guide to the Egy Docs AI Filmmaker Bible
How to use an AI-assisted roadmap for documentary pre-production — without losing control of your film.
The problem this solves
Most filmmakers who try to bring AI into their process run into the same two failures.
The first is chaos: a different prompt every time, no consistency between sessions, no memory of what was already decided, and an AI that cheerfully invents a broadcaster contact or a budget figure because it sounds plausible.
The second is the opposite failure: rigid AI tools that assume you're starting from nothing, force you through a fixed script regardless of what you already have, and quietly try to write your film for you instead of helping you make it.
The Egy Docs AI Filmmaker Bible is an attempt to avoid both. It's a set of plain-language instruction files — readable by a human, and usable by any AI agent — that walk a documentary project through pre-production one real stage at a time. It doesn't tell you how to make your film. It tells you what each stage of getting a film ready actually requires, asks you what's already true, and keeps track of what's still missing.
The one idea that matters more than any other
The system governs milestones, not methods.
That's the whole philosophy in six words. Everything else in this guide is really just an explanation of what that sentence means in practice.
A "milestone" is a real thing: you know your idea. You've stress-tested your treatment. You know what archive material you actually have. A "method" is how you got there — and the bible has almost nothing to say about that. You can write your treatment yourself and hand it to the AI for a sanity check. You can build it entirely through conversation with the AI. You can use a completely different AI tool for half of it. You can skip a step because you already did it three years ago in a grant application. All of that is fine. The bible cares whether the milestone is actually met — not how you got there.
A few consequences follow from that one idea, and they're worth stating plainly, because they change how you should expect this system to behave:
AI is optional. No task assumes you must use it. Use it where it helps, skip it where it doesn't.
You don't have to start from zero. If you already have a treatment, a budget, or a finished pitch dossier, the system reviews it against what that stage requires — it doesn't make you rebuild it.
Missing information stays visibly missing. The AI is not allowed to quietly fill a gap to make your project look more finished than it is.
You make the decisions. The AI can draw out your idea, stress-test your treatment, or flag a gap in your archive plan. It doesn't decide what your film is about.
Development is iterative. Your idea isn't locked the moment you write a logline. Research, treatment, and even the script itself will legitimately change earlier decisions — the system is built to notice when that happens, not to pretend it doesn't.
What's actually inside it
The bible is organized the way a real production actually moves, not the way a syllabus would organize it. For pre-production, that's eleven stages plus two that only apply to certain projects:
Idea → Research → Treatment → Visual Grammar → Script → Production Readiness → Archive → Interviews → Technical → Budget → Pitch
Each stage lives in its own file, written in plain language, following the same shape every time: what this stage is for, what it needs from you, how the conversation should go, what "done" actually looks like, and what commonly goes wrong. That consistency matters — once you understand how one stage works, you understand the shape of all of them.
Two stages sit slightly outside the main line. Location Scouting only switches on if your project is actually shooting somewhere that needs it — a film shot entirely in a studio doesn't get asked about permits and backup locations it will never need. Festival & Fund Strategy is still being built; the bible is honest about that rather than shipping a placeholder pretending to be finished.
There's also a master file for the whole stage — the one document that sets the ground rules everything else follows: how bilingual material should be handled, how sources get judged for reliability, when the system should double-check itself, and so on. You read that file once at the start; every task file after it assumes those rules are already in effect.
Starting your first project
Here's what actually happens, step by step, the first time you sit down with this.
You open a chat with your AI of choice — Claude, ChatGPT, Gemini, or anything else — and give it the pre-production files. You tell it to read the master file first, and then start with the Idea stage.
The AI asks you one question: "What's your idea?"
Not a form. Not a checklist. One open question, because your idea might be one sentence or three paragraphs, and the system needs to see which before it decides what else to ask.
It listens for what's actually there, and asks only about what's missing. If you've already got a strong sense of who the film follows and why now matters, it won't waste your time re-asking. If you haven't thought about format yet — is this a feature or a series, festival or broadcast — it'll ask, because that single decision quietly shapes almost everything downstream.
Before it writes anything, it checks its understanding with you. It states back, in its own words, what it now thinks your film is — and waits for you to correct it. Only after you confirm does it draft a working title, a logline, and a short synopsis.
That's stage one, done in a handful of exchanges. Then you move to Research, and the same pattern repeats: listen, ask only what's missing, confirm before building, produce something concrete.
The two modes — and why this matters more than it sounds
Every task in this system can run in one of two ways, and knowing which one you're in changes everything about how the conversation should feel.
Build Mode is for when you're genuinely starting from nothing. The AI asks its questions, you answer, and the deliverable gets built from your answers, piece by piece.
Review Mode is for when you already have something — a treatment you wrote yourself, a budget from a previous version of the project, a full pitch dossier you built somewhere else entirely. In this mode, the AI's job flips: instead of asking you to build it again, it reads what you have, checks it against what that stage actually requires, and tells you what's solid and what's thin. It should never make you recreate work that already holds up.
If you're not sure which mode applies, the simplest thing to do is just say what you already have. "I already have a treatment for this, can you check it instead of starting over?" is a completely normal thing to say, and the system is built to recognize it.
Why the system keeps checking its own assumptions
Documentary development doesn't move in a straight line, and the bible doesn't pretend it does. Research can surface a fact that changes your idea. Writing the actual script can reveal something your treatment never anticipated. Discovering that a crucial piece of archive footage doesn't exist can force you to rethink your entire visual approach.
This isn't a hypothetical concern — it happened during the building of this system, on a real project. A treatment called for one long film, and only once the writer got deep into scripting the first real episode did it become clear that three shorter episodes told the story better. The format changed because of script work, not before it.
So the bible builds in checkpoints at exactly the points where this tends to happen: after research and after treatment, it asks whether your original idea still holds. After you've written a script, it asks whether anything in it should change the treatment. After you've sourced your archive, it asks whether what you found — or didn't find — should change your visual plan.
These checkpoints aren't there to make you redo work. Most of the time the answer is simply "no, still holds," and you move on in seconds. But when the answer is yes, catching it early is far cheaper than catching it in the edit.
Knowing when a stage is actually finished
Every task in the system answers a specific question: what does finishing this stage actually mean? Not "have I done a lot of work here," but "is there enough here to move forward responsibly."
For the idea stage, that means a title, logline, synopsis, format, and a clear sense of why this project and why now — even if the tone or style is still genuinely open. For archive sourcing, it means every piece of material you need is accounted for in one of four honest categories: in hand, findable and purchasable, missing, or uncertain — with a backup plan for anything you can't yet confirm.
This matters because it stops a common trap: mistaking a long conversation for real progress. A stage is done when the milestone is met, not when you've talked for a while.
Keeping a record as you go
Two things run alongside the main sequence rather than inside it.
One is a simple readiness check you can ask for at any point — a table scoring how complete each area of your project actually is, plus an honest note about how strong (not just how filled-in) each area is. It's strictly for your own use, never something you'd hand to a broadcaster.
The other is a decision log — a running, dated record of the calls that actually mattered: what was decided, why, what else was considered, and what it affects. Not every choice belongs in it. But the moment one of those checkpoints above catches something real — a format change, a dropped location, a visual approach that shifted because an archive item never turned up — that's exactly the kind of decision worth writing down, so six months later nobody has to reconstruct from memory why the plan changed.
Where to actually start
If all of this sounds like a lot, it isn't meant to be experienced as a lot. The practical version is much simpler:
Give your AI agent the pre-production files.
Tell it to read the master file, then start with your idea.
Answer honestly. Say what you already have. Correct it when it misunderstands you.
Let it tell you when a stage is actually done, and move on.
That's genuinely the whole thing. Everything described above is what's happening underneath — it's not extra work you need to manage yourself.
What this is not
It's worth being direct about the boundaries. This isn't a tool that writes your documentary for you. It doesn't generate scripts — a dedicated stage exists specifically to review a script you've written, never to write one. It doesn't invent facts, contacts, costs, or quotes under any circumstance; if something is unknown, it stays visibly unknown until you resolve it. And it isn't tied to one AI platform — the whole thing is written to work the same way in Claude, ChatGPT, Gemini, or whatever comes next, because the workflow is what matters, not the tool running it.
The short version, if you remember nothing else
The system governs milestones, not methods. AI is optional. Existing work is welcome. Missing information stays visible. You make the decisions. The workflow is iterative. And the goal, at every stage, is fewer blind spots — not more AI.
The Egy Docs AI Filmmaker Bible is released under CC BY-SA 4.0 and built to grow: real production workflow first, structure built around it, never the other way around.