128 articles on engineering, leadership, and career growth.
128 articles
You can't evaluate a candidate's code, so stop trying. Across 1,000+ interviews, the strongest predictor of a good hire wasn't a right answer — it was how they talked about a real failure. Here's the one question that works, and the hire it would have saved me from getting wrong.
When your engineers ask for cleanup time, they're not gold-plating — they're asking you to make a loan repayment before the interest compounds. I owned a product where a cut corner went uncaught long enough to become a formal non-conformance and three months of rework. Here's how to price technical debt instead of vetoing it on instinct.
Nobody on your team will walk in and say the system is fragile — not because they're hiding it, but because they've normalized it. Six behavior-based questions that surface real technical risk without requiring you to read a line of code.
AI can build your MVP — I've built the system that does this professionally, shipping MVPs roughly 3x faster. That's not a reason to relax. Generation is now free, which means your judgment about what to build is the only bottleneck left, and AI won't tell you when it's building the wrong thing.
Every feature you approve before launch costs you twice — once to build it, once in the reluctance to cut it. I over-engineered a product for millions of users; it ended up serving three. Here's the question that would have caught it, and how to sort a pre-launch roadmap into build, fake, and cut.
Application availability decoded honestly: what 99%, 99.9%, 99.95%, 99.99%, and 99.999% actually allow in downtime, the two formulas that calculate it, why every extra nine costs roughly 10x the last, how dependencies in series cap your ceiling before your effort does, and SLA/SLO/SLI/error budgets. The argument underneath it all: past four nines for most teams, the number that saves your night isn't a bigger percentage — it's how fast you recover.
AI coding assistants roughly doubled code duplication while cutting refactoring in half, and experienced developers report AI tools make them slower, not faster. The fix isn't banning AI-authored code — it's gating on one question: if the person who wrote this isn't on the call, can the on-call still fix it at 3am? A concrete diagnostic, not a moral panic, with three guardrails an architect can put in place this quarter.
Teams are reaching for planners, critics, and orchestrators before a single well-scoped agent has been pushed to its limit — the same over-engineering mistake wearing an agent diagram. A constraint-aware framework for the four costs coordination has to pay off (state handoff, failure-mode multiplication, non-deterministic debugging, cost/latency compounding) before multi-agent earns its complexity, from someone who built the orchestrator and still says most teams don't need it yet.
A 2026 survey put cost, not quality or security, as engineering leaders' #1 AI concern at roughly 42%. Agent runs, retries, and context bloat compound quietly and surface on an invoice instead of a design review — the same mechanism that once burned $5,350 out of a forgotten Lambda. The fix isn't a vendor cost calculator or 'measure what matters.' It's a budget ceiling made at design time, tracked against one metric: cost-per-verified-unit-of-work, not cost-per-token.
A retrieval-augmented system that answers wrong failed in exactly one of two places — the retriever handed the model garbage, or the model had good material and still wrote garbage. They look identical from the outside and need completely different fixes. This is the diagnostic discipline that stops teams from rewriting prompts for six weeks while retrieval is quietly broken: measure retrieval on its own, then generation on its own, in that order — and fix the layer that's actually failing instead of the one that's cheapest to edit.
A good software architecture mentor reviews your real decisions and tells you the truth early — not a famous name or a $200/hour booking. How to spot the right mentor, where to find one, and how to ask without getting ignored.
I built a SaaS with multi-tenancy, event-driven architecture, and elaborate domain abstractions — for millions of users that never arrived. The product now serves two or three internal people in the same building. This is the architecture post-mortem, and the operating patterns that would have changed the outcome.
An anonymized teardown of a consumer platform I scaled to several million users. The architecture that carried ~30K req/s at peak, the four walls we hit on the way up — database connections, a cache stampede that caused a 19-minute outage, payment double-charges, and a credential-stuffing attack that looked like organic growth — and the trade-offs behind each fix. Topology, layered caching, the data tier, WAF and rate-limiting stack, and four real ADRs. No vendor named; the engineering is exactly as it happened.
Most agent SDLC setups use the LLM as the runtime for everything—including deciding which files to read—which is the biggest source of token waste and non-determinism. SpecLoom flips this: write your spec as typed blocks with IDs and dependencies, and a deterministic compiler emits a minimal, hash-stamped bundle for one task. A real engineer bundle compiles to ~370 tokens instead of 20–60k, the same task always produces a byte-identical bundle, and @spec:ID#hash anchors turn spec/code drift into a CI failure. Covers the .loom format, the Deterministic Context Compiler, tiered budget degradation, the drift gate, engine-enforced persona gates, and a 60-second loop to try it.
Most teams ship an LLM call in an afternoon and spend the next month firefighting. This walkthrough shows the correct order — spec, architecture decision, eval criteria, implementation, CI gate, production observability — using a real cloneable repo (spec-to-ship-workflow) that runs in 10 minutes with zero API keys. Covers the retrieval-confidence floor that prevents most RAG hallucinations, two-mode providers for CI reproducibility, golden test cases before implementation, and the eval drift alert that catches regressions no other metric sees.
The number one reason AI coding agents produce confident, wrong code is they're guessing about your system. MCP (Model Context Protocol) fixes that — a standard way for agents to pull real context from real sources instead of you copy-pasting it. What MCP is (a USB-C port for AI tools), how to set up your first server, which context to expose (schema, docs, issues) and what to keep out, and the security model you must get right.
A practical reference catalog of the eight architectures worth knowing — layered, modular monolith, hexagonal, event-driven, CQRS + event sourcing, microservices, serverless, and the strangler fig. Each with a diagram, the forces that make it the right call, the failure mode that makes it the wrong one, and a link to runnable reference code. Plus a decision flowchart so you pick on fit, not hype.
You can't ship a reliable LLM feature on vibes. Evals are the regression net for a dependency that's non-deterministic, drifts when the provider updates the model, and fails silently. How to build one without boiling the ocean: start with 30 real examples, layer three kinds of checks (assertion, LLM-as-judge, human), measure faithfulness, and run it on every prompt, model, and retrieval change.
Autonomous PRs are real leverage and a real way to drown your best engineers in review debt. The operating model: autonomy scales inversely with blast radius, you can only generate as many PRs as you can genuinely review, the three gates every autonomous PR must pass, and the metrics that tell you it's working instead of quietly rotting your codebase.
Adding an LLM to your product is a distributed-systems problem with a non-deterministic dependency, not a single API call. When RAG actually helps (and when a prompt will do), how to think about vector databases and chunking without cargo-culting, the retrieval pipeline that separates demos from products, and the seven-point production checklist — evals, guardrails, cost ceilings, latency budgets, fallbacks, observability, and a human-in-the-loop boundary — to put in place before a real user touches it.
Naive RAG gets you a 70%-quality demo and a plateau. The gap to production is three retrieval levers most teams never pull: chunking on structure (not character counts), hybrid search (vector + keyword), and re-ranking an over-fetched candidate set. The deep dive on each, plus citations and the metrics that tell you where retrieval is failing. Retrieval quality beats model quality.
