The View from the AI Frontier

The View from the AI Frontier

Two engineers at a shared desk facing a wall of monitoring dashboards showing alerts and metrics. Laptops and terminals open between them. Late evening, warm desk lamp, empty office behind.

SREs Don't Need Replacing, They Need Pairing

Most SRE work follows a pattern. An alert fires, you check the metrics, pull the logs, form a theory, fix it. Then you do the same thing next week. That sequence is a workflow. When agents can execute it and produce structured data at every step, the work changes shape.

Hands assembling modular electronic components on a wooden workbench covered in circuit boards, connectors, and wiring. Warm task lighting over a purposeful workshop arrangement.

Every Platform Promises "Any System." Here's Why They Don't Deliver.

Every IaC tool promised "any system." Few delivered once you tried to use it in your own business. Provider ecosystems were designed for humans who can fill in the gaps. Agent ecosystems need a different contract. That's what extensions are built for.

An engineer writing on a large whiteboard covered in deployment flows and architecture diagrams. A monitor beside them shows structured code. Warm industrial office lighting.

Building with AI

The First Step on Your AI Journey Is Encoding What You Already Know

Every company has this person. The engineer who every production change flows through because they're the only one who knows the constraints. If you're thinking about putting AI agents anywhere near your infrastructure, encoding what that person knows is the first problem to solve.

An engineer at a desk with two monitors, turning from a screen of dense code toward a clean structured document. A European city skyline glows at dusk through the window behind them.

Building with AI

Intent Is The New Architecture

The sovereign cloud movement is forcing a question the industry has been avoiding. When you have to move off a hyperscaler, the bottleneck isn't the new provider's APIs. It's how precisely you can express what you actually need. Intent is becoming the architecture that matters most.

An engineer seen from behind, sitting at a desk with five monitors showing structured data. Beyond the glass, a vast sprawl of servers and infrastructure glows in the darkness.

Deterministic Automation for a Probabilistic System

AI agents are probabilistic. The same prompt doesn't always produce the same output. That's not a problem to avoid. It's a problem to engineer around. Typed schemas, validated execution, deterministic workflows. The agent reasons freely. The system keeps it honest.

Aerial view of five people around a wooden table, each working on a laptop. A glowing holographic system architecture floats between them, connecting their independent work into one design.

Building with AI

High Trust Teams With Agents Are Unstoppable

High trust doesn't mean no guardrails. It means everyone understands the direction well enough to act independently within it. When you pair that with the right systems, every person on the team can advance the product every day.

Aerial view of a large architectural blueprint under multiple desk lamps, each illuminating a different section of the same design. Drafting tools and rolled plans scattered around the edges.

Building with AI

The Rearchitecture Your Team Could Never Justify

Every codebase has the rearchitecture that never gets prioritised. We split ours into six parallel workstreams and shipped it in eight days, start to finish. The hard part wasn't speed. It was coordination.

An elegant classical column buried under haphazard additions of scaffolding, wooden crates, and makeshift structures. The original form barely visible beneath the accumulated weight.

Building with AI

When Building Is Easy, the Danger Is Building Everything

When agents can build anything in an afternoon, the temptation is to build everything. The products that survive are the ones where someone had the discipline to say no.

Silhouetted figure standing at the edge of a crumbling stone cliff, facing a vast expanse of warm golden light. Fragments of ground fall away behind them into mist.

Building with AI

Take the Leap Before You Are Pushed

The fear of AI replacing your work is real. So is the shift. The teams that build structure around agents instead of resisting or rushing find the job gets better, not smaller.

Tangled multicolored light streams converging through a dark field into structured parallel lines

Building with AI

The Code Was Never the Job

Five of us build swamp. None of us write code. Agents write it, review it, test the binary. The work didn't shrink — it shifted to the decisions that were always the most valuable.

Glowing orange tokens streaming into a dark industrial furnace, burning bright on impact, scattered embers falling below

Building with AI

Your Agent Is Starving

Five people, $3,000/month, zero lines written manually. GitHub just moved to per-token billing. The era of flat-rate pricing absorbing your agent's inefficiency is ending. Your agent isn't the bottleneck. What you're feeding it is.

Wall of AI-generated pull request notifications fading into darkness, with "The Community Pull Request Is Dead" breaking through in white and red

Building with AI

The Community Pull Request Is Dead

The PR-as-contribution model was built for a world where writing code was the bottleneck. AI agents broke that assumption. GitHub shipped a kill switch on PRs. Hashimoto built Vouch. We closed the door entirely. The community pull request is dead. Here's what replaces it.

Three nested layers (what it can do, how it writes code, how it thinks) surround an agent dot. An arrow leads to a red gate labelled "gh pr create permission prompt," then out to "public."

Building with AI

Agent Trust Is a System Design Problem

Most people hit "always allow" within the first hour. Agent trust is a system design problem, not a containment problem. Three layers of permissions, conventions, and context let the agent work autonomously where it's safe and stop it at the boundaries that matter.

PR flows through a UAT gate with three layers — CLI tests, adversarial, and benchmarks. All pass promotes to Homebrew, Docker Hub, and CDN. Any fail blocks the binary.

Building with AI

The Gate Between Our Agent Code and Our Users

Every release binary gets dispatched to a separate repo running CLI tests, adversarial security tests, and benchmarks. Three recent bugs — all with full unit test suites passing — never reached a user because the UAT caught them in minutes.

Four AI reviewers — adversarial, code review, UX, and CI security — each examining a PR from a different perspective, converging on a single auto-merge gate.

Building with AI

Anatomy of a Swamp PR

Agents open PRs in our repo. Other agents review them. That means untrusted input flowing through models with merge authority — so we built a pipeline with four independent AI reviews, scoped tools, and a security review that watches the reviewers.

$Fork in the road — left path fractures into tangled red lines (drift), right path leads to an ordered green city grid (coherence). Yellow dot at the fork: "every PR is a choice."$

Building with AI

The Vibes Don't Scale

Vibe coding works great for the first few PRs. Then you do it two hundred more times and the codebase quietly stops making sense. The fix isn't better prompts — it's building a machine that compounds.

Skill testing pipeline: eight swamp skills pass through tessl and promptfoo CI gates, then weekly regression across sonnet, opus, gpt-5.4, and gemini-2.5-pro.

Skills Are Context, and Context Needs Tests

Skills are context. They're the thing an agent reads before it decides how to use swamp. If the skills are wrong, everything downstream is wrong — so we test them in CI the same way we test code, using tessl for quality and promptfoo for routing, across every model we care about.

The swamp-club lifecycle view for a single issue, showing each phase and the agent event stages inside it.

The Lifecycle of a Swamp Issue

We use swamp to build swamp. That sounds like marketing until you look at how an issue actually moves through our process — not as a GitHub thread with comments piling up, but as a state machine with versioned plans, adversarial reviews, and checks that refuse to let the agent skip steps.

A split terminal showing a swamp model method dispatching to a Docker container, with driver config on the left and live execution logs on the right.

Execution Drivers in Swamp

Swamp model methods can run anywhere — directly in the host process, in a Docker container, or in a custom driver you write yourself. This post covers how execution drivers work, how config cascades from model to workflow to CLI, and how to build your own.

Left pane shows the workflow running, right pane shows S3 sync in real time — that's the datastore abstraction doing its job.

How We Built Datastores in Swamp

Swamp tracks everything at runtime — model state, workflow runs, audit logs. For a while that lived in .swamp/ in the repo. It fell apart the moment we wanted a team sharing state. So we built a proper datastore abstraction with S3, distributed locking, and a local cache.

iTerm2-style terminal window showing a swamp workflow run command deploying Ghost to DigitalOcean, with green-highlighted input flags.

Deploying Ghost on DigitalOcean with Swamp

I asked Claude to build me a blog on DigitalOcean and it worked hand in hand with Swamp to build one!

Person sitting at a desk viewed from behind, facing multiple monitors displaying code editors, terminal windows, and data dashboards in a dark room with warm ambient lighting

AI: Why I'm All In

I'm an AI maximalist, and I think operations is about to get left behind: again. This blog is about closing that gap from the inside.