The crafts that survived\nbecause the best engineers kept them.
A 6-module course on software craftsmanship for the agent era. Reading code at scale, refactoring as art, and the senior-engineer practices that don't disappear when the agents arrive — they get sharper. Built on OpenClaw so every lesson is in your hands, not on slides.
Six things senior engineers do without thinking. Why each one outlives the framework of the year. The agent that learns by watching you do them.
Reading is 80% of senior engineering. Build an agent that helps you scan, summarise, and make sense of someone else's code without losing the thread.
The refactor patterns that survive. How to know when to stop. The trap of letting the agent do too much. Real before/after on real code.
The hand-off pattern. What you stay good at. What the agent takes off your plate. How to not become the person who reads agent code all day.
Taste is the senior-engineer superpower. How to develop it. How to not lose it when shipping at agent speed. The library of patterns worth memorising.
What changed. What didn't. The 5-year plan. Where to invest your reading time. Why your judgement is the asset, not your typing speed.
Modules from foundations to senior-level practice
Hands-on lessons rooted in real codebases
Of guided practice on real production code
Engineers who finished the course this year
Because real practice needs a real computer.
Most courses teach you to call an API, then leave you on your own. The OpenClaw Software Arts Course 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 Software Arts Course 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. Atelier 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 lost crafts: what makes software last
Six things senior engineers do without thinking. Why each one outlives the framework of the year. The agent that learns by watching you do them.
- 01What Naming Things actually means (and why agents make it harder, not easier)
- 02Reading code as the primary skill: how to scan a 200k-line repo in an afternoon
- 03The deletion mindset: every file you don't write is a file nobody has to debug
- 04The taste graph: how to know when a refactor is done
- 05Lab: read a real production repo and write a 1-page architecture summary
Reading code at scale (with an agent's help)
Reading is 80% of senior engineering. Build an agent that helps you scan, summarise, and make sense of someone else's code without losing the thread.
- 01The reading-the-codebase loop: what to do, what to never do
- 02Asking the agent the right kind of question (and the kinds that waste both your time)
- 03Map and reduce: turning a repo into a one-page brief
- 04Tracing a feature from URL to database in 15 minutes
- 05Lab: ship a code-tour for a real repo, with the agent as your second pair of eyes
Refactoring as art form
The refactor patterns that survive. How to know when to stop. The trap of letting the agent do too much. Real before/after on real code.
- 01The five refactor patterns that pay rent
- 02Test as scaffold, not as goal
- 03Splitting a god-object: a guided walkthrough on real code
- 04The 'when to delete the agent's suggestion' instinct
- 05Lab: refactor a 600-line file to 250 lines without changing behaviour
The agent as a collaborator, not a replacement
The hand-off pattern. What you stay good at. What the agent takes off your plate. How to not become the person who reads agent code all day.
- 01The collaboration contract: who decides, who drafts, who reviews
- 02Code review when half the diffs come from an agent
- 03The trap of accepting too fast (and the cost a year later)
- 04Building a personal style guide the agent learns from
- 05Lab: a 4-hour pair session with the Tutor on a real feature
Building your taste: what to keep, what to delete
Taste is the senior-engineer superpower. How to develop it. How to not lose it when shipping at agent speed. The library of patterns worth memorising.
- 01Where taste comes from (clue: it's not videos)
- 02Pattern library: 12 idioms worth knowing by heart
- 03Reading code that's bad on purpose (and learning the difference)
- 04Writing for the next reader, even if the next reader is an agent
- 05Lab: critique three real PRs and write the review
The senior engineer in 2026
What changed. What didn't. The 5-year plan. Where to invest your reading time. Why your judgement is the asset, not your typing speed.
- 01The new senior-engineer skill set, mapped
- 02Where to invest the next 100 hours of reading
- 03Negotiating scope with PMs in the agent era
- 04Mentoring juniors when half their code comes from an agent
- 05Lab: write your own 12-month learning plan with the Tutor as a thinking partner
Watch a lesson run.
This is Module 03 · Lesson 03 — splitting a god-object — Atelier 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 Software Arts Course. 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.
Atelier 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.
Atelier 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.
Atelier 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, Atelier 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, Atelier slows down and adds practice exercises until the concept clicks.
Never says 'as an AI'.
Atelier 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 Atelier stays — paste any code into your sandbox and it'll review the same way it reviewed your homework.
From engineers who shipped.
From engineers who came in skeptical about 'craft in the agent era' and left convinced their judgement was the actual asset.
“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. Atelier 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 Atelier 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. Atelier 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 + Atelier for the first 5 lessons. Most people finish this in an evening.
- Module 01 (1h+, 5 lessons + lab)
- Your own private OpenClaw sandbox
- Atelier for the duration of Module 01
- Discord access
All 6 modules of The OpenClaw Software Arts Course, unlimited sandbox time, Atelier for the full course, and Office Hours when you're stuck.
- All 6 modules
- Unlimited OpenClaw sandbox time
- Atelier 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 Software Arts Course together. Per-person sandbox, group progress, and a private Slack with Atelier.
- Per-engineer OpenClaw sandbox
- Group progress tracking dashboard
- Private Slack channel with Atelier
- 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 Software Arts Course is free forever and most people finish it in an evening. Your sandbox spins up in 30 seconds. Atelier is online and waiting.
Start the course free