How I think.
Principles, capability groups, and the engineering thinking that has survived contact with production systems. Evidence-based, project-agnostic, and deliberately small.
Ten working principles.
Build for the real constraint
Systems are constrained by the boring parts: data quality, latency, fees, signers, deploys, recovery. The interesting parts are easy by comparison. Optimize for the boring parts first.
Make uncertainty explicit
If the system does not know something, the system must say so. Hiding uncertainty turns honest signals into dangerous actions.
Separate intelligence from authority
The component that computes opportunity must not be the component that holds the keys. Authority is granted through explicit gates, not proximity to the model.
Measure economic reality, not proxy metrics
Transaction count, gross spread, and modelled PnL are intermediate signals. Realized net PnL after every actual cost is the only authority.
Production is part of the product
Deployment, rollback, observability, and reconciliation are product capabilities. A system that cannot be safely released is not a product.
Prefer systems that fail safely
When uncertainty grows, authority should shrink. Fail-closed is not slow — fail-closed is fast at refusing the wrong thing.
Automate the boring path, protect the dangerous path
Routine decisions should be automated. Decisions with irreversible consequences should pass through gates a human — or a defense-in-depth system — must approve.
Design the interface around what the caller wants to say
The caller does not want to know your ecosystem. They want to express their intent. Make the interface that intent; absorb the churn underneath.
Trust is a product
Operators are users. A system they cannot trust in one screen is a system they will not use, regardless of how good its edge is.
Split universal from specific
Universal behavior belongs in a kernel. Project-specific behavior belongs in a profile. Profiles are inspectable, versionable, and small.
Product → AI → Systems → Engineering.
Product
Strategy, discovery, marketplace mechanics, growth, monetization, experimentation, and analytics — applied to systems that have to ship.
- Product strategy and discovery
- Marketplace and platform products
- Growth and monetization
- Experimentation and ranking
- Analytics and operator dashboards
- Risk-controlled decision products
- Staged release and rollback planning
AI / Agents
Models are not the product. Routing, harnesses, evaluation, tooling, and feedback loops are.
- AI engineering
- Agent architecture and operating kernels
- Model routing and provider abstraction
- Harnesses and tool hygiene
- Evaluation and failure classification
- Bounded retry and recovery
- Context budget and memory management
Systems
Distributed systems, event-driven architecture, observability, reliability, economic controls, and pipelines.
- Distributed systems
- Event-driven architecture (NATS, queues)
- Observability (Prometheus, dashboards)
- Reliability and protected release
- Economic controls and risk gates
- Dual-provider authority and reconciliation
- Data pipelines and durable evidence
Engineering
Languages and infrastructure I have shipped against. Each one earned its place on a real system.
- Python
- Rust
- Go
- TypeScript / JavaScript
- Solidity
- SQL (PostgreSQL, SQLite)
- Docker / Docker Compose
- PostgreSQL, NATS JetStream, Prometheus
- GitHub Actions and protected CI/CD