Skip to content

The Stupid-Simple Principle: Solving Complex Problems Incrementally

Overview

The Stupid-Simple Principle is a counterintuitive but effective approach to tackling complex problems—whether in documentation, genealogy, AI, or software design. It prioritizes small, functional steps over grand designs, and human needs over hypothetical edge cases.

Why It Matters

Modern tools and AIs often default to over-engineering: anticipating every possible scenario, adding layers of abstraction, and creating systems that are brittle, complex, and hard to maintain. This principle flips the script by focusing on: - What works today (not what might be needed tomorrow). - Human-scale solutions (not hypothetical scalability). - Incremental progress (not perfect designs).

Core Rules

  1. Start with the Minimal Viable Tool Use the simplest tool that solves today’s problem. Example: PHP + Markdown for documentation, or a CSV for genealogy data.

  2. Add Layers Only When Necessary New features or complexity are added only when a real need arises, not because they’re "standard" or "expected."

  3. Design for Humans First Every decision should pass the test: "Does this make it easier for a human to use/maintain?" If not, skip it.

  4. Embrace "Good Enough" Perfection is the enemy of progress. A system that works today is better than a "perfect" system that never ships.

Example: Ardens Documentation

Problem

  • Tried multiple static site generators (MkDocs, Hugo, etc.), each introducing complexity or limitations.
  • Needed a system for 300+ pages of documentation that was easy to maintain and update.

Solution

  • Toolchain: PHP + Markdown + flat files. No build steps, no databases, no frameworks.
  • Workflow: Edit files directly, test locally, deploy by copying files.
  • Search: Added only after the core system worked, using a simple JSON index.

Outcome

  • A system that’s easy to maintain, scales effortlessly, and requires no special tools.
  • Content updates are as simple as editing a text file.

Example: Genealogy-AI

Problem

  • Genealogy tools often require complex setups (databases, graph models) before you can even start.
  • AIs suggest over-engineered solutions for simple tasks (e.g., visualizing a family tree).

Solution

  • Start with a CSV of names and dates.
  • Add one layer at a time: parents → siblings → sources.
  • Use simple visualizations (e.g., hand-drawn diagrams or basic charts) before considering graph databases.

Outcome

  • A functional family tree that grows organically, without upfront complexity.

Key Insight

"We’re not building a cathedral. We’re laying one brick—today—and seeing if it holds weight."

Call to Action

  1. Start small. What’s the simplest tool or step that solves your current problem?
  2. Add layers incrementally. Only introduce complexity when you hit a real limitation.
  3. Test with real data. Does it work for your use case? If yes, move forward.
  4. Repeat. Complex problems are solved by stacking simple solutions.

Key Takeaways

  • Complex problems are solved by stacking simple, functional solutions.
  • Avoid tools or features until you need them—start with the minimal core.
  • Test with real data early to catch issues before scaling.
  • Document just enough to maintain and share the system.