| name | building-product-movements |
| description | Strategies for transforming a software product into a global community and ecosystem. Use this when launching open-source projects, building developer platforms, or seeking to create a competitive moat through ecosystem incentives rather than just features. |
Building Product Movements
Successful platforms are more than just software; they are movements. By infusing a product with a clear philosophy and designing systems that prioritize ecosystem success over core company profits, you can create a "flywheel" effect that proprietary competitors cannot easily replicate.
Core Principles
1. Shift from Product to Philosophy
Don't just sell utility; give people a worldview to believe in.
- Infuse Art and Soul: Use branding to signal that the work is craft. For example, the WordPress tagline "Code is Poetry" and naming every major release after a jazz musician (e.g., Gershwin, Vaughan) humanizes the technology.
- Set the Values: Establish clear "freedoms" (like the GPL's four freedoms: use, study, change, and redistribute) so users know they are building on a foundation of liberty, not just a vendor's roadmap.
2. Design for Systems Thinking and Incentives
A true platform exists when the ecosystem built on top of it makes more money than the core company itself.
- The "True Platform" Test: If the third-party developers, agencies, and theme creators are collectively out-earning the platform owner, the moat is secure.
- Protect the "Rug": Never pull the rug out from under successful developers. Unlike social media giants that often cut off API access once a third party gets too successful, a movement ensures that even if the founder "grows devil horns," the code belongs to the users.
3. Establish Contribution Infrastructure
Provide clear "on-ramps" for people to contribute their specific talents, not just code.
- Multi-disciplinary Groups: Create formal groups for non-coders, including accessibility, design, translation, documentation, and event organization.
- Feedback Loops: Use Town Halls, open Q&A sessions, and public Slacks. Lead by being "the unhappiest user" of your own product to signal that the bar for quality is always rising.
Implementation Workflow
- Identify the Technical Core: Build the "engine" (the CRUD operations).
- Open the Architecture: Create hooks for plugins and themes that allow third parties to modify every part of the code.
- Delegate Radically: Assign "commit status" based on a meritocracy of contributions. Allow the community to drive daily decisions while the leader maintains a check-and-balance "Mayor" role.
- Balance Leadership vs. Committee: Use "Founder Mode" for high-risk, generational shifts (like the 10-year "Gutenberg" block editor project) that a committee would likely vote against, while leaving incremental improvements to the community.
- Scale via Events: Support local meetups and global conferences (WordCamps) to move digital relationships into the real world.
Examples
Example 1: The "Jazz" Naming Convention
- Context: A team is launching a regular release cycle for an API or CMS.
- Input: Technical version numbers (v6.1, v6.2).
- Application: Rename the release after a cultural icon or theme.
- Output: The community feels part of a "release" culture. Contributors compete to be part of the "Coltrane" release, turning a mundane update into a celebrated event.
Example 2: The Gutenberg Long-Bet
- Context: A mature product needs a radical UI overhaul that the current power users hate.
- Input: User resistance to a new visual editor.
- Application: The leader identifies this as a "generational shift" necessary for survival over the next 10 years. They push the vision through despite negative sentiment, trusting that 200+ iterations will eventually win over the majority.
- Output: The product remains relevant as tech shifts from desktop/DHTML to mobile/WASM, while competitors who built by committee languish in technical debt.
Common Pitfalls
- Building by Committee: Seeking 100% consensus on radical innovations often leads to "beige" products that fail to surf technological shifts. Use a hierarchy for major vision bets and a meritocracy for everything else.
- Neglecting Maintenance: Acquiring new features while ignoring "technical debt" is a slow death. Adopt the mindset that "Life is Maintenance" and ruthlessly edit or cut features that are no longer relevant.
- Open-Source Washing: Using the term "open source" while including restrictive clauses (e.g., user limits or proprietary licenses). This destroys the trust required to build a movement and invites "false prophet" labels from the community.
- The "Rug Pull": Monetizing the exact features that your third-party ecosystem relied on to build their businesses. This turns partners into competitors and kills the flywheel.
