$ find ./posts -type f

Five predictions for where code intelligence is heading by 2028, based on 6 years of building tools in this space. Includes what's real, what's overhyped, and a maturity model for planning.

Most code quality dashboards fail because they track too many metrics and live outside the team's workflow. Here are exactly 7 metrics and a 3-week adoption plan that actually works.

Most codebases have hundreds of unmonitored transitive dependencies. Here's how to build an SCA pipeline that catches vulnerabilities and license issues before they become incidents.

Architecture fitness functions are automated tests for your system's structural properties. Here's how to implement the 5 most impactful ones and integrate them into your CI pipeline.

A 3-tier succession planning framework for engineering orgs, with a 90-day sprint for accelerating candidates from potential to ready. Based on succession plans built at 4 companies.

The CTO's real job in product development isn't attending every meeting or making every technical call. It's connecting feasibility, viability, and capacity while letting EMs handle the day-to-day.

Your PR data reveals team bottlenecks invisible in standups. Here's how to measure TTFR, review distribution, and cycle time with the REVIEW framework.

Four years of data from a fully remote engineering team across 4 time zones. Specific metrics on productivity, retention, and onboarding with the frameworks that actually worked.

Every codebase has 10-20% dead code. Here's the CLEAN method for finding it, safely removing it, and preventing it from coming back.

Behavioral code analysis examines how teams interact with code, not just what the code looks like. It reveals risks no linter can catch.

Cyclomatic complexity measures testability. Cognitive complexity measures readability. Change complexity measures risk. You need all three.

Small frictions cost more than big blockers. 47 micro-frictions consume 96 minutes per engineer per day. Here's the TAX Return framework for finding and eliminating the developer productivity tax.

A structured 30-60-90 day framework for handling engineering underperformance. Based on 14 real cases with a 64% success rate, starting with diagnosis before intervention.

Periodic code quality audits are worthless without continuous monitoring. Here's the PULSE framework for metrics that actually drive improvement.

Engineers spend 38% of their time on repetitive, automatable work. Here's a toil audit process that identifies where time disappears and a framework for systematic elimination with measurable ROI.

Coupling and cohesion are the best predictors of maintainability, yet most teams never measure them. Here's how to quantify both with the GRIP score.

Your git history is the most underutilized dataset in engineering. Here's how to mine it for hotspots, coupling, and knowledge distribution.

Developer experience is a systems design problem, not a culture problem. Platform engineering reduces cognitive load from 12 concepts to 3 for common tasks. Here's the LOAD assessment framework.

Seven leadership antipatterns that look reasonable on the surface but quietly destroy engineering teams. Each one includes specific signals, real failure stories, and the framework I use to correct it.

Code churn reveals more about team health than any code quality score. Learn to distinguish healthy churn from warning signs using the CHURN framework.

The 10x developer myth is actively harmful to engineering teams. After tracking individual metrics vs team output, I found that the highest performers often had negative correlations with team throughput.

Linting is just the first rung of static analysis. Semantic analysis, architectural enforcement, and AI-augmented tools are where the real value lives.

Most build vs buy decisions rely on gut instinct and flawed spreadsheets. Here's a scored framework (CORE) I've used across 130+ decisions to consistently make the right call.

30-45% of engineering time produces zero customer value. Here's a 4-week audit process that identifies exactly where time goes and the AUDIT cadence for continuous productivity improvement.

Code intelligence combines structural, temporal, and behavioral analysis to predict codebase risks. Here's the discipline every team needs.

Sprint velocity measures estimation consistency, not productivity. After tracking 8 teams, I found velocity often increases while actual output declines. Here's the SHIP framework that replaces it.

Most architecture reviews are theater. Here's a 4-step process with 4 mandatory questions that catches real problems before they reach production.

No single person can hold a large codebase in their head. A knowledge graph externalizes understanding into a queryable structure. Here's the 4-week GRAPH playbook to build one.

Senior engineers leave managers who treat them like advanced ICs. Here are 7 mistakes new VPs make and the TRUST model to retain top talent.

Most technical strategy documents die in Confluence. Here's a 2-3 page format with 5 decisions max that engineers actually reference and follow.

Code search is more important than code quality. A team that can't find code can't fix it. Here's the search infrastructure stack by team size and the FIND audit for measuring search effectiveness.

Most engineering reorgs are leadership failure disguised as structural change. Here's why they fail and the ORBIT checklist to do them right.

Codebases don't become unmaintainable because of bad code. They decay through 5 specific mechanisms: dependency creep, abstraction erosion, knowledge concentration, test brittleness, and configuration explosion.

Every metric will be gamed. Here's a three-layer evaluation system that measures delivery, decisions, and team health without creating perverse incentives.

80% of documentation teams write should never have been created. Here's the WRITE system for building documentation that survives: proximity to code, append-only ADRs, and CI-enforced accuracy.

A 90-day playbook for new engineering managers. Listen for 30 days, fix for 30 days, build for 30 days. With specific scripts and frameworks.

Context switching costs 31% of coding time, and the biggest source isn't meetings. It's inconsistent codebases. Here's the COST audit framework and 4 structural fixes that cut switching costs by 52%.

Most technical investment pitches fail because engineers speak tech and execs speak business. Here's the RICE-T framework that wins budget.

The monorepo vs polyrepo debate misses the most important factor: how quickly engineers understand the code they need to change. Here's a framework that measures understanding impact directly.

Engineering culture dies during hypergrowth unless you treat it as infrastructure. Here's the 4-Document Culture Kit that actually scales.

A repeatable quarterly process for measuring codebase health using the VITAL Signs Framework. Covers velocity, incidents, test effectiveness, architecture, and legacy burden with real metrics and thresholds.

A practical playbook for adopting AI coding tools without tanking code quality. Includes the PACE framework and specific quality gates.

Your codebase has dependencies you don't know about. Here's how to map them all and find the ones that will break your next deploy.

How AI fundamentally changed engineering leadership, team structure, hiring, and metrics. A practical guide from 14 years of experience.

Developers spend 58% of their time reading code but zero hours learning how. Here's the systematic approach I wish I'd learned in school.

My first big rewrite cost $400K and failed. The next three modernizations succeeded using a 6-phase strangler fig roadmap. Here's the complete playbook with real budget numbers.

Developers spend 70% of time in the inner loop but orgs invest 85% of tooling budget in the outer loop. Here's how to fix the imbalance.

I watched a 45-person team lose 62% of their velocity in 18 months. The death spiral has 4 stages and a specific breakout protocol: Stabilize-Demonstrate-Invest.

I tracked my flow states for 3 months: 1.8 productive hours per day out of 8+. Here's the playbook that doubled my deep work time to 4.2 hours.

Strong code ownership reduces bugs by 30% but can create knowledge silos. Here's the ownership model that gets both right.

Every metric changes behavior. Story points, code coverage, and PR counts cause damage. Here's a metric health check to prevent unintended consequences.

Netflix uses chaos engineering to find debt. Google uses large-scale changes to fix it. Stripe budgets for it explicitly. Here's what you can steal from each approach.

One senior engineer had 17 weekly meetings and 12 productive hours per week. Here's a meeting audit framework that recovers engineering capacity.

I replaced 183 Jira debt tickets with a 14-item Technical Debt Register and resolved 6 items in one quarter. Here's exactly what to track and what to skip.

Your bus factor is 1. You just don't know it yet. Here's how to extract and preserve critical knowledge before it walks out the door.

Our 14-minute build was costing us 28% of PR throughput. Here's the exact sequence of optimizations that cut it to 90 seconds.

I lost 3 senior engineers in 5 months to codebase frustration. That's $225K in replacement costs. Here's the KEEP framework for breaking the debt-turnover spiral.

Developer experience is a competitive advantage, not a perk. A DX friction log and ROI framework for getting executive buy-in on improvements.

The SPACE framework measures developer productivity across five dimensions. Here's how to implement it without creating a bureaucratic nightmare.

Stop drawing architecture diagrams that are outdated before the ink dries. Here's how to generate visualizations from your actual code.

Five of my 11 debt sprints failed. The difference was structure. The 4B Framework (Baseline, Bet, Build, Benchmark) turns debt sprints into measurable wins.

Lines of code as a productivity metric actively incentivizes bad behavior: less refactoring, no code reuse, padded code. Here's what to use.

DORA metrics are the best starting point for engineering performance. But they miss developer experience, quality depth, and value delivery.

Microservices don't reduce technical debt, they redistribute it from code complexity to operational complexity. Here are the 5 categories of distributed debt and a scoring framework.

Code review designed for human-written code catches only 47% of AI code issues. Here's the 3-layer review stack built for an AI-first world with measurable results.

A CTO's framework for what actually moves the needle on developer productivity: system throughput, developer experience, and business impact.

A blanket ban on AI coding tools is as reckless as uncontrolled adoption. The RAPID decision framework helps engineering leaders choose the right control tier.

Most codebase complexity isn't inherent to the problem. It's self-inflicted. Here are the 7 patterns that make code unnecessarily hard to read.

Most AI code quality advice fails in regulated industries. After consulting for fintech, healthtech, and automotive, here's the framework that passed 11 regulatory audits.

ADRs are the only documentation I've seen engineers voluntarily read. Here's the exact format and process that works.

AI-heavy codebases have 3x the code duplication of non-AI codebases. After auditing 9 codebases, here's a 3-layer framework to prevent AI-introduced duplication.

An 8-factor scoring framework for the refactor-vs-rewrite decision, with a contrarian take on why most rewrites fail and when to do one anyway.

After reviewing 500+ AI-generated snippets, I built the CRAFT prompt framework. Prompts with constraints produce acceptable code 82% of the time vs 45% without.

After 847 tracked AI pair programming sessions across 6 tools, here's what actually works and what wastes time. Data-driven results with a 3-question filter framework.

Cyclomatic complexity is overrated. Here's what 15 years of research says about which metrics actually predict defects.

Eight tools deployed, most failed. The five patterns that kill debt tracking initiatives, and the simple system that actually works: a spreadsheet and a meeting.

AI coding assistants are systematically biased toward insecure code. After auditing 14 codebases, here are the 6 vulnerability patterns AI generates most and how to stop them.

A step-by-step calculator for quantifying technical debt in dollars across four cost categories, with data-gathering templates and presentation tips.

Not all AI code needs the same review depth. Here's a data-backed decision matrix for when to trust AI output, when to modify it, and when to rewrite from scratch.

After working with 22 engineering teams, I built a 5-level maturity model for AI code quality. Most teams overestimate their level. Here's how to assess and advance.

How to use git log and complexity analysis to find the 14 files (out of 2,400) causing 73% of your bugs, and a triage checklist for fixing them.

Most companies lose $50K+ per hire during the onboarding gap. Here's why it takes 6 months and how to cut it to 6 weeks.

AI coding assistants double your output and 6x your debt rate. Here's a five-rule framework for capturing speed without drowning in debt.

Standard CI/CD checks miss AI-specific code issues. Here's how to build a 4-stage quality gate that caught 73% more issues before production for 8 engineering teams.

Our PR approval rate dropped from 78% to 52% after adopting Copilot. After redesigning our review process with 5 key changes, we recovered to 74%.

A practical four-quadrant prioritization framework for technical debt that tells you exactly what to fix now, what to plan, and what to ignore.

AI coding assistants are making individual engineers worse while making teams more productive. Here's the data from 83 engineers and a framework to prevent deskilling.

A battle-tested system for understanding unfamiliar codebases in days, not months. Includes the Codebase Comprehension Matrix.

Technical debt isn't a failure state. It's a financial instrument. Here's a framework for making deliberate debt decisions with documented contracts.

A battle-tested checklist for reviewing AI-generated PRs, organized by priority. Every item caught a real bug in a real codebase. Print it, pin it, use it.

A battle-tested playbook for pitching technical debt remediation to leadership, with frameworks for calculating ROI and handling objections.

Seven technical debt metrics with specific action triggers that actually change engineering behavior, not just decorate dashboards.

AI tests hit 91% coverage but only 34% mutation score. Here's proof that AI-generated tests create dangerous false confidence, and the workflow to fix it.

A practical framework for quantifying technical debt in business terms, prioritizing paydown, and selling remediation to leadership.

Practical TypeScript patterns for everyday development: discriminated unions, branded types, the builder pattern, and more.

Most teams track the wrong AI code metrics. Here are the 8 metrics that actually predict whether AI code generation helps or hurts your codebase long-term.

Set up a Docker development environment that doesn't slow you down. Hot reloading, debugging, and database management included.

Tailwind CSS v4 brings a new engine, CSS-first configuration, and significant performance improvements. Here's what you need to know.

Vibe coding works 80% of the time. That other 20% is where your codebase dies. Here's how to detect it, assess the damage, and break the habit.

Stop being afraid of git rebase. Learn interactive rebase, when to rebase vs merge, and how to recover from mistakes.

Everyone tracks AI productivity metrics. Nobody tracks what happens when that code needs changes. Here's data from tagging 1,247 PRs over 8 months.

A deep dive into React Server Components, how they work under the hood, and when to use them vs Client Components.

AI code looks clean but hides real issues. Here's the REVIEW method: a 6-step process specifically designed for reviewing AI-generated PRs efficiently.

Learn how to leverage tRPC for end-to-end type safety in your Next.js applications without code generation.

AI coding tools are creating invisible technical debt. After auditing 6 codebases, here are the patterns I found and the framework to assess your own AI debt.

A complete framework for maintaining code quality when 40-70% of your codebase is AI-generated. Covers pre-generation, static analysis, review, and monitoring.