The structured curriculum\nfor the next decade of engineering.
A 6-module institutional curriculum for engineering teams adopting agents. Hand-built by senior engineers who run real teams shipping real software. Every lesson runs in OpenClaw sandboxes — your engineers learn on real production-shaped problems, not slideware.
What changed in 2024-2026. Where senior engineers spend their time now. The skills that compound and the ones that don't. A clear-eyed map.
The eight tools every team needs in their agent stack. The trade-offs. How to pick. How to migrate when you're wrong.
How to review code when half of it comes from an agent. The new red flags. The conversation you have with the engineer (and the one you have with the agent). The taste-transfer pattern.
The big-refactor playbook with agents in the loop. How to move 100k lines without breaking production. The five-stage rollout pattern.
Where agents fit in your CI/CD. The eval gate. The cost gate. The kill switch. The patterns the best teams converged on in 2026.
Running a 6-12 person engineering team in the agent era. Standups, retros, on-call, hiring, mentoring. The practices that work and the ones that broke.
Modules covering the full team practice
Lessons designed for engineering teams
Of guided practice on team-shaped problems
Engineering teams shipped a curriculum-based program
Because real practice needs a real computer.
Most courses teach you to call an API, then leave you on your own. The OpenClaw Engineering Curriculum is built on OpenClaw because OpenClaw gives every student a real isolated machine: a browser, a terminal, a file system, and credentials to actual tools. You do real work, not pretend work.
A real linux box per lesson.
Every lesson in The OpenClaw Engineering Curriculum spins up your own private OpenClaw sandbox — a real Ubuntu machine with a real browser, real terminal, and a real home directory that persists. You write code that touches real files, opens real URLs, and ships real artifacts.
Your tutor IS an OpenClaw agent.
You're not watching videos. Praxis reads your code in real time, runs it in your sandbox, debugs alongside you, and asks the right next question. It remembers what you've already learned and what tripped you up last lesson.
Ship to your own stack.
By the time you hit Module 04 you're connecting your work to your real tools, your real data, your real environment. The course doesn't end with a toy demo — it ends with something you actually use, every day.
Six modules. One real thing shipped by the end.
Each module is self-contained but builds on the previous one. Start free with Module 01 — by Module 06 you're shipping from your own terminal.
The shift: hand-coding to agent-coding
What changed in 2024-2026. Where senior engineers spend their time now. The skills that compound and the ones that don't. A clear-eyed map.
- 01What 'agent-coding' actually is (and isn't)
- 02The new senior-engineer time map: drafting, reviewing, judging
- 03Skills that compound: judgement, taste, system design
- 04Skills that don't: typing speed, framework memorisation, library incantations
- 05Lab: audit your last week and re-allocate it
Tooling foundations
The eight tools every team needs in their agent stack. The trade-offs. How to pick. How to migrate when you're wrong.
- 01The eight-tool baseline: editor, agent, sandbox, eval, log, cost, observ., deploy
- 02Picking your editor + agent: a decision flow
- 03OpenClaw vs other sandboxes: when to use each
- 04The 'switching cost' equation when you want to migrate
- 05Lab: stand up the eight-tool baseline for a fresh team
Agent-aware code review
How to review code when half of it comes from an agent. The new red flags. The conversation you have with the engineer (and the one you have with the agent). The taste-transfer pattern.
- 01The four new code-review red flags
- 02Talking to the engineer about agent-drafted code
- 03Taste transfer: how to teach the agent your style
- 04The 'agent-shaped over-engineering' antipattern
- 05Lab: review three real agent-drafted PRs with the Tutor
Migrations and refactors at scale
The big-refactor playbook with agents in the loop. How to move 100k lines without breaking production. The five-stage rollout pattern.
- 01The five-stage rollout: dark, shadow, canary, partial, full
- 02Drafting a migration plan with the Tutor
- 03Test scaffolding for a refactor that touches 80 files
- 04When to abort a migration (and the cost of not aborting)
- 05Lab: a real 200-file refactor in your sandbox repo
CI/CD with agents in the loop
Where agents fit in your CI/CD. The eval gate. The cost gate. The kill switch. The patterns the best teams converged on in 2026.
- 01Where to insert an agent in your CI/CD pipeline
- 02Eval gates that stop bad builds
- 03Cost gates: when to fail a PR for being too expensive
- 04Kill switches: the one button you need that nobody talks about
- 05Lab: wire an eval + cost gate into a real CI run
The team practice
Running a 6-12 person engineering team in the agent era. Standups, retros, on-call, hiring, mentoring. The practices that work and the ones that broke.
- 01Standups when half your team is working with agents
- 02Retros: the new failure modes worth talking about
- 03On-call when an agent is shipping at night
- 04Hiring senior engineers in 2026: what to look for
- 05Lab: run a real team retro with the Tutor as facilitator
Watch a lesson run.
This is Module 03 · Lesson 03 — taste transfer — Praxis walks a student through a real problem in their OpenClaw sandbox. Reads the code, runs it, sees the failure, shows the fix.
Four real things you'll have shipped.
Every module ends with a project that runs in your sandbox and produces a real artifact. Not toy demos — real working things you'll keep using after the course is over.
Module 01 graduation project
The first thing you'll ship in The OpenClaw Engineering Curriculum. A small but real artifact that proves the foundation lessons stuck. Runs in your OpenClaw sandbox by the end of week one.
A working artifact you'll keep using after the course is over — not a notebook, an actual tool.
Module 03 graduation project
The mid-course project. By Module 03 you've got enough of the core down to ship something with real moving parts. The Tutor reviews every commit.
A working system with real parts — the kind of thing you'd put in a side-project portfolio.
Module 05 graduation project
The advanced project. Combines what you learned in Modules 04 and 05 into one real-world build. The kind of thing senior engineers actually ship.
A senior-level artifact: the system you'd talk about in an interview as 'the thing I built that taught me X'.
Module 06 capstone
The final project. End-to-end, production-shaped, deployed from your sandbox. The Tutor stays online while you ship it.
Your portfolio piece. Deployed, observable, and small enough that you actually understand every line.
Meet your instructor.
Praxis is an OpenClaw agent that runs alongside you in your sandbox. It's not a chatbot bolted onto a video — it actually reads your work, runs it, sees the failures, and shows you the fix. Persistent memory means lesson 12 isn't lesson 1 all over again.
Reads your code in real time.
Praxis watches your sandbox file system and your terminal output. When you save a file it's already up to speed before you click 'help'.
Runs your code for you.
Praxis has its own shell in your sandbox. It can reproduce a bug in 4 seconds and tell you exactly which line is failing.
Remembers your past mistakes.
If you tripped over something in Module 02, Praxis will quietly catch the same pattern in Module 04 and call it out before you even hit run.
Adapts the pace to you.
If you're flying, lessons get shorter and the labs get harder. If you're stuck, Praxis slows down and adds practice exercises until the concept clicks.
Never says 'as an AI'.
Praxis has a personality — direct, dry, allergic to hedging. It tells you your code is wrong when your code is wrong, and tells you when you've done something clever without flattery.
Lives in your sandbox forever.
After the course ends Praxis stays — paste any code into your sandbox and it'll review the same way it reviewed your homework.
From engineers who shipped.
From engineering managers and team leads who ran the curriculum as a 4-week sprint with their teams.
“I'd been 'going to take a course' for 8 months. The first module is free and 90 minutes long. By minute 45 I had a working artifact in my sandbox. Praxis catching my dumb mistake in lesson 02 was the moment I realised this was different.”
“The OpenClaw sandbox is the unlock. Every other course had me copy-paste into a notebook that died when I closed the tab. Here I had a real linux machine with my own files, and Praxis was running my actual code. It feels like pair work with someone who's done this 1000 times.”
“Module 04 was the moment something clicked for real. I had a real artifact shipped by Friday afternoon. My team thought I'd been working on it for weeks. It was four lessons.”
“I almost quit in module 03. Praxis noticed I'd been re-reading the same lesson three times and offered me a different angle that fit how I think. Clicked instantly.”
“The thing nobody tells you about courses like this is how much production / real-world stuff most of them skip. Module 06 covers the parts that pay rent. That single module saved us from a surprise that would have cost a lot.”
“I run a 12-person team. We did the course as a group over 3 weeks. Every person shipped something real in their squad by the end. The ROI calc is going to look ridiculous when I write it up.”
Questions before you start.
Free to start. Pay when you ship.
Module 01 is free forever — no credit card. Pro unlocks the rest. Team gives every person their own sandbox + group progress.
Module 01 + your own OpenClaw sandbox + Praxis for the first 5 lessons. Most people finish this in an evening.
- Module 01 (1h+, 5 lessons + lab)
- Your own private OpenClaw sandbox
- Praxis for the duration of Module 01
- Discord access
All 6 modules of The OpenClaw Engineering Curriculum, unlimited sandbox time, Praxis for the full course, and Office Hours when you're stuck.
- All 6 modules
- Unlimited OpenClaw sandbox time
- Praxis for the full course
- Weekly Office Hours with the authors
- Lifetime updates as new modules ship
- Cert of completion + project showcase
For teams running The OpenClaw Engineering Curriculum together. Per-person sandbox, group progress, and a private Slack with Praxis.
- Per-engineer OpenClaw sandbox
- Group progress tracking dashboard
- Private Slack channel with Praxis
- Custom labs tailored to your stack
- Volume discount at 10+ seats
- Priority Office Hours
Stop reading about it. Ship something this week.
Module 01 of The OpenClaw Engineering Curriculum is free forever and most people finish it in an evening. Your sandbox spins up in 30 seconds. Praxis is online and waiting.
Start the course free