Short programme
The AI Operator
The thesis
In the next twelve months, the gap between executives who can operate AI fluently and those who cannot will define who leads. Most AI training won't close that gap it explains the field, demonstrates tools, and produces no behaviour change. This course is built differently. Two weeks. Six live sessions. One terminal. By the end, you have shipped a working internal tool to your company. You have built it yourself. Other people use it. You understand how it works well enough to extend it, fix it, and trust it.
That is what "AI fluency" actually looks like. Anything less is theatre.
What makes this course different
By the end of this course, participants will be able to:
- Claude Code in the terminal is the spine. Not a session 5 advanced topic. From Day 1, you operate in the environment that senior practitioners actually use — the same one that has overtaken browser-based chatbots as the frontier interface for serious work.
- You ship a real artifact, not a personal commitment. By 26 June you have deployed an internal tool at your company, used by at least one colleague. The course doesn't end with a 90-day plan. It ends with something that exists.
- Practice between every session, made public. Mon–Wed–Fri rhythm means 48-hour feedback loops. Every assignment gets posted to the cohort Slack — Loom, screen recording, write-up. Public commitment is the engine.
- Peer learning is not an extra. It is the design. Every session opens with 20 minutes of cohort report-back. The most valuable signal in any AI cohort comes from the person sitting next to you. We make that the structural centre, not a coffee break.
- Practitioner-led, currency-obsessed. Sessions are taught by a senior practitioner currently building with AI in industry. The curriculum is rewritten before every cohort because the underlying technology genuinely changes that fast. We turn that pace into the lesson.
- A dedicated program manager runs the cohort. Between-session questions, peer connections, and pattern-spotting are actively curated by ESCP Blue Factory staff. The instructor focuses on session quality. The cohort never goes quiet.
Who this is for
This course is built for founders, executives, senior operators, and consultants who want to operate at the AI frontier.
If you have used ChatGPT or Claude in a browser, sensed there is a step-change available beyond it, and want a structured path to capture it — this is built for you. You do not need to write code. You will use the command line. We teach you exactly how. If you have used Excel and a calendar, you can do this.
This course is not for you if you are looking for a passive overview of the AI landscape, an executive briefing, or a tour of vendors. There are good products for those needs. This is not one of them.
How the cohort works
The roles
The course is delivered by three roles, each with a clear remit:
- Lead instructor — a senior practitioner who teaches the live sessions, reacts in real time to what the cohort is bringing, and surfaces patterns. Focused on session quality, not async support.
- Program manager — ESCP Blue Factory staff who runs the cohort Slack between sessions, answers questions, connects peers working on similar problems, and escalates to the instructor when needed.
- The cohort itself — 20 peers running parallel builds on their own real problems. The Slack is where most of the between-session learning happens.
The session structure
From Session 2 onward, every session follows the same rhythm:
- 20 minutes — cohort report-back: what people tried, what shipped, what failed
- 30 minutes — instructor input: pattern-spotting, demos of current best-in-class tools, frame for the next experiment
- 40 minutes — live build on each participant's shipping artifact, with instructor and peer support
- 10 minutes — set the next assignment and commit publicly to the cohort
Between sessions
48 hours between sessions, by design. Each participant runs one concrete build on their shipping artifact and posts the result to the cohort Slack. The program manager surfaces interesting threads, connects peers working on related problems, and escalates blockers. The cohort never goes quiet.
Pre-session onboarding
Five days before Session 1, every participant receives an onboarding pack: install instructions for Claude Code, a 60-minute self-paced tutorial, a permissions checklist, and an optional 30-minute setup call with the program manager three days before the course starts.
By the time Session 1 opens, every laptop is ready. Nobody arrives blocked. This is non-negotiable — it is the single most important predictor of cohort success and we treat it that way.
Session-by-session breakdown
Week 1 Foundation: become fluent in the operating environment
Session 1 — Open the Terminal — Your AI Operating Environment
Monday 15 June · 18:30–20:15 CET
You leave with Claude Code running in your terminal, connected to your work, and you have used it to do something real on your own data — not a demo.
In session:
- Cohort introductions and the framing that defines the course: by 26 June, you will have shipped a working internal tool, deployed at your company, used by at least one other person
- The terminal demystified — what it is, why it's where the speed lives, why every executive should be at home in it within two weeks
- Live install and first run of Claude Code with the cohort. Pre-session onboarding means every laptop is ready; the live session is where you start using it, not setting it up
- First real task: each participant uses Claude Code to analyze their own calendar, inbox, or recent documents and produces something useful in the live session
- Define your shipping artifact: each participant commits to a specific internal tool they will deploy by 26 June. The lead instructor and program manager help scope it correctly — ambitious enough to matter, narrow enough to ship
Between sessions:
Use Claude Code for one work task you would normally do another way. Post a 60-second Loom in the cohort Slack: what you tried, what surprised you, what was friction. Public commitment is part of the design.
Session 2 — AI as Personal Operating System — Productivity at the Speed of Thought
Wednesday 17 June · 18:30–20:15 CET
You leave with Claude Code wired into your daily work — calendar, email, documents, research — and you have replaced your first real workflow.
In session:
- Cohort report-back: 20 minutes of Loom highlights from Monday night. The instructor surfaces patterns; participants learn fastest from each other
- Connect your stack: MCP servers, file system access, browser tools. Claude Code that knows your calendar, your documents, your recent work
- The portability exercise — ask the AI to extract everything it knows about you, and learn to port your context between models. You are not locked in to any vendor
- Live workflow replacement: each participant identifies one recurring task (research, drafting, status updates, meeting prep) and rebuilds it inside Claude Code
- Prompt engineering as a real practice: system prompts, project instructions, slash commands, skills — how senior practitioners actually configure their environment
Between sessions:
Replace two recurring workflows with Claude Code-driven versions. Track time saved. Post in the cohort Slack: before/after, time saved, where it broke. Bring metrics to Friday.
Session 3 — Agentic Workflows — When AI Does the Work, Not You
Friday 19 June · 18:30–20:15 CET
You leave with a working agentic workflow a multi-step task where Claude Code plans, acts across your tools, and reports back, with you reviewing not micromanaging.
In session:
- Cohort report-back: time saved this week, the most interesting workflow rebuilds, and what broke
- From assistant to agent: the conceptual shift, the tools that make it real (skills, MCP, headless mode, scheduled runs), where each one belongs
- Live build of an agentic workflow that touches at least two systems — research a target, draft outreach, log the result. Each participant builds their own variant
- Failure modes you must understand to trust the system: hallucination, context loss, permission gaps, brittle prompts. How to design around each one
- Scope check on shipping artifacts: the lead instructor reviews each participant's tool plan in small-group breakouts. Adjustments made now save days in week two
Between sessions:
Run your agentic workflow over the weekend on real work. Document at least one failure mode you hit and how you handled it. Post a screen recording or write-up. Begin scaffolding your shipping artifact in Claude Code.
Week 2 Production: ship something that exists in the world
Session 4 — From Idea to Working Software — Build, Day One
Monday 22 June · 18:30–20:15 CET
You leave with the core of your shipping artifact running on your machine. Not theoretically. Running.
In session:
- Cohort report-back: weekend builds, agentic workflow successes and failures, surprises
- The architecture of an AI-built tool: front-end, data, AI calls, deployment. What you actually need to know vs. what Claude Code handles for you
- Live build session — every participant works on their own shipping artifact in Claude Code with instructor and peer support. The cohort is in the same terminal at the same time, building different things
- Patterns that keep coming up: how to structure prompts for Claude Code, when to use plan mode, when to let it run, how to review code you didn't write
- Deployment preview: where your tool will live by Wednesday — Vercel, Replit, internal hosting, whatever fits your context
Between sessions:
Get your shipping artifact to a working v0.1 — running locally, doing the core thing it needs to do. Post the demo in the cohort Slack. Identify the one thing blocking you and surface it before Wednesday.
Session 5 — Ship Day — Deploy and Share
Wednesday 24 June · 18:30–20:15 CET
You leave with your tool deployed, accessible to other people at your company, and ready for someone other than you to use it.
In session:
- Cohort report-back: v0.1 demos, blockers, breakthroughs
- Deployment in real time — the cohort deploys together. Every participant gets their tool to a URL or environment where colleagues can use it
- The harder questions you cannot ignore: data governance, who owns what you built, IP, vendor lock-in, model deprecation. Addressed seriously, with real frameworks
- Onboarding your first user: who at your company will use this tool, how you introduce it, what feedback you collect
- Prepare your final demo for Friday: the problem, the tool, the change, what you would build next
Between sessions:
Get at least one colleague at your company to use your tool. Document their reaction — what worked, what confused them, what they asked for. This goes in your final demo.
Session 6 — What Changes Monday — From Cohort to Practice
Friday 26 June · 18:30–20:15 CET
You leave with a deployed tool used by at least one other person at your company, a 30-day commitment for what you'll build next, and a peer cohort that compounds long after the course ends.
In session:
- Cohort report-back: v0.1 demos, blockers, breakthroughs
- Final demo round: every participant presents their shipped tool, what changed at their company, and the one screenshot or quote from a colleague that proves it's real
- The compounding practice: how to stay current as the landscape shifts every six weeks — without drowning in noise. Curated sources, signal extraction, the right peer networks
- Leadership question: how you teach this to your team, your peers, your clients. The participant becomes the teacher
- 30-day commitments: each participant names what they'll build next, who they'll teach, and how they'll measure it. Public commitment to the cohort
- Cohort channel stays open for 60 days. Optional 30-day check-in call for participants who want to share what stuck and what shipped
Between sessions:
30 days from today, post in the cohort Slack: what stuck, what you built next, what you taught someone else. The cohort is the asset — keep contributing to it.
Course at a glance
| Session | Day & date | Focus | What you leave with |
|---|---|---|---|
| Session 1 | Monday 15 June | Open the Terminal — Your AI Operating Environment | with Claude Code running in your terminal, connected to your work, and you have used it to do something real on your own data — not a demo. |
| Session 2 | Wednesday 17 June | AI as Personal Operating System — Productivity at the Speed of Thought | with Claude Code wired into your daily work — calendar, email, documents, research — and you have replaced your first real workflow. |
| Session 3 | Friday 19 June | Agentic Workflows — When AI Does the Work, Not You | with a working agentic workflow — a multi-step task where Claude Code plans, acts across your tools, and reports back, with you reviewing not micromanaging. |
| Session 4 | Monday 22 June | From Idea to Working Software — Build, Day One | with the core of your shipping artifact running on your machine. Not theoretically. Running. |
| Session 5 | Wednesday 24 June | Ship Day — Deploy and Share | with your tool deployed, accessible to other people at your company, and ready for someone other than you to use it. |
| Session 6 | Friday 26 June | What Changes Monday — From Cohort to Practice | with a deployed tool used by at least one other person at your company, a 30-day commitment for what you'll build next, and a peer cohort that compounds long after the course ends. |