Positions Before Decisions: What Brazilian Jiu-Jitsu Taught Me About Software Architecture

Walk into any Brazilian jiu-jitsu gym and you'll notice something odd: the best practitioners don't look like they're thinking. A purple belt gets their guard passed, and before their brain has consciously registered the problem, their hips are already turning, a knee is sliding in as a frame, and they're recovering position. Nobody "decides" to do this. It happens naturally as it is trained into reflex.

That's not talent (maybe a little). It's simply drilling. Thousands of repetitions of hip escapes, guard retention, and frame placement... done slowly, badly, then less badly, then finally smoothly until the position itself carries the answer. BJJ people have a saying: position before submission. You don't hunt for the flashy finish; you build a base of positions so deeply ingrained that your conscious mind is freed up for the actual chess match... the timing, the feints, the opponent-specific adjustments. The fundamentals run on autopilot so strategy can run in the foreground.

Software engineering works exactly the same way.

A junior engineer burns enormous cognitive energy on mechanics: how to structure a function, what to name things, how to write a test, when to extract an interface. Every small decision is a conscious decision, and by the time they've made forty of them, they have no bandwidth left for the question that actually matters -- is this the right design at all? They get submitted while still thinking about their grips.

A senior engineer has drilled those positions into muscle memory. Separation of concerns, dependency direction, small composable functions, tests that pin behavior rather than implementation. These aren't choices anymore; they're reflexes. When they see a class reaching across a boundary, something feels wrong the same way a fighter feels their base getting compromised, before they can articulate why. That freed-up attention is what gets spent on architecture: trade-offs, failure modes, what this system needs to become in two years.

The lesson for how we improve is the same too:

• Drill, don't just roll. Sparring every round (shipping features nonstop) makes you good at surviving, not good at fundamentals. Deliberate practice: katas, code review, rebuilding a pattern until it's boring. These are what install reflexes.
• Slow is smooth, smooth is fast. You drill a technique slowly and precisely long before you do it at speed. Writing careful, well-factored code on low-stakes work is how you get fast on high-stakes work.
• Position before submission. Don't reach for the clever abstraction or the trendy framework (the flying armbar) before your base is solid. Most production incidents are blown fundamentals, not exotic failures.
• White belts tap; that's the job. Getting your PR shredded in review is a rep, not a verdict. The people who improve fastest are the ones who tap, reset, and drill the escape.

Architecture, in the end, is just the black-belt version of the same idea: patterns like layering, event-driven boundaries, and idempotent operations are positions you've internalized so thoroughly that you can hold the whole system in your head and think about strategy because none of your working memory is wasted on the basics.

You don't rise to the level of your ambitions. You fall to the level of your drilling. Train accordingly.