This is a set of principles that I currently use as context for prototyping and also aligns very well with my personal design philosophy.

Overall Philosophy : File Over App

A core belief of mine that guides most of it is that your data / context should outlive any application.

Your data lives in plain, human-readable files you own, not locked in proprietary databases or cloud platforms.

What this means:

1. Your files, your rules

  • Data stored in markdown, yaml, json, svg, etc.
  • No proprietary formats, no vendor lock-in
  • Open with any text editor, today or in 20 years

2. Local first, always

  • Works completely offline (no servers required)
  • No account creation, no login walls
  • Your computer your data, your privacy

3. Folder-first workflow

  • Apps or agents ask for a folder before operating
  • You choose where data lives (not the app or agent)
  • Easy to backup, sync, or version control

4. Universal Metadata

  • Consistent schema across all content types
  • Machine-readable for tooling
  • Human-readable for transparency

Core Principles

Data Sovereignty

You must have complete control over your data / context.

Applications come and go, but your data / context should be permanent. When you own the format, you unlock actual potential.

Privacy by Design

Privacy is not a feature. It is about more than just privacy. It’s about power.

Your thoughts, notes, research, insights, concepts are yours alone. Privacy should never be negotiable or optional. Privacy by default is true empowerment[1].

Transparency

You should understand exactly what an app or agent does.

Trust comes from understanding. When you can see excatly what's happening, you'r in control.

Interoperability

Data should flow flow freely between applications / agents.

Lock-in happens when data can't escape. True interoperability means never being trapped. And allows you to build other systems, apps, agent on top.

Simplicity

The simplest solution that works is the best solution.

Complexity is a form of technical debt. Simple systems while often incomplete are more maintainable, debuggable, and have a higher chance to be timeless.

Off-line First

The internet should be optional, not required.

Internet access is not universal. Critical tools must work everywhere, always.

Composability

Composable tools create emergent value.

Small focused tools that work together are better than than monolithic apps.

Agency

Users should control their directions, not follow prescribed paths.

Every user is different, and needs evolve and change over time. Rigid workflows create friction for everyone.

Longevity

Build for the long term, not the next quarter.

Critical tools / interfaces (APIs, Smart Contracts) we depend on should be reliable for years, not days.

Software Design Principles

Minimize, Don't Maximize

Build features that reduce complexity, not add it.

Good features:

  • Remove friction from common repeated tasks
  • Clarify unclear concepts
  • Automate tedious work
  • Surface hidden connections

Bad features:

  • Add complexity without clear value
  • Lock users into specific workflows
  • Create dependencies on external services
  • Hide what's happening behind abstraction

Progressive Enhancement

Start with the essential, add layers of capability.
  1. Core: Works with plain markdown and text editor
  2. Enhanced: Rich UI when using the application
  3. Advanced: AI assistance, visualizations, automation

Every layer adds value, but the foundation remains accessible.

Calm Technology

Technology should be ambient, not demanding.
  • Non-blocking notifications
  • Subtle status indicators
  • Auto-save without interruption
  • Pause when not in focus

Respect for Craft

Software/Design is craft. Quality matters.
  • Clean, readable code
  • Comprehensive error handling
  • Thoughtful UX details
  • Documentation as priority, not afterthought
  1. *Privacy is, ... , a way for users to regain control.* Inspired by past work between Mozilla and IDEO exploring the State of the Surveillance Economy ↩