By “drift” I don’t just mean breaking changes between spec versions.
I mean the spec and the live API behavior fall out of sync (often because implementation changes land first and the spec lags, or vice-versa). The first time we notice is when a real UI flow breaks and someone has to spelunk Devtools to see what the server actually returned (missing fields, nullability changes, new enum values, shape differences...)
So spec-diff tools like Vacuum help once you’re comparing two OpenAPI files, but my pain is earlierm catching “spec vs reality” from normal dev/staging usage (real accounts + data) and getting an actionable report (which operation, what mismatch, request id/response snippet) before it turns into a broken UI + an hour of debugging.
sorry it came off that way. I dictated that one in Obsidian, so it picked a slightly polished phrasing. What I meant is just: simple choices keep saving you time later.
This hit a nerve because “simplicity” is one of those things you only notice when it’s missing, and most orgs don’t have a good way to reward “the thing that didn’t happen.”
I’ve watched this exact dynamic play out: one person ships the boring implementation, nothing breaks, everyone moves on. Another person ships the “platform” version, there are docs, diagrams, an internal talk… and now there’s a subsystem that needs to be explained to every new hire. Guess which one looks like “impact” on paper.
The part I think is under-discussed is that complexity has a carrying cost that rarely gets charged to the builder. The team pays it later: more surface area, more failure modes, more time spent reading before changing. In that sense, unearned complexity is like taking on leverage. Sometimes it’s the right move, but you should need a business case, not just enthusiasm.
What’s helped on teams I’ve liked: make “simplicity” legible by treating it as a decision record. In the PR/ADR, explicitly list the two “cooler” options you didn’t take and why, and write down the trigger conditions for upgrading later (“if p95 > X for Y days”, “if we add a second producer”, etc.). That turns “implemented feature X” into “made a deliberate tradeoff, reduced risk, and defined a clear escape hatch.” It also forces the room to argue with specifics rather than vibes like “future-proofing.”
Also +1 on the interview point. A lot of system design interviews are accidentally training people that the goal is to draw more boxes until the interviewer nods. The more senior move is usually: start simple, instrument, set thresholds, and only then add machinery. But that’s harder to “perform” in 45 minutes than rattling off Kafka and sharding.
If an org wants to fix the incentive, I think the question to ask in reviews isn’t “how big was the thing you built,” it’s “did you make the system easier to change next quarter.” That’s the kind of impact that compounds, and it’s usually correlated with simplicity.
Claude Code is an interactive coding assistant. Viba is an automation runtime. You wouldn't use Claude Code to run a cron job at 3am or watch a directory for new files.
Viba compiles your intent into a persistent and versioned workflow that runs unattended with triggers, retries, and history... more like a local first, AI-configured n8n than a coding agent.