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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
The mechanical AI tells you can catch with a script, the ones you cannot, and why detecting AI writing finally comes down to a voice you have to supply yourself.
Why I precompile every post on this Astro site into one committed TypeScript file instead of reading markdown at build time, what it buys, and the one cost you pay to keep it in sync.
Traditional OCR cannot read cursive; a vision model can. The pipeline I built to transcribe years of handwritten journals, the human review it still requires, and the loop that makes it better every batch.
A static site has no server to check a password. How I gated staging with a CloudFront Function instead of Lambda@Edge, kept the credential out of git, and the day the wrong file 503'd the whole thing.
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.
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.
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.
Applying the operational discipline of software, observability, feedback loops, incident review, to the way I run a day. What transfers, and what does not.
Agent mode and autonomous mode get used as synonyms; they are not. In agent mode you close the loop after every task. In autonomous mode the system does, on a schedule or a trigger. A working engineer's disambiguation, and when to use each.
Not a tools list. The tools changed three times this year; what changed underneath is where the hours go: specs in the morning, batch review in the afternoon, and the judgment work that never left.
The code got cheap; the review did not. The workflow I actually use on agent-written diffs: three passes, an adversarial second agent that hunts for bugs, gates that earned their place, and triage for what gets a close read.
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.
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.
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.
Agentic development is not chatting with a model about your code. It is giving an agent real access to your repository and directing it, with a working method for the loop.
Agent mode is when you stop typing code and start directing an AI that reads your codebase, writes the change, runs the tests, and reports back.
Autonomous mode is when the agent runs the whole loop without you in it: plan, act, check, repeat, until the task is done or it gets stuck.
Agent mode is not a faster way to type. It moves the unit of thought up from syntax to intent and turns you into a conductor of parallel work.
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.
AI took the typing, and the cost of software engineering did not disappear. It moved from the hands to the head and got heavier.
I used GitHub Copilot for a long time, always with Claude underneath, then moved most of my work to Claude Code. A firsthand comparison for DevOps work.
What DevOps means in 2026: the tool stack changed almost completely, and the actual work changed almost not at all.
Microservices used to be a tax a solo builder could not afford. AI agents change that math. Why I am drawn to the architecture for what I build next.
What separates deliberate AI-assisted development from prompting and hoping, and why the difference matters more as the models get more capable.
The parts of the AI Development Revolution live together in the overview, in order.
The full series in one place, from the first shock of working alongside AI to building autonomous agents, infrastructure, content pipelines, and business apps.
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.
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.
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.
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.
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.
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.
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.
Reader favorite Recursive DevOps
Reader favorite Claude vs Copilot for DevOps: A Practitioner's Comparison
Reader favorite The Multithreaded Mind: Six Weeks Living at Machine Speed
Reader favorite The AI-Assisted Engineering HOWTO
Deep cut Agent Mode Changes the Shape of Thought
Deep cut The Mind Places Things on Paper
Deep cut AWS Is Math, Kubernetes Is Physics: A Symphony of Systems
Deep cut The Science of Complexence
Deep cut Complexence OS
Deep cut The Loop Was the Top of a Stack
Deep cut Making Complexity Visible: You Cannot Simplify the Ocean, Only Chart It
Deep cut AWS Is Smaller Than It Looks
Deep cut AI Development Revolution Part 2: The Methodology
Deep cut Building a Language Engine You Can Actually Own
Deep cut The Real Bill for AI at Work
From the notebooks Build the Rudder
From the notebooks The Steady Work of Freewriting 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.