Everything is now ONE academy with one path. Five levels, each with its own page, tests, and a gate: pass the level's exam before moving up. The old track names are gone — here's the map so nothing from before is lost.
Green = passed, tap anytime to review. The teal dot = your current step. Locked steps open when the one before is passed. Dashed dots are reference stops — always open.
1. Order is law. Level 0 before 1, 1 before 2. Every "advanced" confusion you've ever had came from a skipped basic.
2. Gates, not vibes. A level counts as passed when its exam score meets the bar (Level 1: 8/10 · Levels 2–3: all module quizzes complete with ≤1 miss each after retake). Report each gate in chat — that's the accountability.
3. Spaced retakes. Any quiz you missed questions on: retake it 1 week later, then 3 weeks later. This is when knowledge actually moves into long-term memory — skipping it means re-learning everything in the interview chair.
4. Doing beats reading. Every level has homework tied to your real projects. The portfolio artifacts ARE the expert level; there is no reading path to expertise.
Fifteen concepts. Assume you know nothing — because pretending is how gaps survive. Tap each card, read all four rows, no exceptions.
One trick, repeated. It chops your text into chunks, guesses the single most likely next chunk, sticks it on the end, and guesses again. That is all. Nothing here looks anything up — which is exactly why it can sound certain and still be wrong.
Karpathy, and still the clearest hour anywhere on what the box in the middle of that picture is doing. Watch it in two sittings.
The long version, for later. Thirty minutes at a time — never in one go.
Six questions. Pass = 5/6. Misses unlock a simpler lesson; retake in 1 week regardless.
You asked what the best learning design is. Here's the honest answer, and how every piece of it is wired into these pages.
Session A (45–60 min): new module — cards/lesson, then quiz cold. Session B (45–60 min): second module OR homework on a real project. Session C (30 min): retakes of last week's misses + 10 minutes of Tutor drilling. Rest of the week: MyClienta work counts as lab time — after Level 2, every client task doubles as practice. Two focused sessions beat seven distracted ones; put A and B in the calendar like client meetings.
Your four postings were examples of families. Here's the whole map: what each family does, and which academy level makes you dangerous in it. Titles vary wildly ("Digital Lead", "AI Specialist", "Transformation Manager") — match by RESPONSIBILITIES, not titles.
1. Build, advise, govern, or teach? Every AI role is a mix of these four verbs — find the dominant one and you know the family, whatever the title says. 2. Which level does it test? Words like "use cases, governance, stakeholders" = Level 2. "Agents, prompts, MCP, integration" = Level 3. 3. What's the one hard filter? (degree, years, a named tool, a language). Decide honestly if you pass or can argue it. 4. What proof would make them relax? Then bring THAT artifact to the interview. Paste any posting into the Level 2 Tutor and it runs this decoder with you.
The honest ledger. Update it in chat as gates fall.
Every module: a story from your business, plain-language deep dives, a test. Wrong answers unlock a simpler remedial lesson. Your progress saves on this device. The Radar looks two years ahead; the Business tab tells you what to build and who pays.
Nine tools, one job each.
The whole map in one line. Your phone shows it, the backend decides it, the database remembers it. The only rule you need: if a person could open their browser tools and change it, it cannot be trusted — so prices and permissions live on the right-hand side.
Supabase is not one thing, it is four in a box. A real database, a login system, somewhere to put files, and a ready-made doorway so your app can ask for data without anyone building one. That is why it shows up in so many small projects: it replaces about a month of setup.
The fastest way to see what is inside the box in the picture above. Four minutes, and 'backend' stops being a vague word.
Skim only the 'How it works' part. This is what serves the app you are reading right now.
Seven hops, and only one of them thinks. The doorman checks you are human, a page is handed over, the database is asked what is free, the card goes to Stripe, Stripe pokes n8n, n8n walks a checklist you drew, and Claude writes one email. Everything except Claude is following fixed instructions — which is why most of this is cheap and only the thinking step is billed by the word.
Tap one. The "mix-up" row is where the education is.
"What is agentic AI, do I have it?" Earn the answer.
Three shapes, not three technologies. A straight line does the same thing every time. A branch picks between paths you already wrote. A loop is allowed to decide for itself — which is powerful and is why it should be your last choice, not your first.
Watch the loop turn once on screen, then try to redraw the picture above from memory on paper.
You have been building the middle shape for two years. This gives you the words for it.
The most quoted piece on this. Its point is the green box above: most things called agents should be workflows.
One question separates all three: who decides the next step?
Trigger fires → fixed steps run. Same thing every time, zero judgment. A light switch with extra steps.
Fixed steps, but a step calls AI — "write this email", "score this ad". The path never changes; only words inside it do.
You give a goal. The AI picks tools, order, checks its own result, loops until done or gives up.
Rule of thumb: if you drew every arrow and the path never changes, it is a workflow — however much AI sits inside the boxes. One exception worth knowing, because an interviewer may raise it: n8n has an AI Agent node, so a workflow you drew can contain a real agent inside one step, choosing its own tools. The test is not who drew the canvas — it is who decides the next step.
Marketing words don't count.
You own zero agents. Everything you've shipped is automation or AI workflow — and that is a feature. Workflows are predictable, cheap, debuggable: what a paying client wants. Agents fail creatively. The only real agent in your business is the one you use: Claude Code.
Sales rule: say "AI-powered automation," not "AI agents," until you've built one. Clients who know the difference multiply monthly.
Try both live on fake RentingPilot data.
The model itself remembers nothing at all. Every time it seems to, something you built went and fetched the fact and pasted it back in. Getting a booking number approximately right is useless — so exact facts go in a table, and "something like this came up before" goes in the vector store.
Covers all three columns above in one go, which is right — they are the same idea at different timescales.
Only if you want to see the table actually being made. Dip in, do not binge it.
SQL is a strict spreadsheet: exact rows, exact matches. Vector is a librarian who finds things by meaning, even when no words match.
Pick a search, then flip the mode and run the same search:
You use SQL only. Supabase runs Postgres — rows and columns. Perfect for bookings, licence keys, client records. Vector memory stores text as lists of numbers ("embeddings") where similar meanings sit near each other — needed for exactly one job: searching documents by meaning, the heart of RAG.
Good news: Supabase has a vector add-on, pgvector. When the day comes, no new tool — just a new switch in one you already own.
Don't add a vector DB because it sounds advanced. No current client project needs one.
You pitched RAG in a 17-slide deck. Own what you pitched.
The model is not searching — it is being handed the right pages to read. Everything before the last box is ordinary look-it-up plumbing. Which is why when the answers are bad, you go and look at which chunks came back, not at the prompt.
One whiteboard, the whole idea. It is the picture above, drawn by someone talking.
Second pass, slightly deeper. Watch it the day after the first one, not straight after.
Only if 'into numbers' in the diagram still feels like magic.
Claude is a brilliant contractor with total amnesia. RAG = Retrieval-Augmented Generation: look up the relevant notes first, staple them to the question, then let the brain answer.
1 — Tokens. You pay per chunk of text, in and out. Every retrieved document stapled to the prompt costs money on every question. Over-fetching RAG is a quietly bleeding bill.
2 — Retrieval quality. Wrong notes fetched → confident answers from wrong notes. RAG moves the problem from "the brain" to "the librarian."
Your Knowledge Assistant deck — local model, no data leaving the building — is textbook RAG. You can now defend every slide.
Four taps, the tree answers. Run it for several projects.
A domain name is a phone book entry, nothing more. Your phone asks what address the name points to, connects there, and files come back. When the files are the same for everybody they can be copied worldwide and arrive instantly — that is why a static site is fast and free.
Look for the difference between static files and functions. Your academy is pure static — that is why it is free.
The seven things a developer sees that you currently don't. Learn them and you stop being hostage to jargon.
Six steps, and the last one is the one that matters. Everything up to "deploy" is bookkeeping. Going and looking at the real site afterwards is what tells you a real person can actually see the change — because a deploy can succeed and still deliver nothing.
The part of development you will personally do most. Treat prompts like the boxes above: versioned, reviewed, never edited live.
The #1 developer skill: reading an error calmly. Three real-style errors from your world — classify each.
"You're using this, but you could use that." For each slot: what you run, the alternatives, and the honest switch verdict.
Each layer sits on the one below. A restaurant has a menu (API). Telling a guest the menu exists is tool calling. MCP is printing every restaurant's menu in the same format, so one guest can read all of them without learning each layout — that is the whole idea, and it is about saving integration work, not making the model cleverer.
The third layer in the picture, from the source. Look for 'write once, plug in anywhere' — that is the business case.
Do it alongside the video rather than watching it. Fifteen minutes, and you have built the middle layer yourself.
Notice the verdicts: stay, stay, stay, stay, stay, consider-one. That's not laziness — your stack is genuinely well-chosen for a one-person shop. The trap for self-taught builders isn't picking wrong tools; it's switching tools to feel productive instead of shipping. Tool-shopping is procrastination wearing a work costume.
Six business models your stack supports, each with the co-founder questions: who pays, when, how much effort. Verdicts included.
Price against what the problem costs them, not what it costs you. Then check what is left after every cost — including your own hours answering the phone. A customer whose usage triples can turn a good contract into a losing one, which is why the ceiling goes in writing at the start.
Read it again with a cost eye. Every extra loop turn in module 2 is a paid call in this one.
Both your paying clients — Sorin and Valentin — are rental businesses. That's a vertical, not a coincidence. Client #3 in rentals costs a week; project #21 in a new field costs a quarter. Every idea above got its verdict by one filter: does it make the rental vertical stronger? Use the same filter on every idea you have this year.
Where technology moves in ~2 years and what each move does to your money. Honest label: informed bets, not certainties. Refresh this monthly in chat — a file can't watch the news.
Ten questions, all eight modules. Pass mark 8.
Live — saved on this device.
Take the module tests. This panel scores you as you go and names your weakest area.
Track 1 (your installed app) taught you how the technology works. Track 2 teaches what AI Strategy & Adoption roles are actually tested on: use-case prioritization, data readiness, governance, vendor assessment, and translating AI for humans. Built from a real posting — the Vestas AI Strategy & Portfolio Advisor role.
Foundation → frameworks → proof. Each week fits your hours.
Everything here feeds BOTH targets. Use-case prioritization = interview answer AND how you scope MyClienta client work. Governance = job requirement AND what lets you sell AI to serious Danish companies. Vendor assessment = job skill AND your own build-vs-buy decisions. Nothing you learn is single-purpose — that's why both-in-parallel is realistic at 5–7 hrs.
The core skill of the Vestas role, in its own words: "identify, scope, and prioritize AI use cases with clear business value."
Two honest scores, not one feeling. Value is money per year. Feasibility is whether it can actually be built — is the data there, is the process stable, is the tech proven. Score them separately and the argument stops being about opinions. The square that earns your fee is the bottom left: anyone can be enthusiastic, but killing a bad idea before a quarter is spent on it is the advisory part.
Read it as a prioritisation argument: its preference for boring fixed workflows over agents is the same instinct as picking feasible use cases over exciting ones.
Companies don't have an AI problem — they have a too-many-ideas problem. Everyone wants "AI for something." The advisor's job is being the adult who asks: which ideas are worth money, and which are toys?
Every proposed use case gets two honest scores. Value: money saved or earned, per year, if it works. Feasibility: is the data available and clean, is the process stable, is the tech proven for this job?
This is a shape, not your history. Every dotted blank is yours to fill with something you actually did. Never say a number you did not measure — the follow-up question is always “how did you measure that?”, and that is where borrowed detail falls apart, in front of the person deciding whether to hire you.
"Ensuring initiatives are grounded in data reality before resources are committed" — Vestas, verbatim. The unglamorous skill that separates advisors from enthusiasts.
Ask them in this order and stop at the first no. There is no point grading the quality of data you cannot reach, and no point cleaning data you are not allowed to use. Most failed AI projects failed right here, before anyone chose a model — which is why running this check in week one is the most useful thing an advisor does.
Relevant because embedding dirty, inconsistent text gives you dirty, inconsistent retrieval. Garbage in is arithmetic, not a slogan.
AI is a chef. Data is the ingredients. Most failed AI projects didn't have a bad chef — they had an empty or rotten fridge, discovered after hiring the chef. The advisor's job: inspect the fridge before signing the chef.
You've lived this: the Kaeli veterinary project stalled on inaccessible CVR data, and Smaafolk needed a whole enrichment pipeline before the map was useful. That pipeline WAS data-readiness work. Now you have the professional name for it.
This is a shape, not your history. Every dotted blank is yours to fill with something you actually did. Never say a number you did not measure — the follow-up question is always “how did you measure that?”, and that is where borrowed detail falls apart, in front of the person deciding whether to hire you.
In every EU posting now — Vestas asks for "guidelines, guardrails, and responsible use practices." Your biggest gap; also the fastest to close, because it's rules, not math.
It regulates the use, not the technology. The same model is minimal risk writing marketing copy and high risk screening job applicants. High risk does not mean banned — it means allowed with duties: risk management, human oversight, documentation, accuracy monitoring. Telling a frightened client that most of what they do sits in the bottom band is often the most valuable sentence in the meeting.
The clearest plain-language summary there is. Learn the four tiers well enough to place an example without hesitating — that fluency is what an interviewer is testing.
The official source. Worth being able to say you read the Commission's own page rather than a blog about it.
Governance sounds boring until you translate it: who is allowed to let a machine make which decisions, and who answers when it's wrong. That's it. Everything else is paperwork around that question.
This is a shape, not your history. Every dotted blank is yours to fill with something you actually did. Never say a number you did not measure — the follow-up question is always “how did you measure that?”, and that is where borrowed detail falls apart, in front of the person deciding whether to hire you.
"Supporting build-vs-buy decisions, including structured assessment of AI vendors" — you do this weekly by instinct. Here's the structure that makes it a credential.
This is where ten years of finance operations beats a computer-science degree. Reading a total cost of ownership properly is rarer in AI rooms than knowing what a transformer is. The first line catches most people: usage pricing is cheap at demo volume and brutal at production volume, and nobody finds out until the third invoice.
Read the complexity argument as a build-versus-buy one: every component you build yourself is one you must also maintain, monitor and staff.
Every vendor demo is a first date: everyone's charming, nothing's broken, and the price of leaving is invisible. The advisor is the friend who asks the unromantic questions.
Buy when the problem is generic (email, CRM, transcription) — your differentiation isn't there. Build when the process IS your edge or vendors would own your core data. And the third option interviews forget: wait — when the category is improving 50% a year, this year's purchase is next year's regret. Cite voice AI.
This is a shape, not your history. Every dotted blank is yours to fill with something you actually did. Never say a number you did not measure — the follow-up question is always “how did you measure that?”, and that is where borrowed detail falls apart, in front of the person deciding whether to hire you.
"Translating complex AI concepts into clear, actionable language" + "supporting AI literacy initiatives." Your strongest card — sharpened.
Say "dial" and the conversation changes. A nervous stakeholder hears yes-or-no and says no. Offer four notches and they pick one — which means they own the decision instead of resisting it. You start at the left, and the system earns its way right on evidence rather than on your enthusiasm.
Read the AI literacy obligation specifically. A legal duty to train staff is a budget line, and a budget line is a job.
The advisor's real product isn't analysis — it's calibrated expectations. Too much hype and the project dies at first error; too much fear and it never starts. You manage the thermostat.
Structure that works: one live demo on THEIR real task (not a canned one) → the three-tier trust dial → hands-on with their own example → one page of do/don't (never paste client personal data into public tools). One hour, no slides beyond five. You've effectively been doing this for clients — now it's a named deliverable.
This is a shape, not your history. Every dotted blank is yours to fill with something you actually did. Never say a number you did not measure — the follow-up question is always “how did you measure that?”, and that is where borrowed detail falls apart, in front of the person deciding whether to hire you.
What's out there, your fit today, and the gap this academy closes. Paste your LinkedIn postings into the Tutor to map any specific one.
Match on responsibilities, never on the title. The same job is called Digital Lead, AI Specialist and Transformation Manager. Read the verbs instead. And the fourth question is the one that changes outcomes: rather than deciding whether you qualify, decide what to build so the question stops being asked.
The AI Auditor and compliance families exist because of this regulation. Reading the source is how you talk about those roles credibly.
Pattern to notice: every emerging role rewards the same combination — operational experience + governance vocabulary + the ability to teach. That's precisely the stack this academy builds. Not an accident.
Ask anything — a term you don't get, a mock interview question, "explain simpler," or paste a job posting to map it against your profile. It knows your background and this curriculum.
Track 1 told you what an agent is. Track 2 told you how to advise about them. Track 3 opens the hood: the anatomy of an agent, prompt engineering, tools and MCP, memory, the end-to-end process of building anything, and how professionals test what they built. Written for someone who has been saying the words to Claude Code — so the words finally have machinery behind them.
Match / gap / action for each — from the actual postings you pasted.
Every posting wants the same trinity: ops experience + hands-on AI + the ability to explain. Nobody asked for a computer science degree. Two asked for governance awareness (Track 2), two asked for agent/MCP fluency (this track). The market is describing you — it just doesn't know your name yet. Your job in interviews is closing that last gap: translating MyClienta into their vocabulary.
Every agent on earth — Claude Code, a support bot, a research agent — is these six parts. No exceptions.
The model never runs anything. It asks, and your code decides — that gap is the whole security model, and it is why every permission, limit and confirmation belongs there rather than in the prompt. Say this in an interview and you have separated yourself from everyone who thinks an agent "does things".
The canonical piece. Its central claim — prefer a fixed workflow, go agentic as late as possible — is the most senior-sounding thing you can say on this topic.
Watch the loop turn once, then redraw the picture above from memory on paper.
An agent is not a magic being. It's a loop wrapped around a language model, with hands attached. Learn the six organs and you can read any agent product's marketing and see exactly what's inside.
When the model "uses a tool," here is literally what happens: the model outputs a structured message — {"tool":"check_fleet","date":"Tuesday"} — your code sees it, runs the real database query, and pastes the result back into the conversation as text. The model then reads it and continues. The AI never touches anything. It writes requests; your plumbing does the work. Once you see this, "agentic AI" stops being mystical: it's a conversation where some replies are executed.
SimCorp lists it as a requirement. It's not magic words — it's writing job descriptions machines can't misread.
Format is the one that pays immediately. If the model returns a friendly sentence where the next step expects JSON, the workflow breaks in a way that looks like an AI problem and is actually a specification problem. And two worked examples teach more than three paragraphs of description — for machines as much as for people.
The part of building you will personally do most. Treat prompts as code: versioned, tested, never edited live in production.
A prompt is a briefing for a brilliant contractor with amnesia. Everything they need must be in the briefing — role, task, rules, format, examples — because they know nothing about you and forget everything after.
Same model, same cost per attempt — wildly different reliability. Prompt engineering is cheap engineering: you're buying error-rate reduction with words.
"Advise functions on connectors to enterprise systems and MCP servers" — SimCorp, word for word. Here's what those words mean.
Three layers, each sitting on the one below. A restaurant has a menu. Telling a guest the menu exists is tool calling. MCP is printing every restaurant's menu in one format so a guest can read all of them. The business case is integration economics, not intelligence — and saying that limitation out loud is what makes you sound like a practitioner.
The third layer, from the source. Look for write-once-plug-everywhere — that is the business case, and the business case is what gets asked.
See how a tool is actually described to a model: a name, a description, typed arguments. Nothing more mystical than that.
How to design a tool a model can use well — the difference between an agent that works and one that flails.
Before MCP, connecting an AI to each system was a custom-made cable — one per tool, per AI, built by hand. MCP (Model Context Protocol) is the USB standard for AI: one plug shape, so any AI can connect to any system that speaks it.
A company like SimCorp has dozens of internal systems and wants MANY AI use cases. Custom cable per pair = chaos and security holes. MCP = one governed doorway per system, with permissions controlled in one place. It's not a fancy feature; it's how AI access scales and stays auditable. Say that sentence in the interview and you're ahead of most candidates.
And you already live it: n8n's newer AI features, Claude's connectors, the tools Claude Code uses — MCP under the hood. You've been a user; now you're a speaker.
The most misunderstood part of every AI system — and where Track 1's SQL/vector module becomes engineering.
Exact facts to SQL, meaning to vectors. Getting a booking reference approximately right is worse than no answer, so references never go in a vector store. "Has this customer complained about something like this before?" is the opposite — that is exactly what meaning-search is for. Sorting facts into those two buckets is most of practical memory design.
Covers all three columns above together, which is right — they are the same idea at different timescales.
The model's only "memory" is the text currently in front of it — the context window. Think of it as a desk: whatever papers are on the desk right now, it knows; everything else in the universe, it doesn't. Memory design = deciding which papers your system puts on the desk, every single turn.
Not "how much memory?" but "what does this turn NEED on the desk?" Too little → the agent asks customers to repeat themselves (feels broken). Too much → slow, expensive, and the model gets distracted by irrelevant papers (real phenomenon — more context is not always better). Professional memory design is curation, not accumulation.
How anything AI gets made — the same eight steps whether it's a workflow, an agent, or a whole product. This is the process you've been doing blind with Claude Code; now it has names.
Narrow but finished, not broad and half-done. A thin slice is one input type handled completely, in production, for one client. The instinct to build everything at once is the thing this rule exists to cure — and "workflow first, agent only when the paths genuinely cannot be listed" is the same instinct applied to the design.
Read it as a process argument this time: start simple, add complexity only when it demonstrably earns its place.
Thin slice first. Build the narrowest complete path — ONE call type, handled end-to-end, in production for one client — before adding breadth. A thin slice teaches more in a week than a full build teaches in a quarter, and it can start earning. Your instinct to build everything at once is the enemy; this rule is the cure.
Workflow first, agent only if forced. Start every design as a fixed workflow. Promote a step to agentic (letting the model choose) only when the paths genuinely can't be enumerated. Cheaper, more reliable, easier to debug — and when an interviewer asks "when would you use an agent?", this answer signals maturity: "as late as possible."
The professional's edge: anyone can build an AI thing; few can prove it works. Plus: what "multi-agent" really means.
Do this once and you are ahead of most people calling themselves AI builders. Thirty real messy inputs beat three hundred invented clean ones, because invented cases share your assumptions. And the score is not just an engineering tool — it is the most persuasive thing you can put in front of a client, because it is the only honest answer to "does it work".
Pay attention to the case for measuring before adding complexity. An eval is what makes that possible rather than aspirational.
Normal code is tested with exact answers: 2+2 must equal 4. AI output varies — same input, different words. So AI is tested like an employee, not a calculator: give it 50 realistic tasks, grade the results, track the score over time. That grading set is called an eval.
Evals are also your margin machine: they're what lets you safely downgrade steps to cheaper models (Track 2, C4) — because "cheaper" is only real if the score holds.
"Multi-agent" = several specialized loops handing work to each other, usually via an orchestrator — a manager agent that routes tasks: one agent reads the email, one checks the fleet, one drafts the reply, orchestrator assembles. Why split? Same reason companies have departments: a specialist with a short, focused job description outperforms a generalist with a 5-page one. Smaller prompts, clearer tools, easier testing per agent.
The honest counterweight for interviews: every handoff adds cost, latency, and a new failure point. The professional starts with ONE agent (or a workflow), splits only when one job description becomes overloaded. "Multi-agent" in a vendor pitch is a design choice to interrogate, not a quality badge to admire.
Everything an AI advisor/builder needs, and where it lives. What remains is not content.
Three tracks, ~14 hours of study, everything the four job ads ask for. From this point, more curriculum is procrastination with a syllabus. The order now: Track 1 scores → Stripe Live → weekly module + homework → portfolio → interviews. The academy's success metric was defined in C1 style: "Djoko explains any of this to a stranger, unaided, and lands interviews that test it." That number moves only when you press start.
Every grey code snippet and strange tool name from your Claude chats — wrangler, dist, push, branch, robots, secrets — decoded on your real systems: the academy, RentingPilot, jobalarm. Read cards in any order. No gate; the quiz at the bottom is for proving it to yourself.
Tap each card, read all four rows — same method as Level 0.
No gate on this track. But if you score under 5, the cards deserve a second pass.
Ten questions from memory, about four minutes. Miss one and it comes back tomorrow.
Mixed on purpose — consecutive questions come from different modules.
Every question you have missed, worst first. This list is the honest one.
Thirty-two terms. You are shown the meaning and must produce the word.
Four minutes of reading that makes every other hour in this academy worth more.
Each question sits in a box from 1 to 5. Answer it right and it moves up a box and goes quiet for longer. Miss it and it drops straight back to box 1 — tomorrow. That is the entire schedule; nothing to configure.
| Box | Comes back in | What it means about you |
|---|---|---|
| 1 | Tomorrow | New, or you just missed it |
| 2 | 2 days | One clean hit — fragile |
| 3 | 4 days | Holding |
| 4 | 9 days | Solid |
| 5 | 3 weeks | Yours. It will still check on you. |
At the end of every drill you get one question to explain out loud, in your own words, with the screen dark. Talk to the wall, your phone's voice recorder, or your wife. If you stumble or reach for the phrase from the card, you recognised it — you do not own it yet. That stumble is the most useful information in this whole app, and it is exactly what happens in an interview chair when someone asks "so what is MCP, actually?"
Pair it, order it, pick every one that applies, answer a real client out loud. Miss one and it comes back tomorrow.
Three exercises each, about six minutes. A module appears once its own quiz is done.
One question, sixty seconds, out loud. Then a model answer and an honest self-grade. This is the actual test you are training for.
Specific videos, specific docs, and one thing to actually go and do. Every link here was checked before it shipped.
What each family is tested on, and which artifact makes them relax about you.
Titles vary wildly — “Digital Lead”, “AI Specialist”, “Transformation Manager”. Match by responsibilities, never by title.
Which level makes you dangerous in each family.
The Expert phase is not a page to read — it is these, built and shown. Tick a line when it is genuinely true.
Scores you produced yourself. Cases and interviews are self-graded — they are worth exactly what your honesty is worth.