A 10-step ladder for getting good at Claude

Ten steps, in order, for getting from “this is an impressive toy” to something that runs actual work. Read it as a self-assessment: find where you are, do the next one.

The order matters more than any individual step. Most of these are dead weight without the one before them.

The ladder

1. Stop using chat, start using a persistent workspace.Unlocks memory, file access, and tool access.
2. Install a skills marketplace. Gets you chained workflows somebody else already debugged.
3. Wire your tools up in draft-only mode. The agent can read and write, nothing ships without you.
4. Iterate each skill until it stops breaking. This is where a baseline becomes an advantage.
5. Write a routing file. Keeps the context window clean and loads domain knowledge on demand.
6. Add a self-improving prompt. The agent updates its own rules after every session.
7. Feed it 10 good and 2 bad examples per domain. Enough for pattern extraction to start.
8. Move to a code-capable agent for multi-file work.Hooks, parallel subagents, scoped local tooling.
9. Sync it all to a private repo. Same system from any device.
10. Run it from your phone.Parallel threads while you're away from the desk.

Why the order is the point

Step 2 needs step 3. Marketplace skills only start clearing a 70 percent approval rate after your tools are connected and the agent has learned how you communicate.

Step 2 needs step 4.An off-the-shelf skill handles maybe 80 percent of cases. The gap between 80 and 99 is where it stops being a convenience and becomes something a competitor can't replicate by installing the same thing.

Step 5 needs to precede step 6.The self-improving prompt tells the agent to update its rules. If the routing file doesn't point at per-domain rules files, there is nowhere for it to write.

Step 6 needs step 7. The loop only compounds when there are enough examples to extract patterns from.

Step 1 is where most people stall

Chat feels familiar, which is exactly the problem. Stateless to stateful is the transition where this stops being a party trick. If you are still pasting the same context at the start of every session, nothing further down this list will help yet.

Draft-only is the safety pattern

When you connect email, messaging, or anything else that can reach another human, set it to propose rather than send. The agent drafts, you approve. It reads your edits, and approval rates climb from around 10 percent to 70-plus over time.

This is worth doing even after you trust the output, because the edit history is the training signal.

How to actually iterate a skill

Run it on real work. When it fails, give it the exact failure rather than a verdict. “The acceptance criteria missed the null cases” teaches something. “This is bad” teaches nothing. Expect five or six rounds before it holds.

The self-improving prompt

Three lines. Works for any domain.

1. Before starting any task, review existing rules and hypotheses for this domain.
2. Apply confirmed rules by default to your work.
3. After completing work and receiving feedback, update rules and hypotheses based on what you learned.

This turns every session into a knowledge-base update without you rewriting anything. Over 30 days the system builds its own set of confirmed rules, open hypotheses, and rejected patterns, provided you actually let it write to the domain files.

Ten good, two bad

That's the minimum viable training set per domain for pattern extraction to work. The bad examples matter as much as the good ones, because they define the boundary.

The last three steps

Code-capable agent, private repo sync, then mobile. These stack in that order and the payoff is being able to dispatch real work from a phone while three other threads run. That's a genuine capability change rather than a convenience, but it's also the tier that's useless if steps 1 through 7 aren't solid.