Engineering, judged.
The honest read on delivery, knowledge risk, code review, AI’s real impact, and what your payroll buys - receipts on every claim, nobody ranked.
DORA vs SPACE vs DX Core 4: Picking a Framework (2026)
DORA vs SPACE vs DX Core 4, compared fairly: what each framework measures, where each breaks, and how to choose for 2026 without dashboard theater.
Technical Due Diligence: The Engineering Checklist (2026)
The engineering-health checklist for investors, acquirers, and incoming CTOs: bus factor, delivery, review coverage, KTLO - and numbers you can re-derive.
Jellyfish Alternatives (2026): A Fair Field Guide
Jellyfish is quote-only and enterprise-first. Five alternatives for mid-2026 - LinearB, Swarmia, DX, Faros AI, Busfactor - judged fairly, receipts included.
LinearB Alternatives (2026): The Honest Shortlist
Six real LinearB alternatives compared for mid-2026 - Swarmia, Jellyfish, DX, Faros, GitClear, Busfactor - with honest trade-offs and cited pricing.
GitClear vs LinearB (2026): Diff Forensics or Delivery
GitClear vs LinearB for 2026 buyers: line-level code forensics against delivery flow, both pricing pages quoted, and the score neither will let you audit.
LinearB vs Faros AI (2026): Benchmarks or the Big Schema
LinearB vs Faros AI in a cited 2026 head-to-head: the benchmark cohort against the canonical schema, pricing floors, and what neither lets you re-run.
DX vs Swarmia (2026): Survey Depth or Working Agreements
DX vs Swarmia, compared honestly for 2026: survey science against Slack-native telemetry, what each tier gates, and where both leave the verdict to you.
Jellyfish vs DX (2026): Allocation Model or Survey Standard
A fair Jellyfish vs DX comparison for 2026: the patented allocation model against the survey standard, cited pricing, and the third lens both quotes miss.
LinearB vs DX (2026): Telemetry or Sentiment?
LinearB vs DX compared honestly for 2026: git telemetry and benchmarks against survey science and the DXI - method, pricing, and the fork that decides it.
Swarmia vs Jellyfish (2026): The Finance-Grade Face-Off
Swarmia vs Jellyfish in 2026: transparent rules against a patented effort model, capitalization on both sides, and what an auditor can actually re-derive.
LinearB vs Jellyfish (2026): Self-Serve or Sales-Led?
A fair LinearB vs Jellyfish comparison for 2026: self-serve metrics platform against sales-led finance intelligence, priced and sourced, plus a third lens.
LinearB vs Swarmia (2026): Scale or Transparency?
LinearB vs Swarmia, compared fairly as of July 2026: benchmarks and automation against Slack loops and honest AI detection - and the question neither answers.
Busfactor vs Hatica (2026): The $29 Question
An honest Hatica alternative comparison: their $29 CapEx and wellbeing angle conceded, our audit-grade provenance and priced verdict, and who fits which tool.
Busfactor vs Oobeya (2026): Dashboards or a Verdict
An honest Oobeya alternative comparison: their on-prem posture and integration breadth conceded, our receipts and priced verdicts, and who should buy which.
Busfactor vs Aviator (2026): Merge Queue Meets Diagnosis
A fair Aviator alternative read: monorepo merge automation fully conceded, no analytics layer to strawman, and where a diagnosis fits beside the queue.
Busfactor vs Graphite (2026): Ship Faster, Then Ask Why
An honest Graphite alternative view: stacked PRs, merge queue, and AI reviews act on your code; we diagnose the system behind it. Different jobs, cited.
Busfactor vs Cortex (2026): IDP or Engineering Verdict?
An honest Cortex alternative take: their service catalog and scorecards conceded, why an IDP is not an SEI, and when a platform team should run both.
Busfactor vs Port (2026): Scorecards You Define, or Ours
A fair Port alternative guide: the self-serve IDP and free tier conceded, why DORA rollups aren't a verdict, and how our exports could feed its catalog.
Busfactor vs Allstacks (2026): Dates or Root Causes
An honest Allstacks alternative comparison: ML forecasting and a Gartner nod conceded, our checkable diagnosis and priced fixes, and who fits which tool.
Busfactor vs Code Climate (2026): After the Pivot
An honest Code Climate alternative review: they now sell 12-week AI consulting engagements; we ship the same thesis as self-serve software. Who buys which.
Busfactor vs Harness in 2026: Artifacts, Not Screens
A cited Harness SEI alternative comparison: their on-machine agent captures tokens and prompts at a depth we concede - and never want. Artifacts, not screens.
Busfactor vs Typo in 2026: The Neighbor That Reviews PRs
An honest Typo app alternative comparison: their AI reviewer, MCP server, and price conceded; our verdict layer, money spine, and receipts contrasted.
Busfactor vs Multitudes in 2026: The Ethics Twin's Labels
A fair Multitudes alternative comparison: where their AI cost data and wellbeing sources win, where the High/Low adopter labels clash, and who fits which tool.
Busfactor vs Waydev in 2026: The Missing Method
A fair Waydev alternative comparison: five modules and a free token tier conceded, an undisclosed AI attribution method questioned, and who should pick which.
Busfactor vs Faros AI in 2026: Data Lake or Diagnosis?
A cited Faros AI alternative comparison: their connector breadth and enterprise scale conceded, the GenAI insight layer questioned, and who should buy which.
Busfactor vs GitClear 2026: Can You Open the Per-Dev Score?
An honest GitClear alternative comparison: their line-level forensics conceded, both products ordering named people, one opening the evidence behind it.
Busfactor vs DX in 2026: Repo Receipts or Survey Science?
An honest DX alternative comparison: their survey science and benchmark cohort conceded, what a Likert composite can't prove, and who should pick which tool.
Busfactor vs Swarmia in 2026: The Most Honest Rival
An honest Swarmia alternative comparison: Slack loops and the free tier conceded, the default-on low-confidence AI signal examined, and who should pick which.
Busfactor vs Jellyfish (2026): Can Your Auditor Recompute?
A fair Jellyfish alternative comparison for CFO-minded CTOs: patented effort models and R&D tax credits versus recomputable finance numbers with a printed hash.
Busfactor vs Navigara (2026): Who's Actually Deterministic?
A cited Navigara alternative comparison: what their docs say about the LLM behind ETV, what we refuse to build, and which teams each product actually fits.
That 4,000-Line PR? Everyone's Pretending to Review It.
Nobody can genuinely review a four-thousand-line diff. How giant pull requests turn review into theater, and how to shrink them without slowing anyone down.
Why Are Code Reviews Taking So Long? (It's One Queue)
Slow code reviews are rarely a people problem. Usually one reviewer's queue carries the whole team. How to find that queue, prove it, and unblock it.
The Sprint Ends. The Work Doesn't. Every Single Time.
Sprint carryover is not a planning quirk - it is your throughput telling you the truth. How to measure the gap and plan from evidence instead of hope.
Half Your 'In Progress' Is Dead. The Board Hides It.
Sort your board by last-updated and count the silence. Stale work in progress is paid-for delivery dying quietly - how to find it, clear it, and keep it gone.
Busfactor vs LinearB (2026): Cohort or Checkable Numbers
An honest LinearB alternative comparison: where their benchmarks and automation win, where our checkable numbers win, and who should pick which tool.
We Audited Every 'Deterministic' Engineering Analytics Tool
What we found in vendor docs: LLM classifiers inside scoring loops, undisclosed coefficients, per-developer scores. Every claim cited to the vendors' pages.
Is Your Team Ready for AI Coding Tools? A Checklist
Adoption is not readiness. The checklist that predicts whether AI coding tools will compound your output or your debt: reviews, tests, attribution, rework.
AI Agents in Your Repo: Gate, Log, Review
Autonomy levels, bot-authored PRs, and guardrails: how to let AI coding agents work in your repo without losing review coverage or the audit trail.
Sprint Velocity: What It Can and Can't Tell You
Sprint velocity is a planning tool that gets promoted into a performance metric. What velocity honestly measures, where it lies, and what to track instead.
How Much of Our Code Is AI-Written?
Commit trailers, bot accounts, co-author lines: how to measure your AI-authored code share with explicit signals instead of detector guesses.
DORA Metrics Explained (Without the Fluff)
The four DORA keys, the real 2024 elite/high/medium/low bands, and the caveats the consultant deck skips - including why 'medium' beat 'high' on failures.
Should We Buy More Copilot Seats? Check the Repo First
Seat expansion is an evidence question. How to compare an AI tool's merged-PR cohort against your baseline on cycle time, review latency, and rework first.
AI Wrote It. Nobody Owns It. Bus Factor Just Went Up.
Agents write code no human has fully read. How to find the areas where AI churn piles up with no real owner, and what that does to your bus factor.
Your Team Ships at Midnight. That's Not Dedication.
Commit timestamps say the real workday ends after midnight. Crunch, timezones, or night owls? How to read after-hours creep without building a shame board.
Review Coverage: How Much Code Ships Unread
Review coverage is the share of merged code a second person actually read. What self-merges quietly cost you, how to measure it, and honest targets to set.
Your AI Tools Were Supposed to Make You Faster
Adoption is high, the roadmap is no faster, and the board wants AI ROI. What research actually shows about AI coding gains and where they leak away.
Cycle Time vs Lead Time: What Each One Hides
Lead time and cycle time measure different waits, and each hides a failure mode. Definitions, the published bands, and how to decompose cycle time by stage.
AI Readiness Assessment for Engineering Organizations
Is your engineering org ready for AI? The seven factors you can score from your repo today - reviews, tests, knowledge, docs - and how they become a verdict.
Your CI Bill Is Payroll, and Nobody Has Priced It
Slow CI turns payroll into waiting. How to price your CI pipeline cost in engineer-hours from data you already have, and which fixes pay back first.
Your Release Date Is Fiction (and Your Team Knows It)
Slipping releases are rarely an estimation problem. Batch size, maintenance load, and invisible rework decide the date - here's the first free step to fix them.
Pull Request Stuck in Review? A Triage Guide
A PR stuck in review is blocked, abandoned, or radioactive - three different problems. How to tell which you have, and unstick each without a guilt trip.
Vibe Coding: Fast Until Nobody Can Explain the Code
What vibe coding is, where it genuinely works, and the point where shipping code nobody can explain turns into churn, rework, and a bus factor of zero.
Done Isn't Done: Your Tickets Are Running in Circles
Reopened tickets and status ping-pong are your delivery process leaking. How to count ticket loops, read them fairly, and stop the Done column from lying.
What to Bring Up in a Retrospective: Topics That Matter
A concrete list of retrospective topics worth raising - where time went, what came back broken, planning misses, review friction - phrased without blame.
AI Code Churn: Why AI-Written Code Gets Rewritten
Code rewritten weeks after shipping isn't velocity, it's a treadmill. What AI code churn is, how to measure it, and how to tell iteration from regression.
The Code Review Checklist Seniors Actually Use
A concrete code review checklist with the reasoning behind each item - what to check first, what to automate, and why most review findings aren't bugs.
Is AI Making Our Code Worse? How to Actually Check
Industry data shows duplication and churn climbing with AI. Whether that is true in your repo is checkable: a cohort comparison that answers with git receipts.
What Losing Your Lead Actually Costs (a Real Number)
The cost of losing a software engineer is computable from your own numbers - replacement, ramp, orphaned knowledge. Price it while they still work here.
The Leak in Your Budget Is a Process, Not a Person
The waste in software development is rarely a person. How to find and price the process leaks - review waits, rework, dead work - hiding in your payroll.
WIP Limits: Start Less, Finish More
Why too much work in progress makes everything late, what WIP limits actually do, how to set them without theater, and the queue math behind it all.
The AI Code Went In Fast. It's Coming Back Just as Fast.
AI-assisted code ships faster and comes back sooner. How to measure your AI code rework rate from git, and what the churn research actually shows.
AI Code Review Tools: What They Catch and Miss
AI code reviewers are a tireless first pass and a confident non-reader of context. What they reliably catch, what they miss, and where humans stay.
PR Pickup Time: The Metric Nobody Watches
Most 'slow review' is a PR sitting untouched, waiting for a first look. Why pickup time is the highest-leverage review metric - and the cheapest to fix.
Deployment Frequency: What 'Elite' Really Means
DORA's deployment-frequency bands, what 'on demand' actually means, why batch size is the real story, and the honest caveats behind the word 'elite.'
AI Slop Code: What It Is, How to Catch It in Your Repo
AI slop is code that ships fast and gets rewritten faster. The git-visible signals that expose it, and how to clean it up before it compounds.
Rework Rate: The Productivity Metric That Doesn't Lie
Rework rate measures how much fresh code gets rewritten within weeks - paying twice for the same work. How to measure it, read it, and not abuse it.
How to Measure AI Adoption in Your Engineering Org
Seat counts measure spend; surveys measure mood. Real AI adoption is measured in the repo: commit share, PR share, AI-reviewed share, and the per-tool split.
How to Report Engineering Progress to Executives
What to put in an engineering status report executives will actually read: a working template, the few metrics worth trending, and what to leave out.
You Ship Once a Month and Call It Stability. It Isn't.
Monthly releases feel safe, but each carries a month of risk. DORA says speed and stability rise together - how to increase deployment frequency for real.
How to Get Your PR Reviewed Faster (Author's Edition)
Author-side tactics to get your pull request reviewed faster: right-size the diff, write a description that works, ask one person, time it well.
The Debt Nobody Prices: AI-Generated Code
AI-generated code ships with an unpriced liability: duplication, churn, and review burden. What the repo data shows, and how to put a number on it.
Run the Fire Drill Before a Resignation Runs It for You
A resignation will run this drill for you eventually, on its schedule. How to rehearse losing a key engineer now, while the answers are cheap to fix.
Data-Driven Retrospectives: Bring Receipts to Retro
Retros that run on vibes decay into ritual. How to bring delivery data into retrospectives without turning them into blame courts: trends, receipts, one fix.
AI Productivity Paradox: Feeling Faster, Shipping Slower
Developers report feeling faster with AI; measured outcomes tell a messier story. What the research actually found, and how to test it on your own team.
How to Reduce PR Review Time (Without Rubber Stamps)
Faster review that isn't shallower review: smaller PRs, spread load, pickup-time pressure. What actually shortens review time without approval theater.
How to Measure the ROI of AI Coding Tools
Seat price is easy; return is not. What to measure beyond acceptance rate - churn, rework, review burden - before calling an AI coding tool a win.
How to Measure Developer Productivity (the Honest Way)
No single number measures developer productivity honestly. What to measure instead - system flow, quality, sustainability, perception - and what to refuse.
You Can't Tell Your CEO When It'll Ship. That's a Choice.
The honest answer to the ship-date question is a range built from your own delivery history, not a confident date. How to build that range in one afternoon.
AI-Assisted Development: What the Evidence Says
The honest state of AI-assisted development: where coding tools measurably help, where they quietly cost you, and how to tell which one your repo is.
Your Review Stats Only Count the PRs That Got Reviewed
Latency dashboards only see reviewed PRs. The ones merged without review vanish from the math. How to measure coverage, self-merge share, and close the gap.
Code Review for Tiny Teams (and Teams of One)
Code review with five devs, three, or just you: honest coverage targets, a lightweight process that holds, and what replaces the second reader solo.
MTTR Is Four Different Metrics. Pick One Honestly
Repair, recovery, respond, resolve: MTTR hides four different metrics. How to pick one definition, measure it honestly, and read incident data without lying.
Your Wiki Is a Museum. The Real Docs Live in One Head.
Everyone agrees the wiki is out of date; nobody can say by how much. How to measure documentation health from git - presence and staleness, per area.
What Your Git History Knows About Your Team
Your git history is a complete, timestamped record of how your team actually works. What it can tell you, what it honestly can't, and how to read it.
Code Review Feedback: Firm, Kind, and Actually Read
Code review feedback that gets read and acted on: comment patterns that work, example rewrites that show the difference, and the noise worth deleting.
Unplanned Work Is Eating Your Roadmap. Here's the Receipt.
Unplanned work quietly rewrites your roadmap every quarter. How to measure the bugs-and-firefighting share of engineering time - and shrink it with receipts.
Sprint Planning 101: How to Plan a Cycle That Ships
How to run sprint planning that produces a plan the team believes: a step-by-step agenda, honest capacity math, a definition of ready, and common traps.
The Business Case for Refactoring (in Money)
How to turn refactoring into a funded line item: price the interest, scope the principal, show a payback period - a case the budget owner can actually approve.
Your Team Isn't Slow - It's Stuck in Queues You Can't See
When engineering feels slow, the reflex is pressure and process. The real first step is cheaper: find where the time goes - most of it is waiting, not working.
Rubber-Stamp Reviews: Spotting Approval Theater
Fast LGTMs with zero comments aren't review - they're theater. The PR-data signals that expose rubber-stamp approvals, and the system fixes that end them.
Lines of Code Is a Garbage Metric
Lines of code measures typing, punishes deletion, and rewards bloat - and AI just broke it further. Why the metric survives, and what to measure instead.
Jira Hygiene: Make Your Ticket Data Worth Reading
Your delivery metrics are only as honest as your tickets. A practical Jira hygiene playbook: fewer states, real timestamps, and habits that survive a sprint.
Why Small Pull Requests Win (The Data)
The research case for small pull requests: the 200-400 line ceiling, why defect detection collapses in big diffs, and how to actually keep PRs small.
How to Reduce Cycle Time (Fix the Waits, Not the Work)
Cycle time is mostly waiting, not working. Split it into pickup, review, merge, and deploy; find the stage eating your weeks; fix the queue that owns it.
Doubling Your Estimates Won't Fix Being Late. This Will.
Estimates measure the work, but delivery time is dominated by waiting, interruptions, and rework. Why padding never helps, and the audit that shows what will.
Review Load: Is One Person Your Whole Safety Net?
When one person does most of the code review, you have a bottleneck, a burnout risk, and a bus-factor problem in one. How to see and rebalance review load.
Change Failure Rate: Honest Measurement, No Theater
What change failure rate actually measures, the real DORA 2024 bands - including the medium-beats-high anomaly - and how teams game it without noticing.
PR Descriptions That Get Read (and Merged)
What a pull request description needs so reviewers actually read it: the why, the risk map, and test evidence - plus a template you can steal today.
Your New Senior Hire Hasn't Shipped Anything Real Yet
A senior hire on full salary, a month in, nothing real merged - and nobody measured it. Time to first PR exposes the ramp tax and who gates each area.
The Real Cost of Technical Debt (Quantified)
Surveyed developers report a third of the week going to technical debt. How to price yours honestly - and the overclaims a CFO will shred on sight.
DORA vs SPACE vs DevEx: Which Framework, When
DORA, SPACE, and DevEx answer different questions - delivery outcomes, productivity dimensions, daily friction. A decision guide for choosing between them.
Code Review Metrics That Matter (and Four That Don't)
Code review metrics worth tracking - pickup time, coverage, size, load - the vanity numbers that reward speed-approving, and how each one gets gamed.
Your Backlog Is a Graveyard. Leadership Plans on It.
Hundreds of open tickets nobody will ever do, requests that die unanswered, and plans built on that fiction. The case for a measured backlog bankruptcy.
Half Your PRs Link to Nothing. Your Roadmap Is a Vibe.
Nobody can say what shipped for the initiative - the work is in git, the plan is in Jira, and nothing joins them. Measure linkage; get the split as a fact.
Flow Efficiency: Why Everything Takes Forever
Flow efficiency splits elapsed time into working and waiting - and waiting usually wins. How to measure it honestly and shrink the queues eating your weeks.
Code Review Culture: What Healthy Teams Do Differently
Code review culture is the norms, not the tooling: how healthy teams handle turnaround, teaching, seniority, and disagreement - with research receipts.
How to Track Software Delivery: A Practical Setup Guide
A practical guide to tracking software delivery: which events to capture, the few metrics that matter, honest baselines, and a cadence that sticks.
Code Review Best Practices That Survive Reality
Code review best practices backed by data: PR size limits, pickup-time targets, review load, and what review actually catches - with sources, not vibes.
The Engineering Metrics That Actually Predict Delivery
The four DORA keys plus the flow metrics under them - what each predicts, what each hides, and how to read delivery metrics without dashboard theater.
CapEx vs OpEx for Software: The Question Finance Asks
Which engineering work is an investment and which is an expense? The CapEx vs OpEx split for software, under FASB's new rules and IAS 38, in plain terms.
You're One Engineer Away From Disaster. Here's Why.
Every ticket in that area routes to one name, and you plan around their vacations. How to shrink a bus factor of one before it becomes an emergency.
Capitalizing Software Development Costs in Agile
Agile has no design phase for accountants to point at. How software capitalization works with continuous delivery, and how to keep evidence audit-ready.
The 'Hit by a Bus' Conversation You Keep Postponing
Every team has a morbid what-if it never discusses out loud. How to run a hit-by-a-bus drill in ninety minutes, and what to do with the answers.
Key-Person Risk: The Quiet Threat in Every Codebase
Key-person risk forms wherever your best engineer keeps saying yes. What it is, how git history exposes it, and how to fix the system - not the person.
Single Points of Failure in Your Engineering Team
You removed single points of failure from your infrastructure years ago. Your team still has them: the deploy person, the billing expert, the one reviewer.
Developer Experience Metrics (SPACE, Explained)
The SPACE framework explained: five dimensions of developer experience, what each one actually measures, and how to use DevEx metrics without surveillance.
Knowledge Transfer: Getting It Out of People's Heads
Knowledge transfer fails when it's a two-week offboarding panic. How to make it continuous with code review, pairing, rotation, and docs that live in the repo.
Is Your Engineering Team Overloaded? Signs in the Data
Overload hides behind busyness. The signs: WIP above headcount, growing review queues, after-hours creep, maintenance eating the week - and how to confirm it.
Questions to Ask Before Buying Engineering Analytics
The vendor-agnostic question list for evaluating engineering analytics: data honesty, team-versus-individual metrics, privacy, pricing, and exit costs.
The Legacy System Only One Person Understands
Every legacy system ends up with one living interpreter. How that happens, what it costs before anyone leaves, and how to spread the knowledge in time.
What Slow Code Review Costs You in Payroll
Every day a PR waits, someone's loaded cost is paying for the queue. How to price review wait against payroll and make 'reviews feel slow' a real number.
DevEx Survey Questions People Answer Honestly
DevEx survey questions that get honest answers: what to ask about feedback loops, cognitive load, and flow - and the survey mistakes that poison results.
Your Senior Engineer Quit. Now What?
The two weeks after a senior engineer quits decide how much of their knowledge you keep. Map what they owned, rank the orphans, transfer what matters.
Feature Factory: When Output Replaces Outcomes
What a feature factory is, the signs John Cutler named, how output-over-outcome shows up in your delivery data - and the honest way off the shipping treadmill.
Glue Work: The Invisible Load Holding Teams Together
Glue work - unblocking, onboarding, reviews, docs - is what makes teams actually ship, yet activity metrics can't see it. How to notice, value, and share it.
The Same Three Files Keep Breaking. It's Not the Files.
Every release ships a follow-up fix, always in the same corner of the codebase. Measure hotfix rate and blast radius - and retire the hero act.
The Offboarding Checklist That Saves the Codebase
Developer offboarding is more than revoking a laptop. The full checklist: ownership mapping, access and credentials, review handoff, and knowledge transfer.
You Pay a Fortune for Engineering. Where Does It Go?
Payroll is your biggest line item and the roadmap shows three shipped features. Where engineering spend actually goes, and how to answer without blame.
Performance Reviews for Engineers, Minus Stack Ranking
How to run engineering performance reviews without a forced curve: evidence-linked scorecards, system context first, and calibration on receipts.
How to Calculate Bus Factor From Git History
A concrete method for calculating bus factor from commits and reviews - not a survey, not a guess. What counts as ownership, and where the math lies.
Fully Loaded Cost of an Engineer (It's Not the Salary)
The fully loaded cost of an engineer is far more than salary - and every waste calculation depends on it. How to compute yours, and what to do with it.
New Engineering Manager? What to Look At First
A first-90-days checklist for new engineering managers: the queues, knowledge risks, and team signals to read before you change anything at all.
What Is Engineering Intelligence? A Plain-English Guide
Engineering intelligence explained in plain English: what these platforms measure, how they differ from DORA dashboards, and what they can never tell you.
Succession Planning for Engineers (Yes, Engineers Too)
Companies write succession plans for executives while the engineer who holds payments has no backup. How to run succession planning for critical code.
Technical Due Diligence: What Acquirers Actually Check
What acquirers examine in technical due diligence - bus factor, debt, ownership, delivery receipts - and how to fix the findings before the data room opens.
Should You Measure Individual Developer Performance?
The honest answer is: not the way you're about to. What per-person developer metrics destroy, and which questions about people you can answer safely.
Code Ownership Models: Who Actually Owns This File?
Strong, weak, and collective code ownership each trade quality against bus factor. What the research shows, and which model fails your team slowest.
KTLO vs New Development: Finding a Defensible Balance
Keep-the-lights-on work is necessary until it silently eats the roadmap. How to measure your KTLO share honestly and argue the reallocation with receipts.
Stack Ranking Software Engineers: Why It Backfires
Stack ranking engineers optimizes for looking productive, and your best people can read a leaderboard. Why forced ranking backfires, and what to run instead.
How to Reduce Bus Factor Without Slowing the Team
Pairing on everything is a tax nobody pays for long. The bus-factor fixes that stick - review rotation, ownership spreading, living docs - ranked by cost.
Engineering Economics: Putting a Number on Your Team
Engineering is most companies' biggest opaque line item. How to price loaded cost, delay, rework, and CapEx - and turn payroll into decisions.
How to Prevent Developer Burnout: A Manager's Playbook
The WHO defines burnout as unmanaged workplace stress - so the fix is managing the workplace. Rebalance load, bound on-call, cut WIP, protect recovery time.
Bus Factor 1: The Areas That Orphan When One Person Leaves
Bus factor 1 means one resignation orphans an area. How to inventory every single-owner zone in your codebase from git history and fix the worst first.
The Underpaid Engineer You're About to Lose
The engineer you can least afford to lose is often quietly paid below market. How to spot the criticality-to-pay mismatch and fix it before they resign.
Documentation Debt: Why Your Team Can't Find Anything
Documentation debt is why most developers lose 30-plus minutes a day searching for answers. How it accrues, what it costs, and how to pay it down for real.
How to Tell If an Engineer Is Struggling
Struggling engineers hide it - the signs show up in the work first. Long-lived branches, shrinking scope, silence. How to spot struggle early and actually help.
Build Your Own Metrics Dashboard vs Buying One
The honest math on building an engineering metrics dashboard versus buying one: what DIY really costs, when scripts win, and when a tool earns its keep.
Your Acquirer Will Find Your Bus Factor Before You Do
Diligence teams read git history and price knowledge concentration into deals. How to audit your own key-person risk before a buyer's analyst does.
Onboarding: How Long Until a New Hire Ships?
Time-to-first-PR, ramp curves, and why new engineers take months to land: what research actually shows, and the system fixes that shorten the ramp.
Knowledge Silos in Engineering Teams: How to Find Them
Knowledge silos don't announce themselves - they surface the week someone resigns. How to detect them from commit and review patterns before that.
How to Run 1:1s With Engineers (Cadence + Questions)
A working guide to engineering 1:1s: the right cadence, questions that get past 'fine', how to prep with receipts, and the mistakes that turn 1:1s into status.
Tribal Knowledge: Get It Out of Heads, Into the Repo
Tribal knowledge is everything your team knows that the repo doesn't. Why it accumulates, what it costs, and how to move it out of heads on purpose.
How to Tell If an Engineer Is Slacking (Honest Answer)
Engineering data cannot detect slacking - commits measure visibility, not effort. What it can honestly show: blocked, overloaded, isolated, or ramping.
Nobody Documented This Codebase. Your New Hire Noticed.
Your new engineer is weeks in and still lost, because the map of the system lives in three heads. How to onboard people into an undocumented codebase.
Developer Burnout Warning Signs in Your Git Data
Burnout leaves traces before the resignation letter: rhythm shifts, after-hours creep, shrinking collaboration. How to read the signs without surveillance.
No One Hoards Knowledge on Purpose. Systems Do.
Before you confront your team's knowledge hoarder, look at the routing. Why expertise concentrates on its own, and how to spread it without a trial.
Engineering Intelligence Tools: The Honest Buyer's Guide
What engineering-intelligence tools actually do, what the category gets wrong, how pricing models work, and how to evaluate one before you spend a euro.
Engineering Team Health: Signals Before the Resignation
Team health rarely fails loudly. It erodes quietly - in flow, load, and knowledge risk - long before the resignation email. How to read the signals humanely.
Bus Factor: What It Is and What It Costs You
Bus factor is how many people your team can lose before a codebase goes dark. What the term means, why the risk stays invisible, and what it costs at one.