// Topics / Engineering

Engineering

Definition

Engineering coverage in this archive spans 53 posts from Jan 2016 to Jan 2026 and treats engineering as a production discipline: evaluation loops, tool boundaries, escalation paths, and cost control. The strongest adjacent threads are teams, architecture, and ai. Recurring title motifs include engineering, ai, team, and debt.

Key claims

  • The archive repeatedly argues that engineering only creates leverage when it is wired into an existing workflow.
  • Early posts lean on security and without, while newer posts lean on ai and engineering as constraints shifted.
  • This topic repeatedly intersects with teams, architecture, and ai, so design choices here rarely stand alone.

Practical checklist

  • Define quality gates up front: eval sets, guardrails, and explicit rollback criteria.
  • Start with the newest post to calibrate current constraints, then backtrack to older entries for first principles.
  • When boundary questions appear, cross-read teams and architecture before committing implementation details.

Failure modes

  • Shipping agent behavior without hard boundaries for tools, data access, and approvals.
  • Optimizing for model novelty while ignoring reliability, latency, or cost drift.
  • Applying guidance from 2016 to 2026 without revisiting assumptions as context changed.

Suggested reading path

References

    Building Reliable AI Agents in Go Reliable agents aren't prompted into existence. They're engineered -- with bounded tools, validation at every step, explicit recovery paths, and the same discipline you'd apply to any production system. Here's how I build them in Go. agents reliability ai AI Technical Debt Is Eating Your Team Alive (And You Can't Even See It) AI debt doesn't look like normal tech debt. It hides in prompts nobody owns, evals nobody runs, and data pipelines nobody watches. By the time you notice, every change feels dangerous. technical-debt ai engineering AI Doesn't Make Your Team Faster. Shared Infrastructure Does. Individual AI speedups are a distraction. The real gains come from treating AI as team infrastructure -- embedded in docs, decisions, and onboarding. productivity ai teams AI-Assisted Code Migration: What Actually Works I used LLMs to help migrate a 200K-line Go codebase. The mechanical parts went fast. Everything else was still hard. ai code-migration refactoring Responsible AI Is Just Risk Management. Treat It That Way. Responsible AI is not an ethics committee. It is operational risk management, and teams that treat it otherwise are building liabilities. ai security risk-management AI Technical Debt Is Eating Your Codebase (You Just Cannot See It Yet) AI features create a new species of technical debt that hides in prompts, data pipelines, and model versions. By the time you notice it, the cleanup bill is brutal. ai technical-debt engineering Your LLM Bill Is Your Own Fault Everyone's complaining about LLM costs. Almost nobody has done the basics: caching, model routing, or even measuring what they're spending per feature. ai cost-optimization llm AI Safety Is Just Security Engineering With Extra Steps AI safety is not a philosophy problem for engineers. It is reliability, security, and accountability applied to a new kind of system. ai safety security AI in Production Is Just Engineering. Treat It That Way. ChatGPT changed expectations overnight, but shipping AI features that actually work is an engineering problem, not a model problem. ai production engineering Your Engineering Docs Are Probably Useless Most engineering documentation is ignored for predictable reasons. Here is how to write docs that people actually read. documentation engineering developer-experience Hybrid Work Is Harder Than Full Remote Everyone thinks hybrid is the compromise between remote and office. It is actually harder to get right than either extreme. hybrid-work remote-work teams What Actually Works for Distributed Teams (Six Months In) After running a remote-first company for years and watching everyone else scramble through COVID, here's what I've learned actually works -- and what doesn't. remote-work teams engineering Most Developer Productivity Metrics Are Management Theater Lines of code, velocity charts, commit counts — most developer productivity metrics are garbage. DORA metrics are the only ones worth your time. productivity metrics engineering What I Actually Changed About Engineering Interviews Over Zoom Whiteboard coding over Zoom is broken. Here's what I do instead when hiring engineers virtually. interviewing hiring remote-work Your Team Isn't Remote. It's Just on Zoom. Most teams claiming to work remotely are just recreating the office over video calls. Async communication is the actual unlock, and almost nobody is doing it right. remote-work async communication Your Business Continuity Plan Is Corporate Theater Most BCP documents are shelf-ware written by consultants. Here's what actually keeps engineering teams running when everything breaks. business-continuity disaster-recovery engineering Your Team Just Went Remote. Here's What to Do Right Now. COVID forced your engineering team remote overnight. Here's the no-fluff version of what actually matters in the first two weeks. remote-work engineering covid-19 Your Onboarding Is Broken and Everyone Knows It Most engineering onboarding is a polite abandonment ritual. Here's what I've learned building onboarding across three startups about what actually gets new engineers shipping fast. onboarding engineering teams Data Mesh Is an Org Chart Fix, Not a Tech One Most data problems are ownership problems. Data mesh gets that right. But adopting it as an architecture diagram exercise misses the point entirely. data architecture data-mesh Your Monolith Is Probably Fine Most teams shouldn't be migrating to microservices. Here's how to tell if you actually should, and how to do it without wrecking your delivery for eighteen months. microservices architecture monolith Your Staging Environment Is Lying to You Staging never catches the real bugs. Here's how I learned to test in production without burning everything down. testing production feature-flags Your SLOs Are Probably Useless (Here's How to Fix Them) Most SLOs are dashboards nobody acts on. Here's how to pick indicators that reflect real users, set targets grounded in data, and make error budgets actually change how your team ships. sre slo reliability Design for Failure or It Will Design Your Weekend Failure is not an edge case. It is the default state you temporarily hold off with good engineering. A few hard-won rules for building systems that bend instead of shatter. reliability architecture distributed-systems Your Internal Platform Is Probably a Liability Most internal developer platforms fail not because they're technically bad, but because nobody treated them like a product. Thoughts from building (and scrapping) platform tooling across three startups. platform devops developer-experience Migrating to TypeScript Without Losing Your Mind How to introduce TypeScript to a real JavaScript codebase incrementally, without halting product work or annoying your entire team. typescript javascript migration How We Track and Prioritize Tech Debt at a Fintech Startup A framework for cataloging technical debt, scoring it by impact and risk, and scheduling paydown without stalling feature delivery. technical-debt engineering management What I Learned Scaling an Engineering Team Lessons from growing an engineering org at the fintech startup -- what breaks, what works, and why clarity beats process every time. engineering management teams What I Learned About Code Reviews the Hard Way Most code reviews are theater. Here's how we fixed ours at the fintech startup and what actually made a difference. code-review engineering teams Stop Wasting Everyone's Time in Technical Interviews Most technical interviews test the wrong things. After hiring engineers at the fintech startup, here's what I've learned actually predicts job performance. hiring interviews engineering Machine Learning for Backend Engineers: What Actually Matters What backend engineers actually need to know about ML in production -- from someone who builds NLP pipelines for financial news. machine-learning backend python What I Learned Building Our Platform Team This Year Reflections on standing up the fintech startup's platform team in 2017 — what worked, what didn't, and why treating infra like a product changed everything. platform teams engineering Stop Trying to Fix All Your Tech Debt A two-number scoring system for tech debt that tells you what to fix now, what to schedule, and what to quietly accept. technical-debt engineering prioritization Stop Counting Code Reviews and Start Reading Them Most code reviews are theater. Here's what actually makes them worth the time. code-review engineering quality Engineering Manager vs Tech Lead: What's Actually Different Two leadership tracks, one fork in the road. A breakdown of what engineering managers and tech leads actually do day-to-day, based on how we structured it at the fintech startup. career leadership management Your Startup Doesn't Need a Security Team. It Needs a Security Champion. You can't afford a security team at a startup. But you can turn one motivated engineer per squad into a security champion — and that changes everything. security startups engineering Leading Without a Title — What Actually Works Nobody handed me a leadership mandate at the fintech startup. I had to earn it through credibility, clear communication, and doing the unglamorous work that moved things forward. leadership engineering career 2016: The Year I Stopped Fighting Infrastructure A personal look back at what mattered in 2016 -- Docker going mainstream, Kubernetes momentum, Go adoption, and lessons from building at Dropbyke and a fintech startup. year-review technology engineering Building Effective Engineering Teams What a year of building an engineering team at Dropbyke taught me about hiring, trust, and the habits that actually matter. teams engineering leadership Why We Chose Go for Our Backend Services How Go became the default backend language at Dropbyke and a fintech startup, what it replaced, and the honest tradeoffs we accepted along the way. golang go backend The Economics of State: Why Scaling Up Beats Sharding (Until It Doesn't) A production-grounded case for exhausting single-server headroom with pooling, replicas, and partitioning before taking on sharding complexity. postgresql databases scaling Building a Security-First Engineering Culture Security culture is not a training program or a tool purchase. It is a set of habits that leadership enforces through consistency, not speeches. security engineering culture Why Every Developer Should Understand Networking Too many developers treat the network as magic. It bites them in production every time. networking tcp dns Database Migrations Without Downtime A practical guide to evolving schemas without maintenance windows by keeping old and new code compatible at every step. databases migrations postgresql Hiring Engineers When You Can't Compete on Salary You cannot outpay Big Tech, but you can outshine it on impact, growth, autonomy, and clarity. This is how to hire great engineers with a startup offer in 2016. hiring startups engineering Building Resilient Systems: Lessons from Production Failures Production incidents show where architecture bends and where it breaks. These lessons focus on designing for failure, limiting blast radius, and making recovery routine. reliability resilience architecture The Real Cost of Running Your Own Servers in 2016 Most startups have no business running their own servers. The math is not close. cloud infrastructure aws Continuous Deployment Without the Chaos Continuous deployment is not a tooling problem. It is a discipline problem. We deploy the Dropbyke backend dozens of times a day because we built habits first and automation second. continuous-deployment devops ci-cd Security Incident Response for Startups A practical incident response playbook for small teams: define incidents, assign owners, contain fast, investigate calmly, and recover with clear communication. security incident-response startups API Design Principles That Stand the Test of Time Lessons from building the fintech startup's financial data API: the REST conventions that actually matter, the ones that don't, and why consistency beats cleverness every time. api rest design Postgres vs MySQL in 2016: A Practical Comparison A grounded look at PostgreSQL and MySQL as of April 2016, focusing on integrity, query power, and operational tradeoffs rather than benchmark hype. postgresql mysql databases Building a DevOps Culture from Scratch DevOps is a cultural shift, not a job title. This post lays out a practical, 2016-era path to shared responsibility, fast feedback, and resilient delivery without hand-wavy promises. devops culture engineering The True Cost of Technical Debt A pragmatic look at technical debt in 2016: what it is, how it shows up, how to measure it, and how to make a business case for paying it down without stalling delivery. technical-debt engineering leadership Why Microservices Aren't Always the Answer Most teams adopt microservices too early and pay for complexity they don't need yet. A well-structured monolith is faster, simpler, and keeps your options open. architecture microservices monolith