Inside the
Trenches of CI/CD

The Comfortable Room

Software engineering was a walled garden. AI just copied the key. The data is messy: 19% slower in trials, 30% more warnings, 322% more vulnerabilities. But the baseline wasn't pristine either. What's left isn't coding: it's judgment, taste, and knowing which room to build.

How We Turned Claude Into a Cross-System Support Investigator

Support triage at Mergify meant juggling Datadog, Sentry, PostgreSQL, Linear, and source code. We built a repo with MCP servers and Claude Code that investigates tickets in parallel — cutting triage from 15 minutes to under 5, with 75% first-pass accuracy.

Spinners Are the UX Equivalent of “TODO: Fix Later”

We replaced a spinner with a chart-shaped skeleton and realized loading states are part of the layout contract. Bad skeletons cause layout shift. Good ones match the final UI exactly. Here's what we learned fixing ours — and why CLS is a UX problem, not just an SEO metric.

Claude Didn’t Kill Craftsmanship

AI doesn't remove craftsmanship: it moves it. The goal was never to protect the purity of the saw. It's to build good furniture. Engineers can now focus on intent, judgment, and product quality instead of translating tickets into code.

On LATERAL Joins

Our new API endpoint worked in dev but timed out in production. A naive SQL subquery was scanning 660K rows to return 50. Switching to LATERAL JOIN cut response time by 1000x. Here's how join order can make or break your PostgreSQL queries.

Detecting Blocking Tasks in Asyncio by Measuring Event Loop Latency

Asyncio only works if every coroutine cooperates. One blocking call can freeze your entire app. This post shows a simple watchdog coroutine that measures event loop latency, detects blocking tasks early, and turns invisible stalls into actionable metrics.

GitHub Merge Queue Was Step One. Real CI Orchestration Comes Next.

GitHub’s merge queue solved safety, not scale. As CI grows slower, costlier, and shared across teams, merging becomes a scheduling problem. Learn why large monorepos and Bazel users outgrow native queues and what real CI orchestration looks like.

Stop Lying to Your Dependency Resolver: The Real Rules for Python Dependency Management

Your Python app didn’t change: your dependencies did. This post explains why apps must pin dependencies, libraries must declare ranges, dev tools must be locked, and how to use lockfiles correctly with Poetry, PDM, and uv to avoid CI and production surprises.

Lessons From a Noisy Monitor

Your database monitors keep firing even though nothing is wrong? We hit the same problem: noisy IOPS alerts caused by predictable jobs. This post explains how we replaced brittle thresholds with an SLO-based approach that restored signal, eliminated noise, and stopped the monitor from "crying wolf."

await Is Not a Context Switch: Understanding Python's Coroutines vs Tasks

Python’s async model is misunderstood, especially by engineers coming from JS or C#. In Python, awaiting a coroutine doesn’t yield to the event loop. Only tasks create concurrency. This post explains why that distinction matters and how it affects locking, design, and correctness.

Updating Materialized Views (Without Worrying Too Much)

Materialized views are powerful but painful to change. Here’s how we safely version, refresh, and migrate them without locking production or timing out deployments, plus the approach we use to avoid dangerous DROP/CREATE migrations.

Goodbye Checklists, Hello AI Linters

We turned our pull request rules into small AI-powered linters using GitHub’s new actions/ai-inference. Each linter enforces one rule: catching risky changes before humans do, without regexes, static analysis, or friction.

Origin and Evolution of the Globstar

Discover how the double-asterisk recursive glob pattern evolved: from Zsh’s early 1990s innovation to Bash’s globstar and beyond, spreading into Python, Ruby, Git, and modern build tools.

Shadow Shipping: How We Double-Executed Code to Ship Safely

How do you ship risky code without crossing your fingers? In this post, we explain how he ran old and new logic in parallel (“shadow shipping”) to validate behavior in production before rollout. Learn how this simple pattern turned feature-flag anxiety into data-driven confidence.

Why PostgreSQL Ignored Our Index (and What the Planner Was Thinking)

PostgreSQL doesn’t "ignore" your indexes, it just does the math differently. We dive into how the planner weighs cost, why it sometimes chooses sequential scans, and how we tuned our queries to make peace with it.

The Magic (and Mayhem) Behind Our Config Deprecation Transformers

We built a "self-healing" system that fixes deprecated configs by opening PRs automatically. It worked like magic, until it didn't. Here's what we learned about the thin line between elegant automation and uncontrollable complexity.

TypeScript's import type: The Flag That Makes Builds Honest

TypeScript doesn’t run your code, but your bundler might think it does. Learn why marking your type imports with import type (and enabling `verbatimModuleSyntax`) makes your builds faster, cleaner, and more predictable.

Should We Still Write Docs If AI Can Read the Code?

AI can explain what code does — but not why it does it. This post explores how documentation is evolving in the age of AI, and why writing down human intent is becoming one of the most practical forms of AI alignment.

Why WARNING Has No Place in Modern Logging

Most systems drown in meaningless WARNING logs. They waste money, obscure real errors, and help no one. Here’s why your next logging cleanup should start by deleting WARNING — and how structured logs make your production systems clearer, cheaper, and safer.

AI Won't Replace Code Reviews, But It Can Fix Them

Code reviews often fail not because the code is wrong, but because no one knows why it was written that way. This post explores how AI-generated comments can add missing intent to pull requests—making both human and AI reviews smarter, faster, and more effective.

Friends Don't Let Friends Use :latest

Floating versions like :latest, ^, and ~ promise convenience but deliver broken builds, hidden regressions, and supply chain risks. Here we explain why they undermine reproducibility and security and shows how to pin GitHub Actions, Docker images, and dependencies safely.

Application vs. Database: Where Should Permissions Live?

Permissions drift is real: scattered checks, forgotten filters, and data leaks. PostgreSQL’s Row Level Security (RLS) flips the script: pushing verification into the database for stronger safety, but with trade-offs in debugging and performance.

The Origin Story of Merge Queues

From Bors and Homu to Bulldozer, Kodiak, Mergify, and now GitHub and GitLab, merge queues have shaped how we keep main branches green. This article traces their history, why they emerged, and how they became a standard in modern software development.

What I Learned Building My First Jenkins Plugin

Building a Jenkins plugin sounded simple — until it became a crash course in Java, Jenkins internals, and community code review. Here’s what I learned, why the process surprised me, and how it now powers Mergify CI Insights.

Pull Request Management: Streamline Your Workflow with Automation

Pull requests are essential, but they don’t scale without automation. Learn PR basics, best practices, and how to automate reviews, tests, and merges with GitHub Actions or Mergify.

Trunk-Based Development vs Gitflow: Which Branching Model Actually Works?

Trunk-based vs Gitflow: which branching model really works for modern CI/CD? We compare both, share trade-offs, and argue why trunk-based (with automation like merge queues) usually wins for teams that care about speed, reliability, and flow.

Feature Branch Workflow: A Practical Guide for Git

A feature branch workflow is one of Git’s most popular strategies. Learn how it works, its pros and cons, and how modern automation (like merge queues) keeps feature branches fast, safe, and frustration-free.

Looking for a Bulldozer Alternative? Meet Mergify.

Bulldozer is fine for simple PR automation, but it struggles as teams grow. In this post, we break down its pain points and show how Mergify’s merge queues, flexible rules, and templates make it the smarter choice for modern development workflows.

Stop Abusing .gitignore

.gitignore is one of Git’s most abused features. Here’s what it’s actually for, why you shouldn’t commit your editor junk into it, and how to use a global ignore file instead.

Code Review: Culture, Flow, and Practices That Drive Team Performance

A practical guide to modern code review—from reducing friction to building team culture. Tips for writers, reviewers, and leads to turn code review into a source of clarity, speed, and collaboration instead of delay and frustration.

Mergify CI Insights Now Supports Jenkins

Mergify CI Insights now supports Jenkins. With one plugin install, you get dashboards for flaky jobs, slow builds, reruns, and job costs in hours. Turn your Jenkins pipeline from a black box into clear visibility — and ship with confidence.

CI Sucks (and That’s OK)

CI is supposed to help developers move faster — but too often, it does the opposite. In this post, Julien Danjou, Mergify CEO, reflects on why CI feels broken, how teams lose trust in it, and what we can do to bring clarity, observability, and confidence back into the software delivery process.

GitHub's Merge Queue Isn't Enough for Large Teams

Why large engineering orgs quickly hit the limits of GitHub's queue — and what they actually need.

CI Failures Don’t Just Break Builds: They Break Focus

CI always breaks at the worst time — slowing fixes, killing flow, and leaving teams rerunning jobs by ritual. We built CI Insights to show which jobs flake, where time is lost, and why your pipeline hurts. Real visibility, zero YAML edits.

Handling Candidate Rejection: A Delicate Balancing Act

At Mergify, we reject with respect. This post shares how we handle one of hiring’s hardest parts: saying no. Why we keep it short, when we go deeper, and how we try to balance honesty, kindness, and efficiency — for your sake and ours.

The Mechanics of Mergify’s Project-Driven Workflow

How Mergify evolved from lightweight Agile to a project-driven workflow that balances ownership, clarity, and autonomy. Briefs, leads, and deadlines keep us motivated, aligned, and shipping without bureaucracy.

Aligning Project Management with Team Culture at Mergify

At Mergify, we learned the hard way that process should serve the team—not the other way around. Here’s how we moved beyond rigid Agile rituals to a lightweight, culture-driven workflow that respects autonomy, fosters ownership, and keeps our remote team shipping.