Why Everything You've Planned Will Collect Dust Unless You Actually Build It
I spent three years watching teams at two different companies grind themselves to death in planning meetings. We're talking sprints planned six weeks out, color-coded spreadsheets, stakeholder sign-offs on documents nobody would read. The output was always the same: shipped features nobody wanted, delivered months late, and a lot of exhausted people who could recite their project roadmap backward. Meanwhile, the competition was shipping broken stuff every Tuesday and learning from actual users instead of guessing what they needed. The problem isn't that planning is bad. The problem is that most people use planning as a substitute for doing. It feels productive because you're busy. It produces deliverables like Gantt charts and requirements documents that give you something to point at when someone asks for progress. But none of it moves the product forward. Rolling Up Your Sleeves And Getting The Job Done The Enduring Power Of Action Over Words isn't a motivational poster. It's the observation that velocity comes from shipping, not from meetings about shipping.
What This Actually Looks Like in Practice
When I talk about action over words, I'm not talking about headlong impulsiveness. You can ship fast and still ship garbage. What I'm describing is a specific workflow discipline: identify the smallest possible version of what you're trying to prove, build that in a single focused session or day, get it in front of real users or at least a realistic test environment, and then iterate based on what actually happens instead of what you predicted would happen. Here's a concrete example from when I was running a small engineering team building an internal inventory management tool. We had a two-week sprint planned to redesign the entire search interface. We did user interviews, created wireframes, built a prototype in Figma, presented it to stakeholders. Then we got to implementation and realized the search logic was fundamentally broken because we'd never tested it against the actual database schema. Two weeks gone. The prototype looked fine. The thing we needed to solve wasn't even visible in our design process. So we changed the approach. Next time, instead of redesigning the search interface, I just wrote a quick script that ran our actual search queries against production data and logged the response times and failure rates. Took about forty minutes. We discovered that 60 percent of searches were failing because of a missing index on a column we thought was indexed. We fixed the index, the search worked acceptably, and then we spent one afternoon making the interface slightly less terrible. Total time investment: one morning plus one afternoon. The redesigned search that was supposed to take two weeks ended up taking three days because we finally understood what the actual problem was.
The Core Mechanism: Why Action Beats Planning Every Time
There are a few reasons this works, and they're mostly about reducing the surface area for error. When you spend time planning, you're operating in a model of reality. Models are simplifications. They're always wrong about something. The more complex the model, the more places it can be wrong, and the harder it is to notice those places without actually running the thing you're modeling. A physical prototype, a deployed feature, a functional script — these exist in reality. They encounter the actual constraints: real data, real network latency, real users who do things you didn't anticipate. You learn something real in the first hour of testing that would have taken three weeks to discover in a planning meeting because nobody thought to ask the right question or nobody had the context to know what question to ask. I also want to flag something that surprises people. Action reveals information that planning cannot. This is probably the most important point and the one most teams miss. When you sit down and actually build something, you hit decisions that no amount of discussion will resolve until you make them. Should the search results load asynchronously or synchronously? Does it matter? You don't know until you write the code and see what the browser does. The answer emerges from the work, not from the conversation about the work.
Get the Full Details
How to Actually Do This Without Becoming Chaotic
The common fear is that if you stop planning and start doing, you'll build the wrong thing efficiently. That's a real risk. The way to manage it is to make your actions explicitly small and explicitly reversible. Don't build the search interface. Build a query and look at the results. Don't redesign the dashboard. Export the data and look at it yourself. Don't write the entire API. Write one endpoint and call it from your browser. There's a specific technique I use called the twenty-four-hour test. Whatever you think you need to plan or discuss or research, can you instead spend twenty-four hours building a crude version and seeing what breaks? Ninety percent of the time, the answer is yes. The remaining ten percent is usually when you're dealing with regulatory constraints, safety-critical systems, or projects where the cost of being wrong is genuinely catastrophic. Those are rare in most software and business work. Another practical rule: if a decision requires a meeting to resolve it, you're probably wrong about the meeting being the right tool. Can you resolve it by building the thing two ways and comparing them? Can you resolve it by asking one person who has actually done this before? Can you resolve it by setting a deadline and committing to one option? Most team discussions I've watched unfold could have been resolved in ten minutes if someone had just picked a direction and started moving.
Common Pitfalls That Make This Approach Fail
The biggest mistake I see is confusing action with activity. Sending an email about the project isn't action. Updating a ticket isn't action. Saying you'll look into something isn't action. Action changes the physical state of your product or your knowledge. Before you finish the day, something should be different than it was when you started. A file exists that didn't exist before. A user has seen something you showed them. A hypothesis has been proven or disproven. If nothing has changed materially, you haven't taken action. You've been busy. A second pitfall is not iterating fast enough. I've watched people build their "minimal version" for three weeks and call it agile. If your minimal version takes three weeks, it's not minimal. It's just a smaller version of whatever you were going to build anyway. The whole point is to compress the feedback loop. I've seen teams cut their learning time from months to days by simply deciding that anything taking longer than two days to build is too big and needs to be split. There's also a social risk you need to account for. In most organizations, people get rewarded for looking prepared. Meetings, presentations, documents — these are visibility mechanisms. Action is often invisible until it produces results. If you're the person who just ships things without the accompanying artifacts, you may get overlooked for promotions or recognition. This isn't ideal. It's just something to be aware of. I've learned to pair action with brief written summaries of what I built and what I learned. Twenty minutes of writing after three days of building captures the value without turning the building into paperwork.
When This Approach Actually Doesn't Work
I want to be honest about the limitations because most people selling this idea won't. Action over planning fails in a few specific scenarios. First, when the cost of failure is extremely high and irreversible. If you're designing a bridge, you can't just build a small version and see if it holds. The physics will tell you in a very final way. Same thing with medical procedures, structural engineering, nuclear systems. These domains require rigorous modeling and validation before any physical action. Second, action over planning fails when you genuinely don't have enough information to make even a small decision. If you're entering a completely unfamiliar market and you have no data about customer behavior, no competitive landscape analysis, no understanding of the regulatory environment, then building something blind is just expensive guessing. In that case, the right action is research, not production. But research is still action. It's not a planning meeting. It's going out and gathering data. There's a difference. Third, when you're working in a team where everyone is waiting on your output, rapid individual action can create coordination problems. If you ship something on Tuesday and your teammate was planning to build on top of it starting Wednesday, you've just broken their work. This isn't an argument against action. It's an argument for communication. A five-minute Slack message saying "I just shipped X, are you blocked?" takes less time than the conflict resolution that follows when you don't send it.
Building a Personal System Around This
Here's what I actually do on a typical week. I start by writing down the three things that would move my current project forward if they happened. Not the twenty-three things. Three. Then I pick the one that has the most uncertain outcome — the one where I'm most wrong about what will happen — and I spend the morning resolving that uncertainty through action rather than discussion. For example, last month I was working on a content platform and couldn't decide whether to build a recommendation engine or just use simple popularity-based sorting. I spent forty-five minutes writing a popularity-based sorter and deploying it. Then I compared the output against what my gut said the recommendation engine would produce. The difference was negligible for our traffic level. Saved myself three weeks of development. That forty-five minutes was worth more than any architecture review we could have had. The evening is for documentation, but only the kind that helps the next version of you. Not status reports. Not slide decks. A brief note on what you built, what surprised you, and what you'd do differently. This creates a personal knowledge base that compounds over time. After a year of this, you have a detailed record of what actually worked in your specific context, which is infinitely more valuable than any industry best-practice guide.
I also keep a running list of decisions I've made through action that I later realized I should have spent more time thinking about upfront. This is my personal failure log. It keeps me honest. There are cases where a little planning would have saved significant rework. The key is learning to recognize those cases. So far, the ratio has been roughly ten to one in favor of just doing it. But the one in ten matters, and having the log means I catch the pattern before it catches me.
