These are the principles I use when I build web applications and blockchain systems, for startups and for institutions. They are independent of the stack, and they keep quality and reliability in the same conversation as shipping.
User experience first
Technology is worth little if people dislike using it, so I prioritize clarity, usability, and performance, and I would ship a clear, fast product with ordinary internals over a clever one that is hard to use.
Less code over more
The best code is often no code. I avoid unnecessary abstractions and complexity, and if a problem can be solved without writing more code, that is usually the better choice, because a small system is easier to scale than a complicated one.
Automate and secure everything
Security is non-negotiable. Automated processes reduce human error and make deployments predictable and repeatable, and continuous testing with security-first practices catches problems before they reach users.
AI in the workflow
I use AI to take on the tedious work, automating repetitive tasks and adding tooling that shortens the path from idea to change, so engineers spend their time on the decisions that need judgment.
Open source and portability
I build systems that can be deployed anywhere, because open-source technology supports collaboration, reduces vendor lock-in, and keeps a product portable when platforms shift.
Ship early and learn from it
Frequent releases mean continuous learning. I get user feedback early and iterate on it, since the longer a release waits, the more a wrong assumption costs, and that cost grows when you are leading a team building on the same assumptions.
Functional tests over unit tests
Unit tests are useful, and functional tests are what prove real-world reliability, so I test how the system behaves as a whole before I test isolated components.
Optimize after measuring
Premature optimization wastes effort. I make it work first, then measure, and optimize only where the measurements show a need, which keeps the design from being overengineered.
Software ages like milk
Software degrades over time as APIs change, dependencies go stale, and technical debt accumulates, so maintenance and refactoring are part of the work from the first release.
The Unix philosophy
The Unix philosophy still sets the standard I measure software against:
- Modularity: write simple parts connected by clean interfaces.
- Clarity: clarity is better than cleverness.
- Composition: design programs to be connected to other programs.
- Separation: separate policy from mechanism, and interfaces from engines.
- Simplicity: design for simplicity, and add complexity only where necessary.
- Parsimony: write a big program only when nothing else will do.
- Transparency: make systems easy to inspect and debug.
- Robustness: robustness comes from simplicity and transparency.
- Representation: encode knowledge in data so the logic stays small.
- Least surprise: interfaces should do the least surprising thing.
- Silence: if a program has nothing important to say, it should say nothing.
- Repair: when failing, fail noisily and as soon as possible.
- Economy: programmer time is more valuable than machine time.
- Generation: write programs that write programs when possible.
- Optimization: prototype before polishing, and get it working before optimizing it.
- Diversity: distrust all claims of a "one true way."
- Extensibility: design for the future, which arrives sooner than expected.
I apply the same list whatever the stack or the client, and it is where I start when a design decision needs settling.