The agentic way · Coming soon
Learn the new Agentic Coding way
Engineering when the code writes itself.
The dojo's second course, for people who can already build software and can feel the job changing under them. Not prompt tricks. The engineering discipline of getting real, correct, maintainable systems out of machines that write code faster than you can read it.
For: Working engineers, and anyone who finished The Guide
Why this course exists
The role is shifting
For twenty years the title told you the work. You picked a layer, got good at producing code in it, and got paid for the producing. That mapping is coming apart. The scarce skill is no longer writing the code: it is deciding what should exist, directing the systems that build it, and being able to prove the result is right.
This is not AI replacing engineers. It is AI repricing engineering. Some of what you were paid for went to nearly zero. Some of it just became the whole job.
You were hired to write the code.
You are hired to decide what should exist and to prove the result is correct.
Your title named a layer: frontend, backend, mobile, platform.
Your title names a loop. The layer is whatever this week’s problem needs.
You reviewed a teammate’s pull request once a day.
You review machine output at volume, and design the checks that catch what you will never read.
You owned a service.
You own a harness: the context, tools, tests and guardrails that service gets built and maintained by.
Seniority meant years of pattern recall.
Seniority means judgment, verification and taste, and juniors are now expected to have them on day one.
You estimated in weeks of typing.
You estimate in iterations of a loop, and your job is to make each iteration cheaper.
The fastest-growing role
Harness development
A job is forming in the gap, and it is hiring faster than anything else in software. Call it agentic engineering, or harness development: the person who builds the system the agents run inside.
Not the person chatting with an assistant. The person who engineers the context it sees, the tools it can call, the permissions it cannot exceed, the tests that tell it when it failed, and the review process that catches what nobody reads. Anyone can get a demo out of a model. Getting production software out of one, over and over, at a quality a team can live with, is engineering, and almost nobody has been taught it.
The factory runs itself. Somebody still has to build the factory.
The curriculum
What you will learn
Six stages, walked in order, exactly like The Guide: every stage unlocks new moves, and the milestones grade you up. This course starts where The Guide ends, at black belt, so the ranks here are dan grades.
Ranks you earn on this path
shodan, 1st dan- nidan, 2nd dan
- sandan, 3rd dan
Lessons are being written. The stages below are what the course covers.
Stage 1 of 6
How agents actually work
Under the marketing, an agent is a loop: context in, tool calls out, repeat until done. Learn the moving parts so the failures stop being mysterious.
New moves unlocked
- Reason about context, tools and the agent loop
- Predict where an agent will go wrong before it does
- Pick the right model and effort for the job
Stage 2 of 6
Spec-driven development
The bottleneck moved from typing to intent. A vague ask produces confident, wrong software very quickly. Writing a spec a machine can execute is the new core skill.
New moves unlocked
- Turn a fuzzy request into an executable spec
- Slice work into reviewable, independently testable units
- Keep the spec as the source of truth as the code drifts
Rank up: shodan, 1st dan 🎉Stage 3 of 6
Building the harness
This is the fast-growing role. Somebody has to build the thing the agents run inside: the tools they can call, the context they get, the permissions they do not, and the feedback that tells them they failed.
New moves unlocked
- Design tools, skills and MCP servers agents can use well
- Engineer context: what to load, what to leave out
- Set permission boundaries and blast-radius limits
- Close the loop with tests, linters and CI the agent can read
Stage 4 of 6
Verification at volume
AI produces plausible code. Deciding whether plausible code is correct, safe and maintainable is no longer a senior nicety; it is the job. And you cannot read all of it, so you have to design what catches the rest.
New moves unlocked
- Read code faster and more ruthlessly than you write it
- Build evals and test strategy for non-deterministic output
- Review a large diff without pretending you read every line
- Spot the subtle bug, the security hole, the design that will not scale
Rank up: nidan, 2nd dan 🎉Stage 5 of 6
Orchestration: running a fleet
One agent is a tool. Five agents in parallel is an engineering problem: isolation, merge conflicts, cost, and knowing when to stop the line.
New moves unlocked
- Run parallel work safely with worktrees and isolation
- Decompose a task into work that fans out cleanly
- Measure cost and quality per iteration, and cut what is not paying
Stage 6 of 6
Architecture and taste in the loop
Agents write inside your architecture. They will not fix it, and they will happily scale a bad boundary to fifty files. System design got more leveraged, not less.
New moves unlocked
- Design boundaries that survive code you did not type
- Keep a codebase legible to humans and machines at once
- Decide what not to build, and defend it
Rank up: sandan, 3rd dan 🎉End of the path: you build the factory.
There is no final belt here. The models change every few months, so the last move you learn is how to keep re-learning the loop.
Do not throw it away
What still matters
The loudest version of this story says none of it counts any more. That version is wrong, and expensive to believe. Most of what makes a good engineer did not move. It got more leveraged, because it is now the part nothing else can do for you.
Reading code
Promoted from warm-up exercise to the main event. Everything downstream of an agent is a review, and you cannot review what you cannot read.
System design
Boundaries, data models, failure modes. The generated code lives inside decisions only you are making.
Debugging
Something will break at 2am, and the thing that wrote it will not be the thing that explains it. Tracing a fault to its cause is still a human skill.
The fundamentals under the syntax
How the network, the database, the browser and memory actually behave. AI fills in syntax; it cannot fill in your mental model, and without one you cannot tell good output from confident nonsense.
Product judgment
Deciding what is worth building, what "good enough" means here, and what to cut. AI will build the wrong thing beautifully.
Working with people
Specs, reviews, disagreement, persuasion. The team is still where software actually ships.
And the honest half: what stopped being a moat
- Hand-writing boilerplate, glue and the tenth component that looks like the last nine
- Syntax recall for a library you touch twice a year
- Being the fastest first-draft author on the team
- Guarding knowledge that is now one good prompt away
None of that made you a bad engineer. It just stopped being the thing you get paid for, and the course spends its time on what replaced it.
Before you start
Who this is for
You should be able to build and ship something on your own already: read an unfamiliar codebase, write tests, use git without fear. If you are not there yet, that is exactly what the other path is for. Walk it first, then come back. This course starts where it ends.
Want to know when it opens?
Chapters are being written now. The Discord hears first, and the people in there help shape what makes the cut. Tell us what you want covered.
Join our DiscordIn the meantime, the articles cover a lot of this ground already.