# The Next-Step Dojo: An Airborne Kata for the AI Era That Lets Anyone Master Unfamiliar Tech Fast

Have you ever had this experience: you want to learn Rust, learn a K8s Operator, learn Claude Code Skills — you’ve bookmarked seventeen tutorials, watched videos at 1.5x speed three times over, filled a page with notes, and yet when it’s finally time to write code, your mind still goes blank?

It’s not that you didn’t try hard enough. It’s that the learning path itself is wrong.

The traditional path to learning something new is: search → filter → read → take notes → find a demo → set up your own environment → hit roadblocks → give up or start over. Along that chain, the fraction of time that actually builds muscle memory is embarrassingly small. Most of your time goes into moving information around, not internalizing a skill.

This article shares a method we’ve validated repeatedly in AI4SE contexts. It grows out of the software engineering world’s classic Code Kata culture, with a key upgrade for the AI era. We’re calling it —

The Next-Step Dojo, also known as the Airborne Kata.

A slightly overdramatic name? Yes, on purpose. When you’re practicing a martial art, being too serious about it makes it harder to actually sink in.

First, What Is a Code Kata

If you’ve never heard of Code Kata, that’s fair — it’s been a niche cult favorite for years, but rarely written into team handbooks as a “serious methodology.”

The word Kata comes from Japanese martial arts, originally meaning “form” — a set of movements practiced repeatedly. The forms in karate, the kata in kendo — they’re not about looking impressive, they’re about carving the correct movement into the body.

In the early 2000s, agile pioneer Dave Thomas (co-author of The Pragmatic Programmer) brought this idea into programming, introducing Code Kata: using small, repeatable, deliberately designed programming exercises to help developers internalize specific skills.

What do classic Code Katas look like? For example:

• FizzBuzz Kata — practices basic loops and edge cases
• Bowling Game Kata — practices the red-green-refactor rhythm of TDD
• Roman Numerals Kata — practices refactoring and pattern recognition
• Prime Factors Kata — practices decomposing a problem

Their shared traits:

Dimension	What it means for Code Kata
Small and complete	One problem domain, runnable within an hour
Repeatable	Doing it again weeks later reveals new insights
Process-focused	The point isn’t “finishing it,” it’s “how you do it”
Deliberate practice	Designed around weak points, not random problem sets
Muscle memory	Makes doing it right your default reflex

Kent Beck, Robert C. Martin, and others have all publicly championed Kata practice. The core problem it solves: programming skill isn’t something you learn by watching — it’s something you learn by practicing.

But traditional Code Kata has an implicit precondition — you already know what you need to practice.

If you want to practice TDD, there’s Bowling Game; if you want to practice refactoring, there’s Gilded Rose. But if you don’t even know “should I be using TDD,” the Kata catalog itself becomes a barrier.

The more real-world problem: in an era of exploding tech stacks, “unfamiliar” is the default state. Bookmarking 50 katas doesn’t automatically get you fluent in eBPF, Nix Flakes, or MCP Server development. What’s missing isn’t more exercises — it’s a mentor who can drop you into the field, practice alongside you to completion, and adjust the pace to your level.

That’s the problem the Next-Step Dojo solves.

The Next-Step Dojo: A Kata Upgrade for the AI Era

A one-line definition:

The Next-Step Dojo = a standalone kata workspace + hands-on mentoring from a Coding Agent + driven by a spoken “next step.”

It preserves the essence of Code Kata — deliberate practice, small steps, repeatability — but fundamentally changes three things:

1. You don’t have to find the exercise — the agent generates a customized practice path based on your skill profile and your goal
2. You don’t have to slog through documentation — the agent writes and runs code right in your workspace, showing you as it goes
3. You don’t have to organize your words — you just say “next step,” the way a martial arts master calls out a move and you practice it

Why “Airborne”?

Every time you learn a new skill, you create a new xx-kata folder — say rust-kata, k8s-operator-kata, mcp-server-kata.

That folder is your drop zone: a clean, isolated, disposable practice ground. It doesn’t pollute your main project, carries no historical baggage, and if you wreck it, you can delete it and start over with zero guilt.

“Airborne” fits well: instead of spending three days reading a map before you set out, you drop straight onto the target terrain, with a guide walking beside you.

Why “Dojo”?

Because the interaction mode has changed.

Traditional learning is staring at a screen; in the Next-Step Dojo, you switch on voice mode and talk to the agent the way you’d talk to a master:

“I’m a Rust beginner with Python and Go experience. I want to quickly grasp the essence of Rust’s ownership system and error handling. Please generate a learning and implementation guide, then wait for my instructions. Whenever I say ‘next step,’ execute the next step and demonstrate it to me, with a brief explanation.”

And then you literally just say:

• “Next step.”
• “Next step.”
• “Why does this need to move instead of borrow?”
• “OK, next step.”

The agent creates files, writes code, runs tests, explains the theory, and handles errors — all inside your rust-kata folder. You’re not reading a tutorial. You’re being walked through one.

That’s the dojo pattern: the master demonstrates, you follow along, you ask questions any time, and you control the pace.

The Standard Operating Procedure

The entire method is so simple it’s almost suspicious, but that simplicity is exactly what makes it work.

Step 0: Create a Drop Zone

mkdir rust-kata
cd rust-kata

One folder per skill, no cross-contamination. Next time you want to learn a K8s Operator, create k8s-operator-kata. Over time, your hard drive fills up with a “dojo cluster” — each folder a record of one round of skill practice.

Step 1: Open the Folder With a Coding Agent

Use Claude Code, Codex, Cursor Agent, or any Coding Agent you’re comfortable with, and open this empty folder as your workspace.

The empty folder matters. It forces the agent to build the practice environment from scratch, and it keeps all output within a controlled scope.

Step 2: The Voice Opening — Say Clearly Who You Are and What You Want

This is the only step in the whole method that requires you to think things through. In voice mode, tell the agent:

1. Skill profile — what’s my current level? What do I know, what don’t I know?
2. Learning goal — what do I want to master? What level counts as “enough”?
3. Interaction contract — I’ll only say “next step”; you’re responsible for implementing and demonstrating
4. Quality bar — make sure what I take away is the essence, not just copy-pasted code

A solid opening looks something like this:

“I’m a backend developer with 5 years of experience but no exposure to Rust. In this kata, I want to quickly grasp the core ideas behind Rust ownership, lifetimes, and Result-based error handling — I don’t need to cover everything, but I need to understand why Rust is designed this way. Please generate a step-by-step learning and implementation guide, then wait for my instructions. Every time I say ‘next step,’ execute the next step and demonstrate it to me, with a short explanation. When we hit a key decision point, pause and ask if I understand.”

The agent will generate a structured practice outline, typically 8-15 steps, each with a clear deliverable and a verification criterion.

Step 3: Enter the “Next Step” Loop

Then you enter the core loop of the whole method:

You say "next step" -> Agent implements the current step -> you observe, ask, get hands-on -> verification passes -> say "next step" again

This loop looks almost silly, but it’s extremely effective. More on why below.

Step 4: Wrap Up — Consolidate and Repeat

Once a kata is complete, your xx-kata folder will contain:

• The full practice code
• The learning guide generated by the agent
• Traces of your own edits and experiments

You can then choose to:

• Archive it — keep it as a reference to come back to when you forget
• Redo it — delete the code weeks later and go through it again (the “repeat practice” spirit of traditional Kata)
• Level up — open an advanced kata in the same folder (e.g., rust-kata/async)

Why This Actually Works

It’s not magic — it’s several mechanisms stacking together.

1. Cold-Start Friction Drops to Nearly Zero

The biggest enemy of learning something new is the cold start. Setting up the environment, installing dependencies, getting Hello World to run — many people are exhausted before they even reach the core concept.

The Coding Agent takes over all that grunt work. You open an empty folder, say “next step,” and the first line of code appears in front of you. The path from intent to action compresses to seconds.

2. Voice Mode Frees Up Cognitive Bandwidth

Typing unconsciously pushes you into “editing mode” — thinking about wording, structure, worrying whether your question sounds dumb. Voice mode is naturally more conversational, making it easier to voice your real confusion:

• “Wait, who is this lifetime annotation actually for?”
• “Why didn’t you use clone() in that last step?”

These half-formed questions are exactly the golden moments of learning. The Next-Step Dojo uses voice to lower the barrier to asking them as much as possible.

3. “Next Step” Is the Strongest Pacing Control There Is

One of the classic problems with tutorials is losing control of pace — either you can’t keep up, or you’re bored and want to fast-forward.

The three words “next step” solve everything:

• Can’t keep up? Stop and ask, don’t rush into the next step
• Already got this part? Say “next step” three times in a row to fast-forward
• Want to go deeper? Insert a “why” in the middle

You’re the master of the pace; the agent is the apprentice executing it. This lines up with the idea in Loop Engineering that “humans intervene at high-leverage points” — except here, the high-leverage point is simply deciding when to move to the next step.

4. A Standalone Folder = a Physical Boundary for Deliberate Practice

Code Kata emphasizes “isolation from production code.” The xx-kata folder makes that boundary physical:

• No worrying about breaking your main project
• Free to experiment, delete, and redo at will
• Each folder is a complete record of one round of practice

5. The Agent Handles the Harness; You Make the Decisions

This maps exactly onto the division of labor in Core Concepts of Agentic Coding Agents: the model gives possibility, the Harness gives reliability, and the human gives direction and judgment.

In the Next-Step Dojo:

Role	Responsibility
You	Define the goal, control the pace, judge your own understanding, ask “dumb questions”
Agent	Generate the path, write code, run verification, explain the theory, handle errors
Kata folder	Isolate the environment, consolidate output, support repeated practice

A Few Practical Tips

The More Specific the Opening, the Better the Kata

“I want to learn Rust” — the agent can only give you something generic.

“I have Go experience and want to understand how Rust’s ownership replaces Go’s GC, taught through a small CLI tool in 10 steps” — the agent can give you a customized, distilled path.

Every Step Needs a Verifiable Outcome

A good Kata step isn’t “read chapter 3” — it’s “run cargo test and see 3 green checkmarks.” Have the agent spell out a done condition for each step when it generates the guide.

Don’t Be Afraid to Look Dumb in a Kata

That’s exactly what the empty folder is for. Asking dumb questions, breaking code, deliberately writing something that won’t compile — that’s all part of the practice. The master won’t laugh at you, and the agent even less so.

One Kata, One Core Skill

Don’t try to learn ownership, async, macros, and FFI all at once in rust-kata. The traditional Kata principle of “small and complete” still applies here. One drop, one hill.

Remember to “Wrap Up” When You’re Done

Spend five minutes having the agent generate a “core takeaways from this kata” summary and save it in the folder. Next time you review or start a new kata, that summary becomes your “record of accumulated skill.”

Common Failure Modes

Failure mode	Cause	Fix
Becomes “watching the agent write code”	Only saying “next step,” never getting hands-on	Require the agent to leave a “fill this in yourself” gap each step
The kata balloons into a giant project	The goal was too broad	Bound the number of steps and scope in the opening
Every kata rebuilds the environment from scratch	No template was saved	Extract common environment setup into a kata-starter template
You forget it right after finishing	No repeat practice	Redo the same kata every 2-4 weeks and compare the two runs
Voice can’t articulate the requirement clearly	The opening was too vague	Type out the opening first, then switch to voice for the loop

Comparison With Traditional Code Kata

Dimension	Traditional Code Kata	Next-Step Dojo (Airborne Kata)
Source of the exercise	Community-preset (Bowling Game, etc.)	Customized by the agent to your profile
Practice environment	You build it yourself	The agent builds it in an empty folder
Guidance style	Static tutorial or a pairing colleague	Real-time hands-on mentoring from a Coding Agent
Pace control	Self-directed	Driven by spoken “next step”
Feedback	Test cases + self-reflection	Test cases + agent explanation + your own questions
Repeat practice	Rewrite the same kata weeks later	Delete and redo, or start an advanced kata
Barrier to entry	You need to know “what to practice”	You only need to know “what you want to learn”

Traditional Kata hasn’t become obsolete — it’s still the best way to internalize a known skill. The Next-Step Dojo solves the problem of discovering the path, lowering the cold-start cost, and pacing to the individual. The two are complementary, not in conflict.

Closing Thoughts: The Master Is Waiting in the Dojo, but the Skill Is Still Yours

When Dave Thomas introduced Code Kata, he said something worth remembering: “Practice isn’t about proving you can do it — it’s about exposing what you can’t.”

The Next-Step Dojo carries that spirit into the AI era. The agent can write code for you, set up the environment, look things up in documentation — but understanding, judgment, muscle memory — those you still have to build yourself.

The only difference is: you no longer need to become an “expert at finding tutorials” before you can start becoming “someone who writes code.”

Create a new xx-kata folder, open a Coding Agent, switch to voice mode, and say:

“I’m at XX level, and I want to quickly master the essence of XX. Please generate a learning guide — I’ll only say next step, and you implement it and show me.”

Then take a breath, and say:

“Next step.”

The dojo doors are open.

Related Reading

• Core Concepts of Agentic Coding Agents: Beyond the Model Lies the Harness
• Loop Engineering: From Writing Prompts to Designing Governable Work Loops
• Claude Code vs. Codex: Official Best Practices Compared
• AI4SE End-to-End Best Practices