I recently started training Wing Chun.
At first glance, it doesn't look like what most people expect from martial arts. There's no flash. No wasted motion. No emphasis on brute force. Everything is controlled, direct, and intentional.
When I first walked into training, I expected to learn techniques—strikes, blocks, sequences.
Instead, we spent time on something much simpler.
Stance. Balance. Positioning.
It wasn't exciting. It didn't feel like progress. But it quickly became clear that everything depended on it.
In Wing Chun, there's a core idea that shows up in everything you do:
Structure creates power.
Economy of motion creates speed.
The more I train, the more I realize how closely this maps to building software.
Early on, speed feels easy.
You're building something new. Writing code, shipping features, making decisions quickly. It feels like momentum.
And in a way, it is—at least at the start.
But over time, something changes.
Small decisions begin to stack. Patterns drift. The system becomes harder to reason about. Bugs start showing up in places that used to feel simple. Every new change introduces a little more friction than the last.
You're still moving, but not forward.
You're spending more time fixing than building.
In Wing Chun, that breakdown is familiar.
If your structure isn't right, everything becomes harder under pressure. Movements get sloppy. Reactions slow down. Power disappears.
You can try to compensate with effort—but it doesn't hold up.
That's why so much time is spent on foundation.
Before anything complex, you focus on the basics:
- where your weight sits
- how your body is aligned
- how you connect movement from one position to the next
It's not flashy. But it's what allows everything else to work.
Software isn't that different.
It's tempting to skip the foundation early on. To move quickly, defer decisions, and assume you'll clean things up later.
And for a while, that works.
But without a solid foundation, systems become fragile. Small changes carry risk. Complexity builds faster than expected. Eventually, the speed you thought you had starts working against you.
What's interesting is that Wing Chun isn't about doing more.
It's about doing less—but doing it well.
Every movement has a purpose. There's no extra motion. No wasted energy. If something doesn't directly contribute to the outcome, it's removed.
That idea carries over into engineering more than most people expect.
The best systems aren't the ones with the most flexibility or the most features. They're the ones where each piece has a clear role, and everything works together in a way that feels intentional.
Simple systems move faster—not because they do more, but because they do less with clarity.
Once the foundation is in place, something shifts.
In Wing Chun, movements become more consistent. Reactions become faster. Techniques that felt awkward start to flow naturally. You're not thinking as much—you're responding.
More complex combinations become possible, not because you've added more, but because everything underneath them is stable.
That's what a good foundation does in software.
It doesn't slow you down. It removes friction.
It gives you:
- consistent patterns
- clear boundaries
- confidence in making changes
From there, you can move faster—not just once, but repeatedly.
You can build on top of what you've already created without constantly reworking it.
This is where the idea of Engineering Momentum really starts to make sense.
Most teams don't struggle because they lack the ability to build.
They struggle because the systems they build don't support continued progress.
Speed shows up early. But it doesn't last.
Bugs increase. Changes get harder. Teams spend more time stabilizing than creating.
Momentum breaks.
The teams that maintain momentum tend to do something different.
They don't avoid speed—but they don't chase it blindly either.
They make a few key decisions early:
- establish structure
- define patterns
- create a foundation that can support growth
Not over-engineering. Not unnecessary complexity.
Just enough structure to keep things moving forward.
Wing Chun isn't about brute force.
It's about alignment, structure, and efficiency.
The power doesn't come from doing more—it comes from doing the right things, in the right way, with the right foundation underneath.
The same is true in software.
You don't need the most complex system.
You don't need the most flexible architecture.
You don't need to solve every problem up front.
You need a foundation that allows you to keep moving.
Structure creates power.
Simplicity creates speed.
And the right foundation creates momentum.
Originally published at m2s2.io
Top comments (0)