Introducing Airlock

Software development is going through its biggest structural shift in decades.

AI coding agents - Claude Code, Cursor, Copilot, Codex - have moved well beyond autocomplete. They write features. They refactor systems. They generate tests. For the first time, the majority of new code in a project might not have been typed by a human at all.

This changes the developer's role fundamentally. You're no longer the author of every line - you're the director. You guide agents, evaluate their output, and decide what ships. The craft of building software has always been about judgment. That hasn't changed. What's changed is where judgment needs to be applied.

The Bottleneck Has Moved

AI can generate code orders of magnitude faster than any human can review it. A feature an agent writes in seconds takes you minutes - sometimes hours - to verify. The bottleneck used to be writing code. Now it's validating it.

And our tools haven't caught up.

All the quality infrastructure we rely on today - CI pipelines, pull request reviews, linters - was built for the left side of this picture. One human writes code, another human reviews it. The tools help the reviewer do their job.

But now AI writes the code and you're the reviewer. You're staring at massive diffs, testing changes manually, wondering if the agent hallucinated a dependency or left a security hole. And none of the tools today was purpose-built to help you do this more easily.

There has to be a better way.

The Push Request

Think of an airlock - the chamber in a spacecraft between the inside and the void. Before anything goes out, you verify it's safe. You check the seals. You confirm conditions. Only then do you open the outer door.

That's what Airlock does for your code.

Whenever you push a code change, it first enters Airlock where it gets validated and cleaned up. You can then review everything in a Push Request: summary, code review comments, test results, suggested fixes.

When you're satisfied, approve the push request - the code change gets pushed to remote, and a clean, well-documented pull request appears.

INPUT (raw AI-generated code)           OUTPUT (clean, reviewable PR)
──────────────────────────              ──────────────────────────────
❌ Lint errors                       →  ✅ All lints pass
❌ No tests for new code             →  ✅ Tests generated and passing
❌ No documentation                  →  ✅ Functions documented
❌ No PR description                 →  ✅ Rich summary with walkthrough
❌ Unused imports, dead code         →  ✅ Clean, minimal code
❌ Hardcoded secrets                 →  ✅ Flagged for review

The loop between "The agent says this is done" and "I'm confident this is ready to go" collapses from hours to minutes.

How It Works

Getting started takes two minutes:

brew install --cask airlock
cd your-project
airlock init
git push origin feature-branch

The git remote origin of your repo will be reconfigured to point to a staging area managed by Airlock. After that, you push as normal. Airlock's pipeline takes over.

Airlock pipelines are fully configurable. Define them in .airlock/workflows, pull from a growing library of reusable steps, or write your own.

name: example

on:
  push:
    branches: ['**']

jobs:
  default:
    steps:
      - name: lint
        uses: airlock-hq/airlock/defaults/lint@main
      - name: freeze
        run: airlock exec freeze
      - name: describe
        uses: airlock-hq/airlock/defaults/describe@main
      - name: test
        uses: airlock-hq/airlock/defaults/test@main
        continue-on-error: true
      - name: review
        run: 'true'
        require-approval: true
      - name: push
        uses: airlock-hq/airlock/defaults/push@main
      - name: create-pr
        uses: airlock-hq/airlock/defaults/create-pr@main

Everything runs locally with your agent and environment. No cloud dependency. No separate LLM bills. No account required. Your credentials stay on your machine.

Built for How Software Gets Made Now

The rise of AI agents hasn't just made developers faster - it's exposed a gap in how we validate and ship what gets built. Our entire toolchain was optimized for a world where humans wrote every line and CI was the safety net. That world is already behind us.

Airlock is built for what comes next. It treats validation as a first-class part of the development workflow, not an afterthought that runs in a remote pipeline twenty minutes after you've moved on. It uses AI to review AI-generated code, catching issues before they reach your team. And it gives developers a single, focused moment to exercise the judgment that still matters most - the decision to ship.

Vibe code in. Clean PR out. Get started today.