WELCOME.txt
corrosion.vst.architecture
HOW_I_WORK.md
Every engagement begins with a written technical spec. No spec, no code. This prevents scope drift and ensures we both know what "done" means before a line is written.
I work in documented, asynchronous cycles. Weekly written updates, not daily standups. Your time is valuable; I respect it by being precise and self-directed.
If your timeline is impossible, I'll tell you upfront. If your budget doesn't match scope, we'll renegotiate before starting. No surprises at invoice time.
You own everything built. Clean repos, documented APIs, runbooks included. I don't create dependency.
WHO_I_DONT_WORK_WITH.md
If "we'll figure it out as we go" is your engineering philosophy, we're not a match. Ambiguity is expensive and I refuse to bill you for confusion.
I won't build LLM wrappers disguised as products. If you need "ChatGPT but for X" without a clear moat or defensibility thesis, I'll decline politely.
Pre-seed with a real prototype: possible. Series A company asking for "sweat equity": no. My rent is not a venture bet on your cap table.
User tracking without consent, engagement manipulation, or deceptive UX. Hard no. I review use cases before signing any agreement.
"Software is not a product.
It is a decision
made permanent in code."
Every architectural choice, every abstraction, every shortcut — they compound. I treat code as a long-term liability, not a short-term deliverable.
Complexity is a debt, not an asset.
Every layer of abstraction you add must justify its existence with measurable value. Teams collapse under architectures that impressed in a pitch deck but couldn't survive a Tuesday morning incident.
AI is infrastructure, not magic.
LLMs are probabilistic systems. They fail silently, drift over time, and hallucinate under pressure. Treating them like deterministic APIs is how you ship a liability. I build with evals, guardrails, and fallbacks.
The best system is the one that ships.
Perfection is the enemy of production. I optimize for correctness, observability, and maintainability — in that order. A working system with known tradeoffs beats an elegant system that never deploys.
Honest engineering over comfortable lies.
I will tell you when your idea is technically unsound. I will flag timeline risks before they become crises. I will document decisions I disagreed with. Candor is a professional obligation, not an option.
Ownership means leaving, not staying.
My goal is to make myself unnecessary. Every engagement ends with documentation, runbooks, and a team that can operate without me. Dependency is a consulting anti-pattern I actively refuse to create.
- →Written specs before any code is written
- →Eval suites shipped alongside every LLM feature
- →Architecture Decision Records for every major call
- →Honest scope and timeline pushback when needed
- →No vendor lock-in without documented justification
- →On-call runbooks before any system goes live
Boring tech is a feature.
PostgreSQL before a distributed database. A cron job before a message queue. The most maintainable system is the one your next engineer can debug at 2am without Slack.
Evals before deployment.
Every LLM system ships with a benchmark suite. If you can't measure it, you can't improve it—and you definitely can't sell it to an enterprise customer with a legal team.
Runbooks, not tribal knowledge.
Every system I build ships with operational documentation. On-call runbooks, architecture decision records, deployment guides. Your team shouldn't need me to keep the lights on.