// Topic
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
- Start here (current state): Building Reliable AI Agents in Go
- Then read (operating middle): What I Learned Scaling an Engineering Team
- Finish with (foundational context): Why Microservices Aren’t Always the Answer
Related posts
- Building Reliable AI Agents in Go
- AI Technical Debt Is Eating Your Team Alive (And You Can’t Even See It)
- AI Doesn’t Make Your Team Faster. Shared Infrastructure Does.
- AI-Assisted Code Migration: What Actually Works
- Responsible AI Is Just Risk Management. Treat It That Way.
- AI Technical Debt Is Eating Your Codebase (You Just Cannot See It Yet)
- Your LLM Bill Is Your Own Fault
- AI Safety Is Just Security Engineering With Extra Steps
References
53 posts
- 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.
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.
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.
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.
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 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.
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 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 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.
Your Engineering Docs Are Probably Useless
Most engineering documentation is ignored for predictable reasons. Here is how to write docs that people actually read.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Stop Counting Code Reviews and Start Reading Them
Most code reviews are theater. Here's what actually makes them worth the time.
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.
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.
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.
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.
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.
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.
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.
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.
Why Every Developer Should Understand Networking
Too many developers treat the network as magic. It bites them in production every time.
Database Migrations Without Downtime
A practical guide to evolving schemas without maintenance windows by keeping old and new code compatible at every step.
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.
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.
The Real Cost of Running Your Own Servers in 2016
Most startups have no business running their own servers. The math is not close.
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.
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.
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.
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.
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.
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.
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.