Meridianby Lex AIAI training for companies
The fastest teams aren’t smarter.
They’re AI-native.
Your people already know their job. What changed is what a model can do beside them — and that is specific, learnable, and mostly not being taught anywhere. Meridian teaches what a model actually is, where it breaks, and how to put one inside the work your team already ships.
The programs
One method, pointed at different work.
Each program teaches the mechanism, practises it in the tool your team actually uses, and ends in something they built. The audience changes. The method does not.
AI for Development
Engineers, architects, and the leads who review their work
What a model actually is, where it breaks, and how to put one inside something you ship. Every mechanism is rebuilt in code that runs in the page — not described, executed.
- Agent loops, context engineering, and the Model Context Protocol
- Transformers and attention, built from the arithmetic up
- Retrieval, evaluation, and why a fluent answer can still be wrong
- System design for AI systems, with auto-graded architecture labs
AI for Sales
The people who carry a number. No code required
What the model is doing when it writes your email, where it will be confidently wrong, and how to catch that before a customer does.
- AI-assisted insight building on an account
- Outreach that survives a reply, and proposal drafting
- Building a sales agent that does the repetitive half
- Prompt and context engineering, for people who never open a terminal
How we teach
Seven ways into the same idea.
Nobody should be blocked because their way of learning isn't served, so a lesson arrives in more than one form — and the forms are not interchangeable. The quiz is where a claim gets tested, the playground is where it gets computed, the canvas is where it gets defended.
Video
A walkthrough for the parts that are faster watched than read — the shape of the idea before the detail of it.
Notes
The written lesson, pitched at an hour of engaged study rather than a skim. Depth over coverage: twelve things properly, not forty thinly.
Visuals
Interactive figures built for one mechanism each. You drag the parameter and the picture re-derives — nothing on screen is a screenshot.
Quiz
One question per concept in the lesson, with an explanation on every option. It sits before the lab, so the lab is the payoff and not the test.
Hands-on coding playground
Real Python running in the browser — nothing to install. The closing lab recomputes the exact numbers the lesson opened with.
Code explainer
Step through a program line by line and watch the state change beside it, instead of reading a finished listing and hoping.
System design canvas
Draw the architecture and have it graded against the constraints — the interview surface, practised on the surface it is conducted on.
// this one, for instance Lifted straight out of the System Design course — the same component, not a mock-up of it. Press Auto, or drag the load yourself, and watch what a single machine does at its ceiling while a pool of them shares the same traffic.
▶ Interactive · Vertical vs Horizontal
Two ways to grow — up vs out
Left: one machine fills toward its hardware ceiling. Right: 3 servers share the load, so each stays ~15% busy — add more to stay cool.
Who it is for
You are not buying a course. You are buying a change on Monday.
Content alone does not move behaviour — an engineer who has read about agents and never shipped one goes back to their old habits on day sixteen. So the programs are built around what happens after the reading.
Service firms and product teams
Your engineers already know how to build software. What changed is what a model can do beside them — and that is specific, learnable, and mostly not being taught anywhere.
- Role-shaped, from one pool
- Engineers, sellers, and leads take different paths through shared material. One lesson, one URL, many audiences.
- 10–15 days on-site
- Content alone does not change behaviour. We sit with the team and make them ship something real with AI, because an engineer who has felt it work once needs no further convincing.
- The tool rotates on purpose
- Lessons teach what does not expire. Labs run in the current, real tool and deliberately change, because being dropped into unfamiliar tooling and reasoning your way in is the actual skill.
- Where AI is wrong, taught as hard as where it is right
- Reviewing model-written work is a genuinely new skill and almost nobody has been trained on it. Whoever teaches it first has people who can defend the work.
What you can show upward
Before-and-after measurement per team, captured before the engagement starts — the instrument is in build, and we scope the baseline with you rather than backfilling it later.
How a program runs
Knowledge, then habit, then evidence.
Four layers that compound. The first is software you log into; the second and fourth are us in the room; the third is the instrument that says whether any of it worked.
- 01
The platform
knowledgeSelf-serve curriculum your people log into. Lessons that compute their own numbers, interactive visuals you can drag, quizzes, and labs that run in the page.
- 02
The immersion
habit10–15 days on-site. Hands on keyboards, building something that deploys. The goal is not the artifact — it is the flip in belief that this makes them faster when used well.
- 03
The proof
evidenceBefore-and-after productivity for the people who went through it, sliced by team. Credible to an engineer, not merely flattering to a VP — lessons-completed is a vanity number and we will not report it as an outcome.
- 04
The culture
identityHackathons, outside speakers who are genuinely doing this work, and interview readiness. Knowledge decays unless the environment around it changes.
Why it holds
Four things that don’t expire.
Tool tours rot faster than the course is long. These are the commitments underneath every program, and they are the reason a lesson written today is still true after the next release.
The tool is not the content. It is the terrain.
Lessons teach the mechanism and must survive any vendor’s next release. Labs run in the real, current tool and deliberately rotate — because being dropped into unfamiliar tooling and reasoning your way in is the skill that does not expire.
Generation got cheap. Judgement did not.
Someone who has never watched a model fail confidently does not know what it can be trusted with. We teach where AI is wrong as hard as where it is right.
Every number is computed, never estimated.
Any figure a lesson prints — a token count, a latency, a cost — is produced by running the code, and the closing lab makes the learner regenerate exactly those numbers themselves.
Hands-on, or it didn’t happen.
Reading about an agent does not produce someone who can ship one. Every lesson ends in work: you build it, run it, break it, and measure it.
Start a program
Tell us what your team cannot do yet.
We will tell you which of it is trainable, which of it is a tooling problem wearing a training costume, and what a first cohort would look like. If a program is the wrong answer for you, that is a cheaper thing to find out now than in month four.