Silhouetted hands directing glowing streams of code that assemble into software architecture

AI-Assisted Engineering

Field notes, essays, and methodology from building software with AI daily. The practical application of making complexity visible in software systems.

Most of the software I build now, an AI agent does the typing and I do the specifying and the review. If you build software right now, you are probably somewhere inside the same shift, whether or not you chose it.

I started writing about it in mid-2025, after six weeks working almost entirely in agent mode. The speed was real, but it was the smaller change. The bigger one was in how I thought: how I scoped work, and how I decided what to do myself and what to hand off. That reached all the way into the shape of the development process.

The essays here are field notes from that experiment, which is still running. They cover the workflows that held up, the failure modes I did not see coming, what working at machine speed did to my thinking, and what happened when I used the same patterns on infrastructure, a content pipeline and business software with production requirements.

AI-assisted development asks for more engineering judgment, not less. The models can write code. They cannot decide what to build, catch the architectural mistake that turns into a rewrite six months later, or know when good enough is good enough. That judgment is still mine, and the point of the tools is to leave me more time and attention for it.

Start with the current work just below. The 2025 series that started it is collected in one overview further down, if you want the whole arc. Every piece stands on its own.

Agent Mode & Agentic Workflows (2026)

The current work, tightly themed: what agent mode and autonomous mode actually are, the workflow that holds up, and how the same patterns reshape DevOps and architecture.

Essay

Level Up the Game

Kent Beck asks the genie to carry his toil and leave his struggle. My reply: move the target past what you can reach alone, the struggle is waiting there, and keep what it teaches.

Essay

The Right to Explore

Not understanding yet is where learning starts. FORTRAN's skeptics, type-in magazines, a manifest the cluster rejects, the genetic fallacy behind "AI slop," where the lab ends, and what the studies actually say.

Essay

The Hacker Ethic Meets Cybernetics

A teenager's robot bug at the MIT AI lab, the grad students who wanted him out, ITS, and the people in Levy's Hackers. My version of the hacker ethic: hands on, brutally humble, and AI as a full partner.

Build Log

Every Check Passed

Most of my essays had gone missing from the page that lists them, on production, and every check passed. Nine checks on this site that could not fail, the shape they share, and the questions I ask of a check before I trust it.

Build Log

The Gates Are the Product

A month of letting an AI run a music and film studio: render, master, verify, repeat. Everything that went wrong went wrong the same way, a number that was measuring the thing next door. The gates that held, and the one line that has to stay mechanical.

Build Log

What 7helm Is Made Of

Change the drag constant in my arcade game by one part in a hundred million and twelve recorded runs stop matching. The deterministic simulation, replayed scoreboard, co-op server and release path an agent-built game stands on.

Build Log

Two Readers and a Red Box

A vision model filed one of my notebook pages under a date eight years off, calmly. Now two models read every page, I look only where they disagree, and one number says how far to trust that.

Essay

A Loop Is a Path That Closes

One of my health checks stayed red for eleven weeks by reading its own failure. A loop is the special case of a trajectory, the path that happens to close. Cybernetics was named for a steersman and I had been illustrating it with a thermostat; in distributed systems the controller is the loop and the log is the trajectory. Day one of a system built on the path, and what it amends in Complexence.

Essay

Hello, Again

Three weeks after Hello, I pulled the thread and the warm front door turned out to be the outermost loop, the one that asks whether the whole system can still become useful. On cybernetics, nested watchers that each live outside the failure boundary of the thing they watch, and the rule I hold hardest: the model proposes but never gets its own hands.

Essay

The Loop Was the Top of a Stack

I typed my thirty-two loops, drew them as a graph, and thought the loop was the top of the system. It is the roof of a stack eight floors deep, and the floor holding all the weight is the smallest one: the edge. The doctrine under the legibility series, from a single relationship up to the rule the whole thing exists to protect: world, belief, and action never collapse into each other.

Essay

A Loop Is Seven Things

Thirty-two automated jobs, every one written by me, and I could not hold the system in my head. The problem was never memory. It was a word: "loop" was one word doing the work of seven, and a word that vague cannot carry rules. Typing the loops, and why naming the latent grammar of a system you built is cartography aimed inward.

Essay

You Reinvented Data Engineering

The best thing anyone told me about my own system this year was that I had not invented it. The scripts I grew by hand are a data pipeline, the shape is a DAG, and the discipline is solved. What Airflow, Dagster, and dbt actually sell, and the difference between wanting an engine and wanting a map.

Essay

The View You're Missing Is the Graph

I gave every job a receipt, a health check, and a green light, and the system still would not fit in my head. A dashboard shows the state of the parts; every question that mattered was about the shape of the whole. Same data, different projection: the dependency graph that turned thirty-two jobs into a short critical chain.

Build Log

One Writer Per Artifact

Most pipeline rules ride along free with a loop's type. The one that does not, every file gets exactly one job that writes it, is the one my system was breaking, and the reason its middle felt like soup. On contracts, deliberate violations versus drift, and systems that govern the code you have not written yet.

Field Note

Engineering Orientation

Making complexity visible is the method; orientation is the objective function. The first field report on the research program: an installable runtime, private laboratories that keep their data, a candidate legibility measure, and the first pre-registered experiment, running on my own life.

Essay

Hello

The smallest possible program, written again now that the machine can write it for you. What the first line of code is for when the typing is no longer the work, and what it means to build the loop you think inside.

Essay

The Science of Complexence

The foundation under the method: how meaning moves through a system, and what shape it takes when it does. Meaning velocity is the rate at which useful meaning becomes visible, transformable, and actionable. Cognitive form is the idea held on its own, apart from any single way of saying it.

Essay

Complexence OS

Day one. The rough operating method I built today, out of need, on no bandwidth: you talk into a file, one Chief of Staff agent sorts what you said and hands the rest to a few specialist roles, and you review only the exceptions. Gated so nothing irreversible happens unattended. The method is public, your data stays private. The evening my work crossed from AI assisted to agent director.

Essay

Germane Friction

The fight over whether AI is good or bad is the wrong fight. AI is a friction-removal engine, and there are two kinds of friction: the kind that is building you, and the kind that is only taxing you. Telling them apart, in the moment, is the whole skill. The synthesis of a two-part argument I ran against myself.

Essay

The Case For AI, Made Properly

Piece I of the dialectic. The strongest version of the argument for the tools, argued in good faith and without the sales pitch, because an argument you have not steelmanned is one you have not actually won.

Essay

The Case Against Letting AI Think For You

Piece II of the dialectic. The strongest version of the argument against, run against myself: what you lose when the friction goes, and why the loss is quiet enough that you will not notice it happening.

Essay

The Real Bill for AI at Work

The invoice for AI is the cheap part: a seat and some tokens. The real bill arrives in four ledgers, financial, attention, coordination, and development. Why AI makes the individual feel fast while the organization barely moves, and where the money actually goes.

Essay

The Jagged Frontier

AI is brilliant in one place and confidently wrong half a step over, and from the inside the two feel identical. The real skill is not prompting. It is knowing when to delegate, when to steer, when to verify, and when to close the tool and think alone.

Essay

Botsitting

The subscription is the small line. The real meter is the time spent feeding context, checking output, catching the confident mistake, and cleaning up work that looked finished. The hidden attention and coordination tax behind the AI productivity paradox.

Essay

Compressed or Destroyed

The same tool that folds a beginner's learning curve shorter can also erase it. AI compresses apprenticeship when it transfers expertise and destroys it when it lets people skip the repetitions that were quietly teaching them. On deskilling and which friction to protect.

Essay

The Patient Part

My head runs in branches, not lines. Then I started building with an agent that does the long flat middle I cannot sit still for, and amplifies the part I already do too much. On working with AI when your attention has its own ideas, and the fence you have to build first.

Essay

AWS Is Smaller Than It Looks

AWS is sold as two hundred services. Underneath it is a handful of primitives, and every service is a frozen answer to a distributed-systems trade-off. The map I built studying for the SAA-C03, the patterns above it, and the two questions that decode any new AWS service.

Build Log

How I Gave CloudFront a CSP Without Blanking My Own Site

A strict Content-Security-Policy on a static site allowlists inline scripts by hash. Change one script, forget to update the hash, and every page renders blank. The incident that taught me, and the deploy guard that ends it.

Build Log

Directing AI Agents Across Thirty-Three Repositories

Multi-repo agent work is not a scale problem, it is a context-routing problem. How I scope an agent to one project at a time across thirty-three independent repositories, and why the instruction files do the real work.

Build Log

I Mapped My Own Blog

I built a graph of every internal link on this site to see its real structure, not the one I imagined. What the map showed about hubs, orphans, and where authority actually flows.

Build Log

Rebuilt My Site in Agent Mode

A field report on rebuilding this blog with an agent driving, from the Astro content cache to the AWS deploy. What the work actually took, the failure modes, and what stayed human.

Essay

Working at the Frontier: What It Actually Feels Like

A field report from inside sustained agent-mode work. Not the tools or the benchmarks: the heat behind the eyes, the way speed bends your sense of time, what it costs the body, and the practice that keeps speed from becoming drift.

HOWTO

The AI-Assisted Engineering HOWTO

A plain-spoken manual in the old Linux HOWTO style: workspace setup, the specify-delegate-verify-record loop, hard-won tips, and how to fix the common failure modes. The entry point if you want to actually do this.

Book

AGENTSPEK Is Live on Amazon

The AI Development Revolution series became a book: a beginner's companion to the AI frontier, written using the very tools it describes. Start reading free here, or read it properly on Kindle and in paperback.

Cornerstone

Recursive DevOps

DevOps was always a feedback loop. The version worth building now runs the system back on itself, so every failure becomes information the system uses to harden.

Cornerstone

DevOps Beyond Automation

What DevOps means in 2026: the tool stack changed almost completely, and the actual work changed almost not at all.

Where it started: the 2025 series

The parts of the AI Development Revolution live together in the overview, in order.

AgentSpek

A Beginner's Companion to the AI Frontier

If you want these ideas in a single readable volume, AgentSpek is the book version. It covers the full arc, from first contact with AI tools to working in full agent mode, with personal stories and practical prompts, written for someone starting out who wants to use these tools, not only read about them.

Start with these

  1. Agentic AI Development: What Changes When You Give an Agent Your Repository

    What changes when an AI agent gets real access to your repository, terminal and tests: the patterns that hold, the failure modes that cost me time, and a four-week way in.

  2. Germane Friction

    The fight over whether AI is good or bad is the wrong fight. AI is a friction-removal engine, and there are two kinds of friction: the kind that is building you, and the kind that is only taxing you. Telling them apart, in the moment, is the whole skill.

  3. DevOps Beyond Automation: What Actually Compounds

    DevOps was never a job title. It is a thesis about building systems that change without breaking: what compounded once the tools became a commodity, what automation never solved, and what agents change.

  4. What Is Agent Mode? A Working Engineer's Definition

    Agent mode is when you stop typing code and direct an AI that reads your codebase, writes the change, runs the tests and reports back. How it differs from autocomplete and chat, the loop, and when to use it.

  5. Working at the Frontier: What It Actually Feels Like

    A field report from inside sustained agent-mode work: the heat behind the eyes, the way speed bends your sense of time, what it costs the body, and the practice that lets you build at the frontier anyway.

  6. The Cognitive Cost of Modern Software Engineering

    AI took the typing, and the cost of software engineering did not go away. It moved from the hands to the head and got heavier. The new scarce resource is your attention, and the new discipline is managing it.

Series

Look around

Everything in AI and engineering (86)

Essays (63)
Thoughts (8)
Projects (1)
Freewriting (14)

Related

The infrastructure underneath

Agent mode still has to ship to something. The AWS and CloudFront side of this practice, the content security policy, the edge functions and the deploy pipeline, is collected at Running a Static Site on AWS.