loom

10x

The habits that make a developer 10x, turned into protocol.

---

You've worked with a 10x developer. They aren't 10x because they type faster or write more code. In fact, they usually write less. They're 10x because they eliminate entire classes of problems instead of solving tickets one at a time. They treat code as a liability - every line is a line that has to be tested, debugged, secured, and maintained - so they maximize the amount of work not done. They strip a problem to its fundamentals before touching a keyboard: what are the actual constraints? What's an assumption we can challenge? Does this even need to exist?

When something breaks, they don't guess-and-check. They read the logs, form a specific hypothesis, isolate the variable, and write one targeted fix with a regression test. When they're about to build something, they mentally simulate the failure modes first - cascading failures, race conditions, what happens under backpressure. And critically, they leave the project smarter every time they touch it. Their decisions get written down with the alternatives that were rejected. Their investigations document the dead ends. Their specs define behavior precisely enough that someone else can verify it independently.

That's not extra process. That's how they multiply the team. A junior engineer onboards faster because the ADRs exist. A teammate picks up the work cold because the reasoning is in the repo, not in someone's head. The next person doesn't re-evaluate a settled decision because the tradeoffs are written down in plain English.

Right now, your AI agent operates at the opposite end of this spectrum. It's a brilliant syntax generator with zero engineering judgment. It starts every session from scratch. It accepts vague instructions without pushing back. It solves the immediate ticket without considering whether the ticket should exist. It says "done" because a command exited zero, without asking whether the output actually satisfies the intent. And it forgets everything it learned the moment you close the chat - so next session, you're explaining the same architectural context for the fourth time.

10x is a protocol that makes your agent operate the way that developer operates. Not by typing faster - by thinking more carefully. It interrogates unclear requirements until the fundamentals are unambiguous. It searches the project for existing answers before asking you questions. It decomposes work into bounded pieces that can be independently verified. It captures evidence of what actually happened - observed output, not "I believe it works." It runs adversarial review on its own work. And because working this way naturally produces documentation, the reasoning accumulates in .10x/ as structured engineering records that any future agent (or human) can pick up cold.

Thursday's agent uses Tuesday's judgment because Tuesday's agent worked carefully enough to leave a trail.

Read the protocol | Install

npx skills add z3z1ma/10x

What still gets lost

Maybe your workflow already has good parts. Plan mode, spec files, custom skills, subagents reviewing subagents. You've built a small ecosystem. But the pieces haven't learned each other's names, and the agent still operates like a ticket machine - accepting work at face value, executing in isolation, and declaring victory without verification.

You already use	What still goes wrong
Plan mode	Reasoning disappears with the session
PLAN.md or spec files	Plans rarely link to evidence, reviews, or later decisions
Subagents	Reports sound authoritative before anyone verifies them
Custom skills	They use different state and vocabulary from each other
"Think before coding" prompts	The agent still guesses when requirements are vague
Chat history	Important conclusions stay implicit, private, or impossible to grep

The gap isn't tooling. It's judgment. 10x gives the agent a complete working method where these problems don't arise because the behaviors that prevent them also produce the records that survive.

How a 10x developer works (and how 10x makes your agent work)