<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" 
     xmlns:content="http://purl.org/rss/1.0/modules/content/"
     xmlns:dc="http://purl.org/dc/elements/1.1/"
     xmlns:atom="http://www.w3.org/2005/Atom"
     xmlns:media="http://search.yahoo.com/mrss/">
  <channel>
    <title>Joshua Ayson - Essays</title>
    <link>https://joshuaayson.com/explore/essays/</link>
    <description>Essays from Joshua Ayson&apos;s blog</description>
    <language>en-us</language>
    <lastBuildDate>Wed, 10 Jun 2026 21:59:31 GMT</lastBuildDate>
    <atom:link href="https://joshuaayson.com/rss/essays.xml" rel="self" type="application/rss+xml"/>
    <generator>Astro</generator>
    <copyright>Copyright 2026 Joshua Ayson</copyright>
        <item>
      <title>Working at the Frontier: What It Actually Feels Like</title>
      <link>https://joshuaayson.com/2026/06/08/working-at-the-frontier/</link>
      <description>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.</description>
      <content:encoded><![CDATA[View Original Handwritten Notes
[dflip id="working-at-the-frontier" source="/pdfs/working-at-the-frontier-2026-06-08.pdf"][/dflip]


There is a heat that comes with working alongside capable agents, and it is worth talking about, because almost nobody does. Much like a too-tight headband, or a beanie a size too small, it is a familiar kind of pressure, and it surfaces, eventually, as a real headache. When I notice it now I ask the plain questions first. Have I had enough water. When did I last take a break. I look out the window. I name something outside, a tree, a roofline, the color of the sky, and if the heat is still there I put on shoes and walk until it goes. The heat is information. It is a sign, the way a runner's blisters are a sign, that a good limit has been reached.

Because this is closer to training than to typing. You feed yourself a measured dose of hormesis, the useful kind of stress, the kind that builds cognitive holding capacity instead of breaking it, and you learn to work with the heat without standing in the fire so long that you burn out. You work near the forge where new ideas are born the way stars are born out of a nebula. Like all training, the worn synapses take their own time to come back. But the mind itself is resilient, and underused, and capable of far more than we tend to ask of it. What limits it, I think, is language, the narrow channel cognition has to pass through to become anything you can share. Once thoughts can travel faster, the thinking speeds up with them.

Both the speed and the ability to scale cognition change your perception of time. You get thrown into project-level wormholes, folding hours against the gracious estimates the tools hand you, until the only real limit becomes a question of how slow you are, and where the time went. All of it is in service of building something useful, and that is exactly where the huge missed opportunity lives, because most people take the speed and waste the build. So you develop the practice the way you would develop morning pages, by showing up to it. It is fine to vibe code, to try things, to let the agent run, and it should be encouraged. But as the system grows in complexity you add the appropriate layers in the same motion, the planning, the context, the guardrails, the structure, at the rate the complexity actually demands them.

<div class="image-container center">
  <img src="https://joshuaayson.com/images/essays/2026/06/age-of-agents-triangle.webp" srcset="/images/essays/2026/06/age-of-agents-triangle-480.webp 480w, /images/essays/2026/06/age-of-agents-triangle-768.webp 768w, /images/essays/2026/06/age-of-agents-triangle.webp 1024w" sizes="(max-width: 768px) 100vw, 768px" alt="Vintage sci-fi poster of an all-seeing eye inside a triangle labeled Plan, Observe, and Act, titled Age of Agents" class="content-image" loading="lazy" />
</div>

I have started calling this the age of agents, and I draw the same small figure in the margin every time. Plan. Observe. Act. It is not only the speed. The results that come out of scaling cognition under the right direction are astounding, given the calibre of the output. What changes underneath is the shape of the work itself. The way you think about the job moves from implementation to design, to orchestration, to efficiency, to anything and everything in between. It is devops applied to the whole of it.

That shift drives a real need, for technical ability and for familiarity, leaning harder than ever into architecture, into quality, into security, and into cost, all of it broken down continuously and accurately and kept attached to what it actually costs. Here is what I could not have written down eighteen months ago. This lets you leap-frog across domains. Once you have a general grasp of a new territory, its codex and its language, once the vocabulary is understood, there is great power waiting on the other side of it.

With the right context and the right systems you get to a high standard in a field in far less time than it used to take, and you start to find what I call the edges. The places where, with proper tools and the meta-capability of these models to abstract models and patterns, you can take some of the most sophisticated machinery there is and model the domains, the systems, the cognition itself, and bring coherence to complexity. The overwhelming becomes navigable. The illegible becomes legible. You draw the maps that let you work near the furnace, close to the source of the heat and the energy, and still keep enough of yourself in reserve to make sense of it all, or to hold what has to be held, and carry it.

Don't panic.]]></content:encoded>
      <pubDate>Mon, 08 Jun 2026 08:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/08/working-at-the-frontier/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/working-at-the-frontier.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>The AI-Assisted Engineering HOWTO</title>
      <link>https://joshuaayson.com/2026/06/06/ai-assisted-engineering-howto/</link>
      <description>A practical, plain-spoken manual for building software with an AI agent: the setup, the loop, context management, and verified Claude Code and Copilot commands. Written like the old Linux HOWTOs, by someone who runs it daily.</description>
      <content:encoded><![CDATA[*Revision 1.1, June 2026. This is a HOWTO in the old sense: a plain manual you can read top to bottom and then go do the thing. I grew up on the Linux Documentation Project, learning the internet one HOWTO at a time. I wanted to write one for years. This is that document, for the skill I use most now. It has high-level tips and it has commands you can paste. Come back to it.*

## 0. Introduction

AI-assisted engineering is building software by directing an AI agent instead of typing most of the code yourself. Done well, it is the biggest change to how I work in fifteen years. Done badly, it produces confident garbage faster than you can read it.

This manual is the difference between the two. It is the setup, the loop, the commands, and the failure modes, written for an engineer who has used a chat assistant a few times and now wants to work this way for real, on a codebase that matters.

I run this with two tools and two models. Claude Code in the terminal. GitHub Copilot agent mode in VS Code. Sonnet for most of it, Opus when the thinking gets hard. The method outlives any one tool, but I am going to be specific, because a HOWTO with no commands in it is just an opinion.

### 0.1 Who this is for

You write or maintain real software. You have opened an AI chat window, pasted some code, and gotten useful answers back. You suspect there is more to it. There is. You do not need to be an expert. You do need to stay responsible for the output.

### 0.2 What this is not

This is not vibe coding, the practice of prompting and hoping and shipping whatever falls out. If you want that line drawn clearly, read [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/) first, then come back. It is also not a magic-prompt collection. There is no incantation. There is a method.

## 1. What you need before you start

A short list. The rest of the document assumes you have it.

1. A real project under version control. Git, committed, clean working tree. This is your safety net and it is not optional. If you cannot get back to a known-good state in one command, fix that first.
2. A test suite, even a thin one. The agent will run it. Tests are how the machine checks its own work so you do not have to read every line by hand.
3. At least one agent with hands. Claude Code in the terminal, or Copilot agent mode in VS Code, or both. A chat box you paste into is the training-wheels version. You want the version that can read the repo, edit files, and run commands.
4. A few minutes to write down how your project works. That file beats any prompt trick, and section 4 is about building it.

## 2. The mental model: you stopped typing

The hardest part of this is not technical. You have to stop thinking of yourself as the person who writes the code.

For most of your career the bottleneck was your hands: how fast you turned an idea into correct syntax. AI moved that bottleneck. The cost of producing code fell to almost nothing. What did not get cheaper is deciding what to build and confirming it is right. That is where your whole job lives now. I wrote about the shape of this in [Agent Mode Changes the Shape of Thought](/2026/06/05/agent-mode-changes-the-shape-of-thought/), and about its hidden bill in [The Cognitive Cost of Modern Software Engineering](/2026/06/05/the-cognitive-cost-of-modern-software-engineering/). You become a director, not a typist. Direction is harder than it sounds.

Here is what that looks like at my desk. This is my own setup, on my own time. On my Organic Arts LLC projects and websites, where I set the rules, I run four to eight Claude Code terminals at once, each on a different task, with VS Code open beside them for review: reading the code and the markdown, making small tweaks by hand, stepping through git compares before anything gets committed. The terminals do the building. VS Code is where I look before I trust. My day job is its own world with its own approved tooling, and I am thankful to work somewhere that actively encourages AI-assisted engineering; there the setup is tighter and editor-first. The number of windows is not the point. The work is parallel now, and your job is to keep the parallel work coherent.

Hold that picture. Every tip below is really about protecting the two things only you can do, deciding and verifying, and handing the rest to the machine.

## 3. The two tools I use

Pick a tool with real repository access and learn it well. Two windows beat ten you half-know. Here is the stack I actually run.

### 3.1 Claude Code, in the terminal

This is where most of my building happens. You start it in the project directory:

```bash
claude                      # start an interactive session in the current repo
claude --model sonnet       # start on Sonnet (fast, my default)
claude --model opus         # start on Opus (deeper reasoning, harder problems)
```

Inside the session you talk to it in plain language and it does the work: reads files, writes the change across the codebase, runs the tests, reports back. You switch models mid-session when a task gets hard:

```text
/model opus                 # switch this session to Opus
/model sonnet               # switch back
```

`Shift+Tab` cycles the permission mode: ask-every-time, auto-accept edits, and plan mode (read-only, where it proposes a plan before touching anything). I live in ask-every-time for real work and plan mode when I am still deciding what to do. `Esc` interrupts it the moment it heads the wrong way. Do not wait politely for a bad run to finish.

### 3.2 Copilot agent mode, in VS Code

When I am already in the editor, or my setup is constrained, I use Copilot agent mode. Open the Copilot chat panel, switch it to Agent, and pick the model from the selector. The same two names are there: Claude Sonnet for daily work, Claude Opus when the problem is gnarly. Agent mode does what the terminal does, multi-file edits and a test loop, with the diff right there in the editor where you read it.

### 3.3 When I reach for which

The terminal wins when I want many things happening at once, or I am scripting, or the job is large. The editor wins when the change is small and visual and I want to eyeball the diff as it shows up in the tree. Neither is the "real" one. They run the same loop. Use the one whose friction is lower for the task in front of you.

## 4. Set up your workspace: the memory file

Before you ask the agent to do anything, give it a place to stand.

The single most useful thing you can do is write a project memory file: a document the agent reads every session that tells it how this project works. Each tool reads its own, and this is the part people get wrong, so be clear about it:

- **Claude Code** reads `CLAUDE.md` at the repo root. It also reads a personal one at `~/.claude/CLAUDE.md` for your cross-project preferences, and nested `CLAUDE.md` files deeper in the tree when it works in those folders.
- **Copilot agent mode** reads `.github/copilot-instructions.md` at the repo root.

They are not either-or. They are additional. If you use both tools, you keep both files, and you keep them saying the same thing. This repo carries both. Same content, two front doors.

Claude Code can write you a starting draft from the code itself:

```text
/init                       # generate a starter CLAUDE.md from the codebase
/memory                     # see which memory files are loaded right now
```

Put in the file what you would otherwise repeat out loud every session:

- What the project is, and how it is built, tested, and run.
- The conventions you actually enforce, in your own words.
- The parts that are dangerous to touch, and the rule for touching them.
- The mistakes the agent already made, so it stops making them.

Keep it lean. A long memory file is a memory file the agent skims and you stop maintaining; aim for something you would actually read. When it grows, split the detail into smaller files and pull them in with `@path` imports:

```markdown
See @docs/architecture.md for the system layout.
Testing rules live in @docs/testing.md.
```

This file turns your standing intent into something permanent. You write your standards once and they apply forever, instead of re-explaining them in every prompt. A good memory file is worth more than any clever phrasing, because it removes the need for clever phrasing. Appendix A has a starter you can copy into either file.

## 5. The core loop

Everything else is one loop, run over and over: **specify, delegate, verify, record.** I run it every day and wrote it up in full in [An AI Agent Workflow for Software Engineers That Actually Holds Up](/2026/06/02/ai-agent-workflow-for-software-engineers/). The working summary:

**Specify.** Get clear on what you want before you type a prompt. For anything past a trivial fix, write the intent down: the outcome, the constraints, what is non-negotiable. Vague in, vague out.

**Delegate.** Hand over the task, not the keystrokes. "Add rate limiting to the payments endpoint and update the tests" is a task. Let the agent read the code, make the change, and run the suite. Do not micromanage the implementation. You set the destination; it drives.

**Verify.** Read the diff. Run the tests. Check the real behavior, not just that a command exited zero. People skip this step and it is the one that matters most, so it has its own section below.

**Record.** When you make a real decision, write down why. I work off architecture decision records a lot of the time, one short ADR per real choice, plus a journal note for myself. An ADR pays off twice: it records why you did something, and next time it specifies the work, because a clear decision is already most of a clear prompt.

The loop holds because the first and third moves are exactly the moves an agent cannot make for you. That is the point of the whole method.

## 6. Context and token management

The agent only knows what is in its context window: the running record of your conversation, the files it has read, the test output it has seen. The window is large but not infinite, and a stuffed, stale window makes the agent dumber. Managing it is a real skill, so treat it like one.

Two commands do most of the work:

```text
/context                    # see what is filling the window right now
/clear                      # wipe the conversation, keep the project memory file
/compact                    # summarize the conversation so far and keep going
```

Use `/clear` between unrelated tasks. A fresh window for a new job is faster and sharper than one dragging an hour of irrelevant history. Use `/compact` when one long task has filled the window but you still need its thread; it keeps the gist and drops the noise. Check `/context` when answers start drifting; a full window is often the reason.

Model choice is the other lever. Sonnet is fast and cheap and handles most engineering work, so it is my default and I leave it there. I move to Opus when a task needs real reasoning: a thorny architecture decision, a bug that has survived two attempts, a plan with many moving parts. Then I move back. Running everything on the heavier model is slower and costs more without making the easy work any better. Match the model to the difficulty, not to your mood.

There is a sharper reason to care about all of this: tokens. The deeper you get, the more you feel it, especially as you near a plan limit or you are paying by the token. The skill that compounds is accomplishing more with fewer tokens, and it is worth treating as a craft of its own. A tight task that points the agent at the three files that matter costs a fraction of a vague one that makes it read half the repo just to orient itself. Clear between tasks so you are not paying to carry dead history. Keep the memory file short. Send big searches out as a subagent so the long output stays out of your main window. Reach for Sonnet first and save Opus for where the reasoning earns its higher price. Doing more with less is not a constraint here. It is the game.

## 7. Tips and tricks

The part I would have read first. Each of these I learned by getting it wrong.

1. **Commit before any big agent run.** A clean checkpoint means a bad run costs you a `git reset --hard`, not an afternoon. Treat the working tree as scratch paper the agent writes on.

2. **Work in small, verifiable units.** One coherent change at a time. A pile of changes you cannot review is a pile you cannot trust, however good it looks.

3. **Make the agent run the tests itself.** Do not run them and report back. Wire it so it sees the failures directly and iterates. Closing that loop is most of the magic.

4. **Green is necessary, not sufficient.** AI-generated code can pass every test and still be wrong, because the test never covered the thing that breaks. Passing tests buy confidence, not certainty.

5. **Verify behavior, not exit codes.** A command that exits zero did what it was told, which is not the same as what you wanted. For anything that touches the real world, look at the real world.

6. **Give it the error, not your summary of the error.** Paste the actual stack trace, the actual failing test, the actual log line. The agent is good with raw evidence and bad with your paraphrase.

7. **Fence the dangerous areas in writing.** If code must not change without care, say so in the memory file, not in your head. The agent honors written rules. It cannot read your worries.

8. **Say a correction once, in the memory file.** If you find yourself fixing the same thing twice, that fix belongs in the file, permanently.

9. **When it goes in circles, stop and re-specify.** An agent stuck in a loop is almost always an agent you under-specified. The fix is upstream, in what you asked, not in asking again louder.

## 8. Commands and hacks worth knowing

These are the moves that compound once you are past the basics. All of them are part of how I run a normal day.

**Headless mode, for scripting.** Outside a session, `-p` runs one prompt and exits. Good in scripts, git hooks, and CI:

```bash
claude -p "summarize the changes in the last commit"
cat error.log | claude -p "what is the root cause here?"
```

**Pick up where you left off.** A session is not gone when you close it:

```bash
claude --continue           # resume the most recent session in this repo
claude --resume             # choose from a list of past sessions
```

**Run agents in parallel without collisions.** This is how the four-to-eight-terminals setup actually works. Each agent gets its own git worktree, a separate checkout of the same repo on its own branch, so two agents editing at once never step on each other:

```bash
git worktree add ../proj-auth     -b feature-auth
git worktree add ../proj-logging  -b fix-logging
# open a Claude Code session in each directory; they cannot collide
git worktree list
git worktree remove ../proj-auth  # clean up when the branch is merged
```

**Teach it a repeatable job once.** A custom slash command is a markdown file of instructions you invoke by name. Drop it in `.claude/commands/` in the repo (or `~/.claude/commands/` for all your projects):

```bash
# .claude/commands/ship.md  ->  invoked as  /ship
# put your standard pre-deploy steps in that file in plain language
```

After that, `/ship` runs your checklist the same way every time. This is the lock-it-down move from the next section, made concrete.

## 9. Lock it down, or leave it open

There are two modes of working this way and you need both.

Sometimes I want the creativity of not locking things down. I give the agent room, leave the constraints loose, and let it surprise me. I try to encourage artistry in the outcome and in the system itself, not just correctness. This is the same instinct I bring to freewriting, the practice I call consciousness mining: keep the prompt loose, stay honest, get the ego out of the way, so something I did not plan has room to surface. You are fishing, and you want a wide net. A tight spec here kills the thing you were reaching for.

Other times I build for repetition and lock it down hard. A clear ADR. A strict memory file. Fences around the dangerous code. A custom slash command so the steps never drift. A task specified so tightly there is one reasonable result. That is the mode for work that has to be right and has to be the same every time.

The skill is knowing which one you are in. Leave a production change loose and you ship a subtle bug. Lock down an exploration and you kill the surprise you were after. Decide on purpose, at the start, which mode the task is, and do not drift between them by accident.

## 10. Common failure modes and how to fix them

Symptom, then cause, then fix.

**The output looks right and is subtly wrong.** Cause: you verified the build, not the behavior. Fix: exercise the actual feature. I once moved a site to a private origin; the change was correct except the new origin did not serve directory index files, so every subpage would have broken. The build was green. I caught it by loading a real page, not by trusting the log.

**It keeps reintroducing a mistake you fixed.** Cause: the correction lives in your memory, not the project's. Fix: write the rule into the memory file so it survives the session.

**Its answers start drifting and getting vague.** Cause: the context window is full of stale history. Fix: `/clear` for a new task, or `/compact` to keep the thread but drop the noise. Check `/context` when in doubt.

**It changed something you did not ask it to.** Cause: the task was broader than you thought, or the danger zone was not fenced. Fix: narrow the task, mark the protected areas in writing, reset to your last commit.

**It is slow and you want to just write it yourself.** Cause: the task is small enough that specifying it costs more than doing it. Fix: do the small ones yourself. The loop earns its keep on tasks big enough that direction beats typing. Not everything should be delegated.

**You shipped fast and now you do not understand your own system.** Cause: you skipped the record step, and speed without memory is debt. Fix: slow down on the decisions, write them down, read the diffs you waved through. The cognitive bill is real and it comes due.

## 11. Frequently asked questions

**Claude Code or Copilot agent mode?** I use both. Terminal for parallel and large work, the editor for small visual changes. They run the same loop. My longer comparison for engineering work is in [Claude vs Copilot for DevOps](/2026/06/02/claude-vs-copilot-for-devops/).

**Sonnet or Opus?** Sonnet for almost everything; it is fast and it is enough. Opus for the hard reasoning: thorny architecture, a bug that survived two attempts, a plan with many parts. Switch with `/model`, then switch back.

**CLAUDE.md or copilot-instructions.md?** Both, if you use both tools. Claude Code reads `CLAUDE.md`; Copilot agent mode reads `.github/copilot-instructions.md`. Keep both, keep them in sync. They are additional, not a choice.

**Is this just vibe coding with extra steps?** No, and the difference is the whole thing. Vibe coding skips specify and verify. This method is built on them. See [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/).

**Can I let it run on its own?** Sometimes, with care. Autonomous mode runs the loop without you in it. When to trust it is its own question, covered in [What Is Autonomous Mode?](/2026/06/02/what-is-autonomous-mode/).

**Does this replace software engineers?** No. It moves the work. The cost of writing code fell; the cost of deciding what to build did not. [How AI Is Changing Software Engineering](/2026/05/27/how-ai-is-changing-software-engineering/) is the long answer.

**Does this apply to infrastructure?** Yes, and the payoff compounds there. The same loop runs on Dockerfiles, CI pipelines, and infrastructure code. [Recursive DevOps](/2026/06/05/recursive-devops/) is where I take that to its end.

## 12. Where to go next

This document is the entry point. The cluster behind it goes deeper:

- [AI-Assisted Engineering](/ai-development/), the hub that collects every essay and field note in one place. Start there if you want the map.
- [How AI Is Changing Software Engineering](/2026/05/27/how-ai-is-changing-software-engineering/), the field report on where the bottleneck moved.
- [An AI Agent Workflow for Software Engineers](/2026/06/02/ai-agent-workflow-for-software-engineers/), the core loop in full.
- [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), what compounds across a long engineering career.
- [AgentSpek](/books/agentspek/), my book on building this way, free to read here.

All of this is the practical application of one larger idea I keep coming back to, [making complexity visible](/making-complexity-visible/): keeping a system understandable enough to navigate without pretending it is small. AI-assisted engineering is where I apply it every day.

## 13. A note on the meta

I built this manual the way it tells you to build software. I specified it, delegated the draft to an agent in the exact agent mode described above, verified every command against the live tools, and recorded the decisions as I went. The document is an instance of its own method. That is the meta.

The meta of the meta is the memory file. The `CLAUDE.md` and the voice rules that governed how this got written are the same kind of standing intent section 4 tells you to keep, pointed at prose instead of code. The thing that shaped the writing is itself a project memory file.

And the Übermeta, with the umlaut it has earned: the method applies to itself, all the way up. Building the thing, writing about building the thing, and setting the rules for how that writing is done are one loop running at three heights. This is [Recursive DevOps](/2026/06/05/recursive-devops/) pointed at language. The system that makes the work and the system that improves the system are the same system. Once you see it you do not unsee it. Good. Now go build something.

## Appendix A: A starter memory file

Drop this at the repo root as `CLAUDE.md` for Claude Code, and as `.github/copilot-instructions.md` for Copilot agent mode. Same content, both files. Fill in the brackets. Keep it short and true; a file that lies to the agent is worse than no file.

```markdown
# Project Memory

## What this is
[One or two sentences. What the project does, who uses it.]

## How it is built and run
- Install: [command]
- Dev: [command]
- Test: [command]
- Build: [command]

## Conventions that matter
- [The naming, structure, or style rules you actually enforce.]
- [How errors are handled here.]
- [Anything a newcomer always gets wrong.]

## Do not touch without care
- [Files or systems that are load-bearing and easy to break.]
- [The rule for changing them.]

## Lessons (append as you go)
- [Mistakes the agent made, so it stops repeating them.]
```

## Appendix B: Spec and ADR templates

Two more good ideas worth keeping as templates. The first is for the Specify step: write the intent before you prompt. The second is the ADR I keep one of per real decision.

A spec you hand the agent:

```markdown
# Intent: [one-line outcome]

## Outcome
[What is true when this is done.]

## Constraints
- [What it must not break.]
- [What it must stay compatible with.]

## Non-negotiable
- [The parts there is no flexibility on.]

## Done when
- [The check that proves it works: behavior, not exit code.]
```

An ADR you write when you decide something real:

```markdown
# ADR-[NNN]: [the decision in a few words]

**Status:** [Proposed | Accepted | Superseded]
**Date:** [YYYY-MM-DD]

## Context
[The situation that forced a choice.]

## Decision
[What we are doing, in plain language.]

## Consequences
[What this makes easy, what it makes hard, what we gave up.]
```

## Appendix C: Command cheat-sheet

The commands from this manual in one place. Terminal commands are for Claude Code; the slash commands run inside a session.

```bash
# Start and choose a model
claude                          # interactive session in the current repo
claude --model sonnet           # start on Sonnet (default for daily work)
claude --model opus             # start on Opus (hard reasoning)

# Pick up past work
claude --continue               # resume the most recent session here
claude --resume                 # choose from past sessions

# Headless, for scripts and pipes
claude -p "one-shot prompt"     # run once and exit
cat file.log | claude -p "..."  # pipe input in

# Parallel agents via git worktrees
git worktree add ../proj-x -b feature-x
git worktree list
git worktree remove ../proj-x
```

```text
# Inside a session
/model opus | /model sonnet     # switch model mid-task
/context                        # what is filling the context window
/clear                          # wipe conversation, keep the memory file
/compact                        # summarize and continue
/init                           # generate a starter CLAUDE.md
/memory                         # show loaded memory files
/agents                         # configure subagents
Shift+Tab                       # cycle permission modes (ask / auto-edit / plan)
Esc                             # interrupt a run that is going wrong
```

## About this document

Written by Joshua Ayson, a DevOps engineering leader who builds this way every day. Corrections and better tips are welcome; like the HOWTOs I learned from, this one gets revised.

- *Revision 1.0, June 2026.* First cut: setup, the loop, tips, failure modes.
- *Revision 1.1, June 2026.* Added the tools I actually use (Claude Code and Copilot agent mode), the memory-file split, context and token management, verified commands, and a cheat-sheet.

If it saved you an afternoon, it did its job.]]></content:encoded>
      <pubDate>Sat, 06 Jun 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/06/ai-assisted-engineering-howto/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/ai-assisted-engineering-howto.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>The Cognitive Cost of Modern Software Engineering</title>
      <link>https://joshuaayson.com/2026/06/05/the-cognitive-cost-of-modern-software-engineering/</link>
      <description>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.</description>
      <content:encoded><![CDATA[# The Cognitive Cost of Modern Software Engineering

*AI took the typing, and the cost of building software did not go away. It moved, from the hands to the head, and on the way it got heavier. The work is more productive than it has ever been and more tiring than it has ever been, and those two facts are the same fact. This is the part the pitch leaves out.*

The story everyone tells about AI and software engineering is a story about speed. The code writes itself. A month of work becomes an afternoon. That story is true, and I have lived it, and it is the least honest version of what happened, because it implies the work got easier. It did not get easier. It got more concentrated, and concentration has a price that you pay with your mind, all day, without the breaks the old work used to give you for free.

I want to describe that price plainly, because I have not seen many people name it, and because naming it is the first step to managing it. The companion to this is [Agent Mode Changes the Shape of Thought](/2026/06/05/agent-mode-changes-the-shape-of-thought/), which is about the opportunity. This one is about what the opportunity costs you, and it is not a small thing.

## The bottleneck moved, and so did the cost

I have written software professionally for over fifteen years. I have said elsewhere, in [how AI is changing software engineering](/2026/05/27/how-ai-is-changing-software-engineering/), that the headline is short: AI did not replace engineers, it moved the bottleneck. The cost of writing code dropped to near zero, and the cost of deciding what to build, how to architect it, and when to ship became the whole job.

Follow that one step further than the productivity articles do. If the bottleneck moved, the cost moved with it. The work did not lose its weight. The weight relocated. It used to sit in your hands and your hours, in the sheer volume of typing and stitching and translating that a week of building required. Now it sits in your head, in the unbroken sequence of decisions that is all that remains when the typing is gone. And the head is a more expensive place to spend than the hands, because the hands can work while the mind rests, and the mind cannot rest while it is the only thing working.

That is the whole essay in one sentence, but the sentence stays abstract until you have felt the specific ways the cost shows up. So let me be concrete about them.

## Typing was rest, and nobody says so

Here is the thing I did not understand until it was gone. The mechanical part of programming, the part that AI took, was never the hard part, and everyone knew that. What nobody said is that it was also a kind of rest.

For most of my career a real share of a working week was typing. Boilerplate. Translating a clear idea into a verbose language. Wiring API responses together. Writing the tests that exercise the mechanical paths through code I had just written. Updating the documentation after the refactor. None of that was where the engineering lived. But it was where the day had its valleys. After you made the hard decision, you got to spend an hour or two simply executing it, and the executing was a place the mind could idle. You were producing real work and recovering at the same time. The hands moved and the deeper part of you got to coast.

Take that away and the valleys disappear. The day becomes a ridgeline. Decision after decision, with no flat stretch in between, because the flat stretches were exactly the parts the agent now does in seconds. I describe what I want, and before I have finished my coffee the change is back and it needs a judgment from me. There is no longer an hour of mechanical typing to hide inside while my mind catches its breath. The breath-catching has to be scheduled now, deliberately, because the work will not hand it to you the way it used to.

This is not nostalgia for boilerplate. I do not miss the typing. I am pointing at a real ergonomic fact that the productivity framing erases: the old work had built-in recovery, and the new work does not, and if you do not replace that recovery on purpose you will run yourself down at a rate the old job could not have managed.

## What is left is judgment, and judgment is expensive

When the typing goes, what remains is louder, and all of it is the costly kind of work.

I read more code now than I ever have, and most of it I did not write. Reading code was once maybe a tenth of the job. It is closer to two thirds of mine now: absorbing an unfamiliar stretch the agent just produced, deciding whether it is correct, whether the error handling is right, whether it interacts cleanly with the rest of the system, whether it quietly made an architectural choice while I was looking away. Reading is more tiring than writing, because writing your own code carries you forward on your own intent, and reading someone else's, even a machine's, means reconstructing an intent from the outside and checking it against what you actually wanted. You are doing that, at speed, all day.

Deciding what to build is now the front of the work instead of the preface to it. A model will build the wrong thing beautifully and fast, and the cost of a wrong decision used to be amortized across the weeks it took to implement. Now the wrong thing arrives in an afternoon, fully formed, and you either live with it or back it out. The pressure on the quality of your specification, on knowing what you actually want before the machine commits you to a polished version of a guess, is constant and it does not relent.

And there is a decision that barely existed before and is now one of the most important and most draining: knowing when to stop the agent. Agents do not get tired and they do not stop. They will refactor what did not need refactoring, scaffold for problems you do not have, keep going confidently past the point where they should have asked. The discipline to interrupt, redirect, and reject is the new craft, and restraint is the most expensive new failure mode, because the temptation to do more, faster, simply because you can, is always right there, and saying no to it dozens of times a day is its own kind of fatigue.

None of these are the parts of engineering that let your mind coast. They are the parts that demand all of it. The job did not get smaller. It got distilled down to nothing but its hardest fraction, and then you do that fraction continuously.

## The new failure mode is overload, not slowness

For my whole career the limiting factor was throughput. You could only produce so much in a day, and the failure mode was being too slow: the project that took too long, the backlog that grew faster than you could burn it down.

That failure mode is mostly gone, and a stranger one took its place. When a two-week project ships in two days, the obvious move is to run ten of them at once across the same calendar, because you can. I have done exactly this. And it does not give you more leisure. It gives you ten times the judgment to supply, ten streams to keep coherent, ten contexts to hold and switch between, ten places where a confident mistake can slip through because your attention was on stream seven when stream three went wrong.

The bottleneck is no longer how fast you can produce. It is how much you can hold without losing the thread. That is a cognitive limit, not a physical one, and it is a real ceiling. Past a certain number of live streams the coherence starts to fray, you stop catching the thing heading the wrong direction, and the very capability that let you take on ten projects becomes the reason all ten degrade at once. The new way to fail is not to be too slow. It is to take on more than one mind can keep clear, at the exact speed that makes that easy to do without noticing.

## The intensity is real, and it has a body

I do not want to keep this abstract, because the cost is not abstract. I lived its sharpest version in a stretch I wrote about as [six weeks living at machine speed](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed/).

In those weeks time stopped behaving normally. I wrote in my journal that a single month felt like a year. The line between my own thinking and the machine's processing mostly stopped existing. I was meeting more frameworks and systems in a week than I used to read about in a year, all of it at once, none of it letting up. My computer ran hot from the load, and that heat was a fair picture of what was happening inside my head. I wrote, plainly, that working with a partner all day, whether human or not, is tiring. The tiredness came with a charge to it, and both things were true. We were building about as fast as I could think, and thinking that fast for that long has a cost your body will eventually present to you.

The part I want to flag is what happened to rest. When you can make an idea real about as fast as you have it, sleep starts to feel like an interruption. I have the timestamps to prove it: Thursday 2am commits, Friday 4am pushes, weekend marathons, not because anything forced me but because I could not put it down. That is the seductive shape of this work. It does not exhaust you against your will. It exhausts you with your full enthusiastic cooperation, because the loop between idea and result got so tight and so rewarding that stepping out of it feels like loss. The old job protected you a little by being slow. This one removes the protection and replaces it with a thrill, and a thrill is not a substitute for sleep no matter how convincing it is at 3am.

## The scarce resource is now you

Put all of it together and the conclusion is uncomfortable and clarifying at once. The scarce resource in modern software engineering is no longer compute, or time, or the supply of people who can type the code. It is your own attention, your clarity, the amount of context you can hold at once without it going blurry.

Picture it as a loom. The parallel [threads of work you run at once](/2026/01/28/on-threads/) are exactly that, threads, and a thread on its own is just a loose strand. Attention is the frame that holds the threads in tension and turns them into a fabric instead of a tangle. The weave is only ever as good as the loom, and a loom has a width. Run more threads than it can hold and they slacken and cross, and the pattern you were making comes apart in your hands. The machine can spin thread faster than anyone ever has. What it cannot do is widen your loom. That part is fixed, it is yours, and everything you make is woven on it.

The machine took over the part that scaled with hours, and handed back the part that scales with the quality and the freshness of your mind. Which means your mind is now the constraint on everything, and a constraint is something you have to manage deliberately or it manages you.

This reframes what it means to be good at this job. It is no longer mainly about how much you can produce, because production is cheap. It is about how well you can protect and direct the one input that is now scarce. The most productive thing I can do on a given day is often not to open another stream. It is to keep my head clear enough that the streams I already have get real judgment instead of a tired approximation of it. That is a sentence I would have found ridiculous a few years ago, when the obvious path to more output was more hours. The path to more output now runs through a rested, clear, undivided mind, and that mind is finite in a way that the old bottleneck never made you confront.

## How you pay it down

So the discipline that this era actually demands is not a new framework or a faster tool. It is the management of your own cognition as the scarce resource it has become, and most of it is unglamorous.

The first move is legibility. The thing that overwhelms you is not the size of the system, it is the system being illegible, too tangled to hold in your head, so that every decision costs more than it should because you have to reconstruct the whole shape before you can reason about a part of it. The defense is to keep the system understandable on purpose, to spend real effort making the complex thing simple enough to reason about, which is the larger idea underneath everything I build, the practice of [making a complex system legible enough to live inside](/coherent-complexity/). A legible system is cheap to think about. An illegible one taxes you on every single move, and the tax compounds.

The second move is restraint, which I have already named as the new craft and will name again because it is that important. Not every project that can be run should be run. Not every refactor the agent offers should be taken. The capacity to do more is not a reason to do more, and the engineers who burn out fastest in this era will not be the ones who could not keep up. They will be the ones who could, and did not know where to stop. Saying no to your own capability is now a core professional skill.

The third move is to treat rest as part of the work rather than a failure of it. The old job built recovery into the day and you could afford to be careless about it. This one does not, so you have to put it back deliberately, and you have to defend it against the thrill that tells you the loop is too good to leave. Sleep is not an interruption of the work. It is the maintenance of the only instrument the work now depends on. I came to this the hard way, and it is the same antifragile instinct I try to apply everywhere, that a little structure and a little protection on the downside is what lets a system, or a person, [gain from intensity instead of being broken by it](/2026/05/30/living-with-antifragility/).

The last move is to know your own limit, honestly, the number of live streams past which your coherence frays, and to stop short of it on purpose. That number is real, it is personal, and it is lower than your ambition wants it to be. Finding it and respecting it is the difference between using this capability for a long time and using it brilliantly for a while and then crashing.

There is a practical version of all of this that I had to learn by hand: protect blocks of single-threaded attention on purpose, where you run one stream and let the loom hold a single clean pattern instead of a dozen fraying ones. The instinct of the era is to parallelize everything, because you can, and some of the most valuable work I do now is the deliberate refusal to, the hour given over to one hard problem with my whole undivided head. The machine made breadth cheap. Depth stayed expensive, and depth is still where the hard decisions get made well.

## The work got more human, not less

There is a fear that AI hollows out engineering, turns it into prompting, removes the craft. My experience is close to the opposite, and the cost is the proof. The machine took the parts that were mechanical, the typing and the translation, the parts that were never really you. What it left behind is the parts that are nothing but you: the taste to know what is worth building, the judgment to know when something that looks right is wrong, the clarity to hold a complex thing in your head, the restraint to stop. Those parts are expensive precisely because they are human, and they cannot be delegated, and there is now nowhere to hide from them inside an afternoon of comfortable typing.

That is why the work is more tiring even as it is more productive. You are spending the whole day in the part of yourself that costs the most to spend. The bargain is real and it is good, but it is a bargain, and pretending it is free is how people get hurt by it. Name the cost, manage the resource, protect the mind, and you can do this for a long time and love it. Ignore the cost because the productivity numbers are intoxicating, and the resource that the whole thing depends on, which is now you, will run out, quietly, at the exact moment you are most convinced you are invincible.

If you want the method I run inside all of this, it is the [book-length version in AgentSpek](/books/agentspek/), free here, and the rest of how I build this way lives at [AI-Assisted Development](/ai-development/). But the most important tool is not in any of them. It is the discipline of guarding the one resource that does not scale, and that, unlike the typing, no machine is going to take off your hands.]]></content:encoded>
      <pubDate>Fri, 05 Jun 2026 22:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/05/the-cognitive-cost-of-modern-software-engineering/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/the-cognitive-cost-of-modern-software-engineering-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Recursive DevOps</title>
      <link>https://joshuaayson.com/2026/06/05/recursive-devops/</link>
      <description>DevOps was always a feedback loop. The first one ran between people. The one worth building now runs the system back on itself, so every failure and every change makes the next one cheaper and safer. The recursion is the compounding.</description>
      <content:encoded><![CDATA[# Recursive DevOps

*DevOps was always a feedback loop. The first version of it ran between people. The version worth building now runs the system back on itself, so that every failure and every change feeds forward into a system that is cheaper and safer to change next time. The recursion is the whole compounding mechanism, and most teams never turn it on.*

I have spent fifteen years inside the DevOps thesis, as a practitioner, then a lead, then someone running platform organizations. The longer I do it, the more I think the original idea was both completely right and quietly mislabeled. It got remembered as a thesis about automation. It was really a thesis about loops. And once you see it as a thesis about loops, an obvious question appears that the industry mostly did not ask: a loop between what and what, and how many times does it run.

This is the answer I have arrived at. The most valuable thing you can do in operations is not to automate the work. It is to close the loop on the system itself, so the system becomes the thing that improves the system. I have written the broad version of why systems thinking is the part that compounds in [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/). This is the narrower, sharper claim underneath it.

## The loop was the original idea

The original DevOps argument was simple and correct. Developers and operators were optimizing against each other, the friction between them was the single largest source of incidents, and the cure was to put them in the same loop. Deploy small changes often. Automate the path from commit to production. Measure what matters. Share responsibility for the running system, not just the code that produced it.

Every word of that is still true. But notice the shape of it. The cure was not a tool. The cure was a feedback loop. Put the people who write the change and the people who run the change into one circuit, so that the consequences of a decision reach the person who made it, quickly, while they can still do something about it. That is the actual invention. The pipelines and the dashboards and the alerting were just the wiring that made the loop fast.

When you see the loop as the invention, the tools stop being the point. A loop is a pattern, and a pattern can be applied to more than the thing it was discovered on. The first DevOps loop closed between two groups of humans. The interesting move is to ask what else you can put inside a loop, and what happens when the loop starts feeding into the very thing that produced it.

## From a loop between people to a loop on the system

Here is the shift. The original loop ran from the system to a human and back: the system did something, a human saw it, the human changed the system. That is already valuable, and it is most of what teams build. But the human in the middle is a bottleneck, and more to the point, the human keeps having to learn the same lesson because nothing about the system itself changed to remember it.

A recursive loop closes the circuit one level deeper. The system does something, a human sees it, and then the human changes the system so that the system itself now handles that case, or makes it impossible, or surfaces it earlier next time. The output of one pass is a permanent change to the thing that will run the next pass. The loop is no longer just operating the system. It is reshaping it, and each reshape changes what the next reshape starts from.

That is what I mean by recursive DevOps. Not infinite cleverness. A discipline of always closing the loop one level deeper than the incident, so that the work you do this week lowers the cost or the risk of the work you do next week. If your operational effort this month did not make next month's operational effort cheaper, you did maintenance. Maintenance is necessary, but it does not compound, and the whole game in a long-lived system is compounding.

## A failure is an input, not the enemy

The cleanest example I have is the day an agent-written deploy script deleted most of production.

The script was good. It built the site, synced the files to a bucket, and cleaned up anything stale so the live state matched the build exactly. That last behavior, deleting whatever was not in the new build, is correct right up until the build comes up short. One day a build failed partway through, produced an incomplete set of files, and the script did exactly what it had been told. It made the live site match the incomplete build, which meant deleting most of the images from production. I have written the longer version of this in [how I rebuilt this site in agent mode](/2026/06/03/rebuilt-my-site-in-agent-mode/), but the part that matters here is what I did with the failure.

The non-recursive response would have been to fix the immediate problem. Re-upload the images, clear the cache, move on, and add a line to a runbook telling the next person to be careful. That closes the loop at the human level. The lesson lives in a person, the system is exactly as dangerous as it was, and the failure is waiting to happen again to someone who has not read the runbook.

The recursive response is to change the system so the failure cannot recur. I pushed the images back with a sync that only adds and never deletes, and then I changed the deploy itself so that a bad build can no longer reach a destructive step, and so asset uploads only ever add. The failure became a permanent improvement to the shape of the system. The system now knows something it did not know before, not in a document, in its structure. That is the only good thing a failure is for, and a failure that you spend on a runbook line instead of on the architecture is a failure you have agreed to suffer again.

This is what people mean, or should mean, by antifragile, and it is the same instinct I try to bring to everything I build, the practice of [making systems that gain from disorder](/2026/05/30/living-with-antifragility/) rather than ones that merely survive it. A robust system takes the hit and stays standing. A recursive system takes the hit and comes out the other side unable to take that particular hit again. The disorder is not the thing you are defending against. It is the input. Every incident is a free piece of information about where your system is weak, paid for in pain you have already spent. The only waste is to spend the pain and not collect the information.

The discipline that makes this routine is naming failure modes before they happen and rehearsing them. The platform itself keeps teaching me to do it: assume the part will fail, decide in advance what happens when it does, and build so that the answer is already known. What happens when a deploy is incomplete. What happens when a cache header is wrong. What happens when a path that worked on the old host does not resolve on the new one. Each of those questions, asked early, is a small recursion run on purpose instead of waiting for the system to run it on you at three in the morning.

## Make the runbook unnecessary

There is a tell that separates teams that are looping recursively from teams that are just automating, and it is the runbook.

Automation looks at a nine-page runbook and asks how to execute it faster. It writes the script that runs the steps. This feels like progress, and it produces real, measurable savings, and it is the easy half of the job. The hard half, the recursive half, looks at the same nine-page runbook and asks a different question: why does this need to exist at all? A system that requires fifteen humans to interpret seven dashboards to decide whether it is safe to deploy on a Friday is not a system that needs more automation. It is a system that needs a different shape. Automation built on top of a confused architecture just amplifies the confusion at higher speed.

I have written a lot of runbooks. The work that actually moved the incident rate down was almost never the runbook. It was the work that made the runbook unnecessary. The runbook is the symptom. The architecture that produced it is the disease, and you can spend a career treating symptoms very efficiently while the disease compounds underneath.

So the recursive move on any piece of operational toil is to ask whether this pass eliminates the need for the next pass, or merely speeds it up. Automating a manual step that should not exist is a local optimum that locks in the thing you should have removed. The deeper version of the question, the one that pays off over years, is the one most organizations are bad at, because they are exquisitely good at calculating the cost of doing something and catastrophically bad at calculating the cost of not doing it. The five-year-old instance nobody will touch because nobody knows what runs on it is a cost. The fragile deploy everyone is afraid to refactor is a cost. The migration the team has spent four years not doing is a cost. Automation does not surface those. Only judgment does, and judgment is the part of this that does not get automated, which is exactly why it is the part that keeps mattering.

## The platform that improves the platform

Around 2022 the industry started calling the mature version of this platform engineering, and the rename was useful because it made the recursion explicit. The platform is a product. The application teams are the customers. And the platform team's entire mandate, the whole of it, is to make the next line of application code easier and safer to ship than the previous one.

Read that mandate as a function and it is openly recursive. Each thing the platform team ships is supposed to lower the cost of the next thing everyone else ships, which lowers the cost of the thing after that. A platform feature that nobody adopts is not neutral. It is debt, because it added surface area without lowering anyone's cost of change. The platform team's success is not measured by how much they ship. It is measured by how much the application teams ship because the platform exists. That is a derivative, a rate of change of someone else's velocity, and optimizing a derivative is a fundamentally different posture than optimizing your own output.

This is the recursion at the organizational scale. You are not building the product. You are building the thing that builds the product, and then improving the thing that builds the thing, and the payoff lives in how many downstream changes each upstream change makes cheaper. A team that internalizes this stops measuring itself by tickets closed and starts measuring itself by friction removed, which is the only metric that compounds.

## Agent mode closes the loop faster

Everything above was true before AI agents entered the workflow. What agent mode changes is the cost of a single pass through the loop, and lowering that cost changes how often you can afford to run the recursion.

A lot of the routine platform work that used to take a junior engineer a week now takes a senior engineer a morning. Writing the Terraform module, scaffolding the service, generating the CI workflow, drafting the runbook, and crucially, performing the reshape that makes the runbook unnecessary: all of that compresses hard. When the mechanical cost of changing the system drops toward zero, the recursion gets cheaper to run, and things that were too expensive to bother fixing become worth fixing. The half-day refactor that removes a class of incident was never worth a week of a person's time against everything else on the board. At a morning, it is obviously worth it. So the loop runs more often, and a loop that runs more often compounds faster.

The economics of the team shift with it. The old question was how many junior engineers you needed to do the rote work. The new question is how many senior engineers you need to direct the rote work the agents now do, and the ratio inverts. A platform team stops being measured by its capacity to produce configuration and starts being measured by the quality of its judgment about which configuration is worth producing. That is a smaller team doing higher-altitude work, and it is only an improvement if the judgment is actually there. Invert the ratio without the systems literacy to aim the agents and you have not made the team better. You have given it a faster way to generate operational debt, because the agents will widen whatever loop you point them at, the compounding one or the destructive one, with equal cheerfulness.

But there is a sharp edge, and it is the same edge I described in [Agent Mode Changes the Shape of Thought](/2026/06/05/agent-mode-changes-the-shape-of-thought/). The agents are very good at the steps and very bad at whether the steps are the right steps. An agent will happily build a beautifully clean pipeline that solves the wrong problem. It will write a Terraform module that provisions infrastructure your team cannot operate. It will refactor a deploy script in a way that breaks a tribal-knowledge invariant nobody wrote down. This is not a flaw in the agents. It is a clarification of where the engineering always was. The agents have made it impossible to fake the systems-thinking part of the job, because they will produce an enormous volume of confident, plausible work that quietly increases the operational debt if a real judgment is not steering it.

So agent mode does not run the recursion for you. It turns the crank. It makes each pass cheap. The thing that decides whether the loop compounds or just produces more system faster is still a human deciding which failure is worth turning into a permanent improvement, which change actually lowers the cost of the next change, and which part of the system to point the loop at next. The agent makes the reshape cheap. It cannot tell you that the reshape was worth doing, or that you reshaped the right thing.

## Pointing the recursion

The practical version of all of this fits on one question, which I now ask of nearly every piece of operational work: does this pass make the next pass cheaper, or does it just get me through today?

If it gets me through today, it is maintenance, and sometimes maintenance is what the day requires. But if I find that almost everything I am doing is getting me through today, I am running an open loop. I am operating the system and learning nothing into it. The recursive habit is to spend a fixed fraction of every incident and every change on closing the loop one level deeper than the problem in front of me. The incident becomes a structural change that makes it impossible. The change becomes a lowering of the cost of the next change. The runbook becomes an architecture that needs no runbook.

The signals that tell you whether the recursion is working are the boring operational numbers, and they are honest in the way that physics is honest. I have written about how [AWS is math and Kubernetes is physics](/2026/05/31/aws-is-math-kubernetes-is-physics/), how one discipline bills you in money and the other in latency and contention. Those bills are the feedback. The cost trend, the incident rate, the time it takes a new engineer to ship safely, the length of the runbook: those are the readouts of whether each pass is making the system cheaper to change or more expensive. A recursive practice bends them in the right direction over quarters, not because of any single heroic fix, but because the loop is pointed at making the next thing easier, and it keeps running.

## The system that gets stronger from what hits it

DevOps started as a loop between people, and that was the right place to start, because the friction between people was the first bottleneck. The version I am describing is the same idea taken one level deeper: a loop the system runs on itself, with a human pointing it and agents turning the crank fast enough that you can afford to run it constantly. The output of the loop is not a deployment. The output of the loop is a better system for producing the next deployment, and a better system again after that.

The aim, in the end, is a system that gets stronger from what hits it. Not one that resists disorder, but one that converts it, that takes every failure and every awkward change and every painful migration and comes out structurally improved, unable to suffer that exact thing again, cheaper to change than it was the day before. That requires keeping the whole growing thing legible enough to actually reason about, which is the larger idea underneath everything I build, the practice of [making a complex system legible enough to live inside](/coherent-complexity/), whether the system is a cloud platform, a codebase, or a life. The agents will turn the crank as fast as you let them. Whether the loop compounds is the part that is still, and will remain, yours.

If you want the broader argument for why systems literacy is the skill that survives, it is in [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), and the book-length version of how I work this way is [AgentSpek](/books/agentspek/), free to read here. The rest of how I build lives at [AI-Assisted Development](/ai-development/).]]></content:encoded>
      <pubDate>Fri, 05 Jun 2026 21:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/05/recursive-devops/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/recursive-devops-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Agent Mode Changes the Shape of Thought</title>
      <link>https://joshuaayson.com/2026/06/05/agent-mode-changes-the-shape-of-thought/</link>
      <description>Agent mode is not a faster way to type. It moves the unit of thought up from syntax to intent, turns you into a conductor of parallel work, and makes the real bottleneck the clarity you can hold in your head at once.</description>
      <content:encoded><![CDATA[# Agent Mode Changes the Shape of Thought

*The speed story is the easy one to tell and the least interesting. What actually changes when you build software in agent mode is the unit you think in, the number of things you can hold at once, and where the hard part of the work goes to live.*

When people describe agent mode, they almost always reach for speed. It writes the code faster. It does in an afternoon what used to take a month of evenings. That is true. I have said it myself. And it is the shallow version, because it measures a new thing with the old ruler.

The deeper change is harder to see, because it happens inside your head instead of on the screen. I have been working this way for the better part of a year, and the thing I keep noticing is not that I produce more. It is that I think differently. The shape of the work changed. The unit I reason in moved up a level. The number of things I can hold in flight went up with it. And the part of the job that is actually hard relocated to a place it never used to live.

This is an attempt to describe that change plainly, from the inside.

## First, the plain definition

If you have not used it, here is the short version. I wrote a [longer one separately](/2026/06/02/what-is-agent-mode/). Agent mode is when you stop typing code and start directing an AI that reads your codebase, makes the change across as many files as the task needs, runs the tests, and reports back. You describe the outcome. It does the work and checks itself. You review, correct, and send it again.

The loop is not write, compile, test. It is specify, generate, verify, specify. You say what you want clearly enough that an agent can act on it. It produces the change. You confirm the result is right, or you catch that it is wrong. Then you correct course and go again.

Notice where the hours go in that loop. Not into typing. They go into the first step and the third: being precise about what you want, and checking that you got it. Hold onto that, because everything that follows comes out of it.

## The unit of thought moves up

For most of the history of programming, the unit of thought was small. You held a function in your head. You held the line you were typing, the variable you were tracking, the bug three calls down the stack. Even with good autocomplete the unit did not really change. Autocomplete finishes the line you are already writing. You are still the one holding the whole task in your head, typing it out one suggestion at a time. The machine is a faster keyboard, not a different altitude.

Agent mode moves the altitude. I am no longer working at the level of the keystroke, or even the function. I am working at the level of the task, and increasingly at the level of the system. I do not think "write a loop that does this." I think "this endpoint needs rate limiting and the tests need to cover the new failure case," and that sentence is the work. The agent reads the relevant files, writes the change, runs the suite, and comes back with a diff. I was never in the editor. I was holding the intent.

That shift sounds small and it is not. When the unit of thought is a function, your day is a thousand tiny acts of translation: turning what you want into the exact syntax that produces it. When the unit of thought is a task, that translation layer mostly disappears, and what is left is the thinking it used to bury. You spend your attention deciding what should exist and whether what came back is correct. The grammar stops being the bottleneck. The idea becomes the bottleneck, which is a much more honest place for it to be.

I noticed this most clearly the first time I described an outcome instead of a procedure. I needed to stand up an AWS service behind CloudFront with a private S3 origin and a password gate at the edge. The old way was to read the documentation, write the infrastructure code, wire the origin access control, debug the bucket policy, fix the cache behavior, and repeat until it held. In agent mode I described the end state: private bucket, served only through this one distribution, gated by a password at the edge. The agent wrote the configuration, explained the wiring, and flagged the single gotcha that breaks these setups. My job was to decide the design and verify the result, not to remember the order of the arguments. The cost of writing the configuration dropped to almost nothing. The cost of deciding what to build and confirming it was right became the entire job.

## The bottleneck moves off your hands

This is the part the hype skips. Working in agent mode is not less engineering. It is more of the engineering that matters and less of the typing that does not.

For years the limiting factor on what one person could build was production. There were only so many hours, and the hours went into making the thing. Agent mode takes the cost of making the thing and drives it toward zero. What is left is what was always the real job and was always crowded out by the typing: knowing what to build, and knowing when something that looks right is actually wrong.

So the bottleneck moved. It used to sit in your hands, in how fast and how long you could produce. Now it sits in two places, and both are upstream of any code. The first is the clarity of your intent. Vague intent produces a polished version of the wrong thing, fast, so the act of being precise about what you want is no longer a preface to the work. It is the work. The second is the rigor of your verification. AI-generated code can pass every test you wrote and still be wrong, because it can satisfy the letter of a specification while missing the thing you actually meant. So checking is not a formality at the end. It is half the job, and it does not get easier as the production gets faster. If anything it gets harder, because there is more output arriving and less of it passed through your own hands on the way.

When I [rebuilt this site in agent mode](/2026/06/03/rebuilt-my-site-in-agent-mode/) and moved it off shared hosting onto AWS, that is exactly where my attention went. I was not writing the components or the deploy configuration. I was deciding what the site should be, reading the diffs, catching the architectural choices that would cost me later, and saying yes or no. The thing that did not drop, the thing that became more important than before, was judgment.

## Scaling cognition, not output

The part that still surprises me is what happens when it is not one agent but several.

With one agent you are a person directing a fast collaborator. With several you become something closer to a conductor. One agent is refactoring a module while another drafts a migration while a third checks a result. You are holding more in flight than a single human working alone could hold, and the holding is the skill. The bottleneck moves off your hands entirely and onto your ability to keep several streams coherent at once: to know which one needs you now, to feel when one is confidently heading the wrong direction, to keep the whole shape in your head while the pieces move.

This is where I am most willing to say something strong, because it is the thing I did not expect. This is genuinely a new way to think, not just a new way to type. You are scaling your own cognition. And the limit is no longer how fast your hands move or how many hours you have. The limit is how much clear intent you can hold at one time. That is a cognitive limit, not a physical one, and it is trainable in a way that typing speed never really was.

I keep coming back to the [Iron Man suit](/2026/06/03/agent-mode-iron-man-suit/) as the closest honest image, because the suit never replaced the man inside it. It amplified him. Without the man it is an empty shell, and without the suit the man is just very smart in a cave. The whole point is the pairing. And the suit does not make Tony Stark a faster typist. It makes his intent reach further. He decides where to go, and the machine handles the flying. What changes is not the speed of his hands. It is the radius of what one person can affect, and the radius is set by the clarity of the person at the center.

## The proof is the range

Here is the evidence, and it is not a benchmark. Over the last year I shipped four open-source projects, each in a different domain. A library of small playable games. A music synthesis engine built from raw arrays of numbers, with no samples. An animation studio that runs from scripts. A language-learning system that is nothing but text files and prompts. Different fields, different skills, none of which I am formally trained in across the board, all built primarily in agent mode, and all shipping things you can actually use today.

A few years ago that range would have been impossible for one person in a year. Not because the individual pieces are beyond a determined builder, but because the cost of becoming fluent enough in four unfamiliar domains to produce finished work in each one was too high. The typing alone would have eaten the year. What collapsed that cost was not that the agent knew those domains for me. It was that the agent handled the translation in each one, the part where you turn a clear intent into the specific incantation that a synthesizer or an animation pipeline or a spaced-repetition system wants. So my actual job in all four was the same job: decide what should exist, set the constraint, and verify the result.

That sameness is the tell. When the unit of thought is the keystroke, every new domain is a new language you have to learn before you can say anything in it. When the unit of thought is the intent, the domains start to rhyme, because the thing you are doing, holding a clear specification and checking it honestly, does not change when the subject does. The skill that scales is not domain knowledge. It is the discipline of clear intent, and that discipline ports.

I do not think this means anyone can now do anything. Taste does not transfer for free, and a clear head in one domain is not automatically a clear head in another. But the friction that used to keep a single builder pinned to one specialty got much thinner, and what is left holding you is your own judgment, spread as wide as you can keep it coherent. The four projects, and the one philosophy underneath them, are written up [together](/projects/) if you want the longer look.

## Judgment becomes the whole job

I want to be careful here, because the same thing that makes the suit powerful is exactly how you fly it into a mountain.

It does what you point it at, fast, and confidently, and that is precisely the danger. A vague intent gets you a polished version of the wrong thing. A weak check lets a plausible mistake through at speed. The faster the system, the more your judgment is the only thing standing between you and a very efficient disaster. Power that does what you say is only as good as the clarity of what you say and the rigor of how you confirm what came back.

I learned this in the most direct way possible. An agent wrote a deploy script for this site. It was a good script. It built the site, synced the files to S3, and cleaned up anything stale so the live bucket matched the build exactly. That last behavior, deleting whatever was not in the new build, is correct right up until the build comes up short. One day a build failed partway through and produced an incomplete set of files, and the script did exactly what it had been told: it made the live site match the incomplete build, which meant deleting most of the images from production.

Nothing about that was the agent being stupid. The script was logical. The bug was that a destructive operation had been coupled to an assumption that the build was always complete, and nobody, human or machine, had questioned that assumption until it failed.

The recovery is the point. The images were never really lost, because the source of truth was the repository on my machine, not the bucket. I pushed them back with a sync that only adds and never deletes, cleared the cache, and the site was whole again in a few minutes. Then I did the thing the incident was actually asking for. I changed the deploy so a bad build can no longer reach a destructive step, and so asset uploads only ever add. The failure became a permanent improvement to the system, which is the only good thing a failure is for.

That is the loop working as intended. Trust it to do the work. Do not trust it to be right. Keep a source of truth it cannot touch, and keep the irreversible operations behind a gate. The agent did most of the typing for the original script, the recovery, and the hardening. The judgment about how it should fail was mine, and it had to be, because that is the kind of decision that does not survive being delegated.

## What this asks of you

If the production stops being the constraint, the constraint becomes you, and not in a way you can fake.

You have to actually know what you want. Agent mode is brutal about this. When my intent is clear, the work pours out and most of it is right. When my intent is muddy, the work pours out just as fast and most of it is subtly wrong, and I have to throw it away and figure out what I was actually after, which I should have done first. The tool will not do that part. If the problem is still fuzzy in your own head, no amount of delegation helps, because you cannot specify what you have not figured out. That part is still yours, and it is more exposed than it used to be, because there is nowhere to hide it. You cannot disappear into an afternoon of typing and feel productive while you avoid the hard decision. The typing is gone. The decision is all that is left.

So the discipline did not go away. It moved, and it concentrated. I spend less effort making the thing and far more effort being sure I asked for the right thing and that the thing is correct. I think in failure modes now, because the platform keeps teaching me to: assume the part will fail, name how, and build so that when it does you already know what happens next. I think in specifications, because a specification is just intent made precise enough to act on. I think in verification, because speed without checking is just a faster way to be wrong. None of those are new ideas in engineering. What is new is that they are no longer the parts you get to around to. They are the parts that are left.

There is a version of this that reads as loss, as if the craft got hollowed out. I do not experience it that way at all. The typing was never the craft. The craft was always the judgment, the taste, the decision about what is worth building and the eye for when something that looks right is wrong. Agent mode did not remove the craft. It removed everything around the craft, and left me standing in front of the part that was always the point, with my whole attention free to spend there. This is the same instinct I bring to everything else I build, the discipline of [making a complex system legible enough to live inside](/coherent-complexity/), whether the system is a cloud platform, a codebase, or a life.

## Where it leaves you

The gap between having an idea and having the thing got small. A single builder with taste and a clear head can now reach a scale that used to require a team, and can keep the whole thing coherent because it is still one mind directing it. That is the part that feels new and a little vertiginous: the reach went up, and the thing that sets the reach is no longer your hands. It is the clarity you can hold.

So the practical advice is almost philosophical. Get clear. Learn to say what you want with enough precision that another intelligence can act on it without you hovering. Learn to verify without flinching, especially when the output looks finished. Learn to hold more than one thread without losing the shape of the whole. Those are the skills that scale now, and they are skills of thought, not skills of typing.

If you want the method I run inside all of this, I wrote down [an AI agent workflow that holds up](/2026/06/02/ai-agent-workflow-for-software-engineers/), and the book-length version is [AgentSpek](/books/agentspek/), free to read here in full. If you want the feel of the work rather than the mechanics, it is [not vibe coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/). And the rest of how I build this way lives at [AI-Assisted Development](/ai-development/).

The suit is real. It fits. And the strange, good catch is that it makes the human inside it matter more, not less, because the one thing it cannot do, decide what is worth building and know when it is right, is suddenly the only thing left to do.]]></content:encoded>
      <pubDate>Fri, 05 Jun 2026 20:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/05/agent-mode-changes-the-shape-of-thought/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/agent-mode-changes-the-shape-of-thought-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Microservices, Agents, and What I Am Building Next</title>
      <link>https://joshuaayson.com/2026/06/03/microservices-agents-what-im-building-next/</link>
      <description>Microservices used to be a tax a solo builder could not afford. AI agents change that math. Here is why I am drawn to the architecture for what I build next, and the discipline that keeps it from becoming a mess.</description>
      <content:encoded><![CDATA[For most of my career, microservices were a tax I could not afford alone. The idea is good: break a system into small, independent services, each owning one job, each able to fail, scale, and change without dragging the rest down with it. The problem was the overhead. More services means more deployments, more boundaries to define, more wiring, more ways for the connections between things to break. For a small team or a solo builder, the cost of all that machinery usually outweighed the benefit, and the honest answer was to keep things in one well-organized monolith and not pretend otherwise.

AI agents change that math, and that is why the architecture is back on my mind for what I build next.

## What the agents change

The tax on microservices was never really the services. It was the connective tissue: the boilerplate, the deployment pipelines, the glue code, the operational babysitting of a dozen small things instead of one big one. That is exactly the kind of work the cost of which has collapsed. An agent can stand up a service, wire its deployment, write its tests, and connect it to the rest, in the time it used to take to decide whether the effort was worth it.

When the overhead per service drops far enough, the calculus flips. The reasons to want small, independent, isolated services were always sound. It was only ever the price that made them impractical at small scale. Lower the price and a single builder can run an architecture that used to require a platform team.

There is a deeper fit, too. A microservice is, by design, a bounded piece of work small enough to hold in one head. That is also the size of work an agent handles best. An architecture made of small, clearly-bounded units is an architecture you can hand to agents one unit at a time, which means the way I want to build and the way I want to structure what I build are starting to point in the same direction.

## Why it fits how I already think

This is not a new instinct dressed in new clothes. It is the same idea I keep circling in everything else.

Breaking a system into bounded services is one more way of making a complex thing [legible instead of simple](/coherent-complexity/). You do not pretend the system is small. You give it seams, so a human, or an agent, can reason about one part without holding all of it at once. The whole stays complex; each piece becomes comprehensible. That is the entire move I care about, applied to architecture.

It is also [antifragile](/2026/05/30/living-with-antifragility/) by construction. Isolation means a failure in one service is contained instead of cascading. Redundancy and independent scaling mean the system can absorb a shock in one place and keep running everywhere else. The same logic that makes me hold slack in a portfolio and redundancy in infrastructure makes me want boundaries in a system: not to be efficient, but to survive the part that breaks.

## The discipline that keeps it honest

Here is the catch, and it is the same catch as always. The fact that agents make microservices cheap does not make microservices free, and it absolutely does not make them always correct.

There is a failure mode where you decompose a thing into twenty services because you can, and you end up with distributed complexity that is harder to reason about than the monolith you started with. A poorly drawn boundary is worse than no boundary. Splitting a system along the wrong seams gives you all the overhead of distribution with none of the benefit, and now the mess is spread across a network instead of contained in one codebase.

So the rule I am holding onto is the same one I apply to money and to systems generally: robustness before optimization. Start with the simplest thing that works, usually one service, and split only when a real seam reveals itself, when a part genuinely wants to fail, scale, or change on its own schedule. Let the architecture earn its complexity. Do not reach for the sophisticated structure because the tools finally let you. Reach for it when the system is actually asking for it, and not one service before.

## What this means for what I build

The practical upshot is that the things I make next, the apps and tools and environments I have been sketching, get to be designed the way I always wanted them designed, in small honest pieces, because the help is finally good enough to make that practical for one person. I get to keep pushing the limits of what a single builder can stand up, using AI as additional hands, and keep the result coherent because each piece is small enough to understand and the seams between them are drawn on purpose.

That is the whole bet I keep making, in one more domain. Not simpler. Legible. A complex system, built in pieces you can actually reason about, that survives the failure of any one of them, and that one person can now hold in their head because they had the help to give it the right shape.

If you want the method underneath the building, it is [an AI agent workflow that holds up](/2026/06/02/ai-agent-workflow-for-software-engineers/). For the idea underneath the architecture, it is all the same thing: [coherent complexity](/coherent-complexity/).]]></content:encoded>
      <pubDate>Wed, 03 Jun 2026 19:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/03/microservices-agents-what-im-building-next/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/microservices-agents-what-im-building-next.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Agent Mode Feels Like the Iron Man Suit</title>
      <link>https://joshuaayson.com/2026/06/03/agent-mode-iron-man-suit/</link>
      <description>The suit never replaced Tony Stark. It amplified him. That is the closest thing I have to a description of what it feels like to build software in agent mode, directing one or many agents and scaling your own thought and output.</description>
      <content:encoded><![CDATA[The thing about the Iron Man suit is that it never replaced Tony Stark. It amplified him. Without the man inside it the suit is an empty shell, and without the suit the man is just very smart in a cave. The whole point is the pairing. That is the closest thing I have to an honest description of what it feels like to build software in agent mode, and I have been chasing a better metaphor for months without finding one.

I dreamt of this, frankly, for a long time before it arrived. Not the specifics. The feeling. The sense that the distance between having an idea and having the thing could collapse, that a single person with enough clarity could reach further than a single person ever has. It is here now, and it has exceeded what I let myself expect.

## What the suit actually amplifies

It is easy to assume the amplification is speed, that the suit just lets you type faster. That is the shallow version and it misses the real thing. The suit does not make you a faster typist. It makes your intent reach further. You decide where to go, and the machine handles the flying.

In practice that means I am no longer working at the level of the keystroke or even the function. I am working at the level of the task, and increasingly at the level of several tasks at once. I describe what I want built, the agent goes and builds it across the whole codebase, runs it, reads the failures, fixes them, and comes back. My attention sits where it is actually worth something: on what to build, on whether the result is right, on the decisions that compound.

The cost of producing the work dropped toward nothing. What is left is the part that was always the real job, and it turns out there is a lot of it.

## Scaling thought, not just output

The part that still surprises me is what happens when it is not one agent but several. You stop being a person who does one thing at a time and start being something closer to a conductor. One agent is refactoring a module while another is drafting a migration while a third is checking a result. You are holding more in flight than a single human working alone could hold, and the holding is the skill.

This is where the suit metaphor strains in a good way, because it stops being about a single exosuit and becomes about commanding a small fleet. The bottleneck moves off your hands and onto your ability to keep several streams coherent in your head, to know which one needs you now, to catch the one that is confidently heading the wrong direction. It is genuinely a new way to think, not just a new way to type. You are scaling your own cognition, and the limit is how much intent you can keep clear at once.

## Someone still has to fly it

I want to be careful here, because the suit is also exactly how you fly into a mountain.

It does what you point it at, fast, and confidently, and that is precisely the danger. A vague intent gets you a polished version of the wrong thing. A weak check lets a plausible mistake through at speed. The faster the suit, the more your judgment is the thing standing between you and a very efficient disaster. Power that does what you say is only as good as the clarity of what you say and the rigor of how you verify what came back.

So the discipline did not go away. It moved. I spend less effort making the thing and more effort being sure I asked for the right thing and that the thing is actually correct. That is not a downgrade. That is the work arriving at the place where a human is genuinely irreplaceable, and being freed to spend its whole attention there.

## The most alive I have felt building

I am aware this can read as hype, so let me just say the plain version. This is the most exciting time of my life to be alive and making things. Not because the tools are impressive, though they are, but because of what they do to the gap between a person and what that person can build. The gap got small. A single builder with taste and judgment and a clear head can now reach the scale that used to require a team, and can keep the whole thing coherent because it is still one mind directing it.

The suit is real. It fits. And the strange, wonderful catch is that it makes the human inside it matter more, not less, because everything it cannot do, deciding what is worth building and knowing when it is right, is suddenly the only thing left to do.

If you want the method I run inside the suit, it is [an AI agent workflow that holds up](/2026/06/02/ai-agent-workflow-for-software-engineers/), and the book-length version is [AgentSpek](/books/agentspek/), free here. For how I keep the whole expanding system legible instead of overwhelming, that is the larger idea: [coherent complexity](/coherent-complexity/).]]></content:encoded>
      <pubDate>Wed, 03 Jun 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/03/agent-mode-iron-man-suit/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/agent-mode-iron-man-suit.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>I Rebuilt This Whole Site in Agent Mode</title>
      <link>https://joshuaayson.com/2026/06/03/rebuilt-my-site-in-agent-mode/</link>
      <description>This site was rebuilt from scratch by directing an AI agent, then migrated off cPanel onto AWS S3 and CloudFront. Here is what that actually looked like, the parts that worked, and the day a deploy script quietly deleted production.</description>
      <content:encoded><![CDATA[The site you are reading was rebuilt from scratch by directing an AI agent, and then moved off shared hosting onto AWS. I did not type most of it. I directed it. That distinction is the whole story, so let me be concrete about what it actually looked like, because the honest version is more useful than the brochure.

## The starting point was WordPress on cPanel

Before this, the site was WordPress on cPanel, the way a lot of personal sites are. It worked, in the sense that it was up. It was also slow, heavy, a moving target for security updates, and a place where every change meant fighting a theme and a stack of plugins to do something a flat file could do better. I wanted a static site: plain HTML and CSS served fast, with the content living as files I own instead of rows in a database I have to babysit.

So the goal was two things at once. Rebuild the site on a modern static stack, and migrate the hosting off cPanel and onto AWS. Either one is a project. Doing both, solo, would have been a month of evenings a couple of years ago. It was not.

## What "agent mode" actually meant here

Agent mode is letting the AI do the task, not the keystroke. I did not ask it to write a function. I handed it the codebase and a destination: build this in Astro, keep the content as markdown, make it fast, match this design sense. Then it read the existing structure, made changes across many files at once, ran the build, read the errors, and fixed them, and surfaced when it was stuck or when a real decision was mine to make.

My job moved up a level. I was not writing the components. I was deciding what the site should be, reviewing the diffs, catching the architectural choices that would cost me later, and saying yes or no. The cost of producing the code dropped close to zero. The thing that did not drop, the thing that became more important, was judgment: knowing what to build, and knowing when the agent had done something that looked right and was wrong.

That is the part the hype skips. Working this way is not less engineering. It is more of the engineering that matters and less of the typing that does not.

## The migration, and the antifragile habit

Moving from cPanel to AWS meant rebuilding the serving layer too: the site is now static files in an S3 bucket, served through a CloudFront distribution, with the caching and the redirects and the security headers all defined as configuration instead of clicked into a control panel. The agent did the bulk of the wiring. I did the part you cannot delegate, which was deciding how it should fail.

That phrase matters more than it sounds. The move taught me as much as it migrated. Doing it well meant naming the failure modes in advance and rehearsing them, instead of discovering them in production. What happens when a deploy is incomplete. What happens when a cache header is wrong. What happens when a path that worked on the old host does not resolve the same way on the new one. The platform itself kept nudging me toward the same habit: assume the part will fail, and build so that when it does, you already know what happens next.

## The day a deploy script deleted production

Here is the part I want to keep in, because it is the real lesson and not the marketing one.

An agent wrote a deploy script. It was good. It built the site, synced the files to S3, and cleaned up anything stale so the bucket matched the build exactly. That last behavior, deleting whatever was not in the new build, is correct right up until the build comes up short. One day a build failed partway through, produced an incomplete set of files, and the script did exactly what it was told: it made the live site match the incomplete build, which meant deleting most of the images from production.

Nothing about that was the agent being dumb. The script was logical. The bug was that a destructive operation was coupled to an assumption that the build was always complete, and nobody, human or machine, had questioned that assumption until it failed.

The recovery is the point. The images were never really lost, because the source of truth was the repository on my machine, not the bucket. I pushed them back up with a sync that only adds and never deletes, cleared the cache, and the site was whole again in a few minutes. Then I did the thing the incident was actually asking for: I changed the deploy so a bad build can no longer reach a destructive step, and so asset uploads only ever add. The failure became a permanent improvement to the system, which is the only good thing a failure is for.

I caught it, fixed it, and hardened it, and the agent did most of the typing for all three. That is the loop working as intended. Trust it to do the work. Do not trust it to be right. Keep a source of truth it cannot touch, and keep the irreversible operations behind a gate.

## It is still changing

The site is not finished, and I do not want it to be. It is a place I keep rebuilding in the open, because the tools keep getting better and because the practice of working this way is itself the thing I am trying to learn. What used to be a month of evenings is now an afternoon, and the bottleneck has moved entirely to taste and intent and verification, which is exactly where I want it.

If you want the method underneath this, I wrote it down: [an AI agent workflow that actually holds up](/2026/06/02/ai-agent-workflow-for-software-engineers/), and the longer version in [AgentSpek](/books/agentspek/), free to read here. And if you want the philosophy underneath the method, it is all one idea: [making a complex system legible enough to live inside](/coherent-complexity/), whether the system is a cloud platform, a codebase, or a life.]]></content:encoded>
      <pubDate>Wed, 03 Jun 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/03/rebuilt-my-site-in-agent-mode/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/rebuilt-my-site-in-agent-mode.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>What Is Autonomous Mode? And When to Actually Trust It</title>
      <link>https://joshuaayson.com/2026/06/02/what-is-autonomous-mode/</link>
      <description>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. Here is what that means, how it differs from agent mode, and where the real risk lives.</description>
      <content:encoded><![CDATA[If [agent mode](/2026/06/02/what-is-agent-mode/) is you directing an AI through a task one step at a time, **autonomous mode is letting it run the whole loop without you in each step.** You give it a goal. It plans, acts, checks its own work, and repeats, until the task is done or it hits something it cannot get past. You come back to a result, not a series of approvals.

That is the promise. It is also where the term gets oversold, so let me be precise about what it actually is and where it actually works.

## The difference from agent mode is the leash

In agent mode you are in the loop. The agent makes a change, you review the diff, you send it again. There is a human checkpoint between each step.

In autonomous mode you move the checkpoint to the end. The agent runs many steps on its own: write the code, run the tests, read the failure, fix it, run again, and only surfaces when it finishes or gets stuck. The leash is longer. Sometimes there is no leash between start and finish at all.

The capability is the same underneath. What changes is how much you let it do before you look.

## Where it genuinely works

Autonomous mode shines on tasks that are **well-specified and cheaply verifiable**, where the agent can tell on its own whether it is making progress.

- Running a test suite to green: write, run, read the failure, fix, repeat. The tests are the judge.
- Mechanical migrations across many files where success is checkable.
- Long, boring loops you would never want to babysit: dependency bumps with a passing build as the gate, large-scale renames, format conversions.

The common thread is a tight, automatic feedback signal. When the agent has a reliable way to know "am I right yet," it can run the loop without you. When it does not, it wanders.

## Where the risk lives

The danger is not that the agent does nothing. It is that it does a lot, confidently, in the wrong direction, because nothing stopped it.

Two failure modes to respect. First, **a bad signal:** if the test it is optimizing toward is weak, it will happily satisfy the weak test and produce something wrong. Second, **blast radius:** an autonomous loop with the power to touch production, delete data, or push changes is a different risk class than one confined to a branch. The fix is not to avoid autonomy; it is to give autonomy a sandbox and a real verification signal, and to keep the irreversible actions behind a human.

## How to use it without getting burned

Start narrow. Let it run autonomously on things you can throw away or easily revert: a branch, a scratch environment, a test loop. Watch what it does over a few runs before you widen the leash. Keep the destructive, irreversible operations gated behind you no matter how good it gets. Autonomy is a dial, not a switch, and the skill is knowing how far to turn it for a given task.

I go deeper on all three modes, conversational, agent, and autonomous, in [AgentSpek](/books/agentspek/), free to read here. And if you want the everyday version, [an AI agent workflow that holds up](/2026/06/02/ai-agent-workflow-for-software-engineers/).]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 17:30:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/what-is-autonomous-mode/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/what-is-autonomous-mode.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>An AI Agent Workflow for Software Engineers That Actually Holds Up</title>
      <link>https://joshuaayson.com/2026/06/02/ai-agent-workflow-for-software-engineers/</link>
      <description>A practical, repeatable workflow for building software with an AI agent: specify, delegate, verify, record. The loop I actually run every day, with the parts that keep it from turning into slop.</description>
      <content:encoded><![CDATA[A lot of advice about working with AI agents stops at "just ask it to build the thing." That works for a demo and falls apart on a real codebase. Here is the workflow I actually run, day in and day out, on production systems.

It has four moves: **specify, delegate, verify, record.** None of them is glamorous. Together they are what separates agentic development from generating slop.

## 1. Specify before you delegate

The agent is only as good as the intent you hand it. Vague in, vague out. So the first move is not typing a prompt, it is getting clear on what you want.

For anything beyond a trivial change, I write the intent down: the outcome, the constraints, the parts that are non-negotiable. In a repo I keep a `CLAUDE.md` that tells the agent how this project works, what conventions to follow, and what not to touch. That file does more for output quality than any clever prompt, because it makes my standing intent permanent instead of repeating it every session.

## 2. Delegate the whole task, not the keystrokes

Once the intent is clear, hand the agent the *task*, not a line. "Add rate limiting to the payments endpoint and update the tests" is a task. Let it read the codebase, make the change across files, and run the suite. Resist the urge to micromanage the implementation. You set the destination; it drives.

This is where the speed comes from. The cost of writing the code drops to near zero. Your attention moves up a level.

## 3. Verify like you do not trust it

This is the step people skip, and it is the one that matters most. **AI-generated code can pass every test and still be wrong.** So verification is not a formality.

I read the diff. I run the tests. For infrastructure, I check the actual deployed behavior, not just that the command exited zero. When I moved a site to a private S3 origin recently, the agent's change was correct except for one thing it could not have known without checking: the new origin did not serve directory index files, so every subpage would have broken. I caught it because I verified the live behavior, not the build log. Trust the agent to do the work. Do not trust it to be right.

## 4. Record what you decided

The last move is the one that compounds. When you make a real decision, write down why. I use short architecture decision records for the project and a journal for my own process. It sounds like overhead. It is the opposite: it turns each session into something the next session, and the next agent, can build on instead of relearning.

## Why the loop holds

Specify, delegate, verify, record. The first and third steps are where your judgment lives, and they are exactly the steps an agent cannot do for you. That is the point. The workflow does not replace your engineering; it moves it to where it is worth the most, deciding what to build and confirming it is right, and hands the typing to the machine.

If you want the full version of this, I wrote [AgentSpek](/books/agentspek/), a book on building this way, free to read here. See also [what agent mode actually is](/2026/06/02/what-is-agent-mode/) and [AI-Assisted Development](/ai-development/) for how I apply it day to day.]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/ai-agent-workflow-for-software-engineers/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/ai-agent-workflow-for-software-engineers.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Making Complexity Visible: You Cannot Simplify the Ocean, Only Chart It</title>
      <link>https://joshuaayson.com/2026/06/02/making-complexity-visible/</link>
      <description>When a system gets too big to hold, almost everyone reaches for the same move: make it simpler. It is the wrong move. You cannot simplify the ocean. You can only chart it. This is about the difference between simplicity and legibility, why decisions quietly migrate to whoever holds the context, and how to make a complex system visible enough to navigate without pretending it is small.</description>
      <content:encoded><![CDATA[Here is the first move almost everyone makes when a system grows too big to hold. They try to make it simpler. Flatten it, hide it, wrap it, abstract it until it fits inside one tired head at the end of a long day.

I made that move for years. It is the wrong one, and understanding why it is wrong is the most useful thing I have learned about building anything large.

You cannot simplify the ocean. You can only chart it.

## Two Kinds of Complexity

Start with the honest part. Some complexity is junk. Fred Brooks called it accidental complexity back in 1986: the mess we make ourselves, the tangle that exists only because nobody cleaned it up. Dead code. A config that needs three files to say one thing. A process with a step that made sense in 2019 and survives out of pure habit. Cut all of that. Cut it without mercy. The world is better with less of it and you will never miss it.

But under the junk there is another kind, and Brooks named that one too. Essential complexity. The complexity that lives in the problem itself. A payment system is genuinely hard because money is genuinely hard. A distributed system is genuinely hard because the network genuinely lies to you. A family is genuinely complicated because people are. You cannot refactor that away. It is not a mess. It is the thing.

The mistake is treating the essential kind like the accidental kind. You keep reaching for the delete key on something that will not delete, and every time you fail you feel a little more like the problem is you. It is not you. You are trying to drain the sea with a cup.

The ocean does not get smaller because you wish it. It does not owe you a pond. So the real question stops being *how do I make this small enough to hold* and becomes something better: *how do I learn to see it whole without pretending it is small.*

That is legibility. And it is a different craft than simplicity entirely.

## A Chart Is Not a Smaller Ocean

A nautical chart does not shrink the sea. The water is exactly as deep, the rocks exactly as sharp, the storms exactly as indifferent as they were before anyone drew a line. What the chart changes is you. It lets one human being stand on a deck and hold a piece of the ocean in their mind, enough of it to make the next good decision, and the one after that.

Korzybski said the map is not the territory, and people usually quote him to warn you off the map. I read it the other way. Of course the map is not the territory. That is the whole point of the map. The territory is too much. The map is the part of the territory a human can carry.

Legibility is when a system shows you its own state before you have to go hunting for it. Not when you *can* answer a question about it if you know the question and where to dig. When you can glance and know. The distance between those two is the distance between querying the sea and reading it.

James Scott used the word legibility as a warning. He showed how states flatten messy living things into grids and ledgers so they can tax and control them, and how much gets destroyed in the flattening. He was right, and the danger is real, and it is the exact danger I am not talking about. The flattening he feared makes the territory legible to a distant ruler by killing whatever does not fit the grid. I mean the opposite motion. Legibility for the navigator, not the king. A chart you make so you can move through the thing wisely, not a grid you impose so you can pretend it is simpler than it is. The first keeps the danger on the page. The second paints over it.

## Where the Decisions Go

Here is what illegibility actually costs, and it is far more than slow work.

When a system is hard to see, decisions quietly migrate to whoever happens to hold the context. Not the right person. The legible-to person. The one who set it up, who remembers, who has the whole tangle loaded in their head because they have been carrying it for two years.

You have met this person on every team. They are the only one who really understands the deploy. The only one who knows why the numbers in that report never quite match. The only one who can say whether the system is actually healthy or just looks healthy from the outside. They are not hoarding anything. They simply *became* the map because no other map exists, and now the system cannot think without them. They cannot take a real vacation. The team's intelligence is bottlenecked on one person's memory and one person's availability.

Multiply that across a company and you get an organization whose real intelligence is far smaller than the sum of its people, because most of what it knows is trapped in a handful of heads, illegible to everyone else. The same thing happens to a household where one person holds the whole budget in their gut, or a project where the true status lives only in a lead's quiet anxiety. The state is real. It is just not visible. So the circle of people who can think well about it stays small, and stays tired.

Make the system legible and you widen that circle. That is the entire payoff. Not a prettier screen. A larger number of people who can hold the whole and reason about it. Coordination, stripped down to the bone, is mostly a group of people managing to look at the same picture at the same time.

## Giving the System a Face

So what do you actually build. You give the system a face.

I have spent a lot of years building these surfaces. Live views of systems that used to answer only to the person who built them. Maps of processes that used to live in somebody's head. Dashboards, when the word does not embarrass me, though the word undersells the thing. The idea underneath all of them is the same, and it is almost too simple to say out loud: stop making people query for state, and let the state be ambient.

Ambient is the key word. You want the state of the system to register the way it registers when a room goes quiet. Before you have consciously checked anything, before you have run a single query, you already feel that something is off. A good live view of a running system does that. You walk past it and your body knows the shape of the day. The knowledge stops being something you go and fetch and becomes something you simply have, the way you have the weather.

And the thing that changes when you build it well is never mostly technical. It is that people who do not own the system can suddenly tell when it is wrong. Conversations get shorter, because nobody has to reconstruct the picture before the real discussion can start. The thing becomes a shared object, and a shared object is half of what coordination even is. You did not make the system simpler. You made it legible, and legibility did the rest.

## Coherence Is Not Simplicity

This is the turn the whole essay has been walking toward, so let me say it plainly.

The goal is not a simple system. The goal is a coherent one.

Simplicity throws information away. Coherence keeps the information and arranges it so a human can hold it. A simple map of the ocean is a blue rectangle, and it will get you killed. A coherent chart has every rock and current and depth still on it, all the danger intact, organized so that a person on a moving deck can read it in the dark and live. Simplicity lies to make you comfortable. Coherence tells the truth in a shape you can use.

I have started calling the thing I am chasing *coherent complexity*. The state where a system stays as complex as it truly is, and stays understandable enough to navigate anyway. You do not pretend the sea is a pond. You become a navigator. That is the only honest relationship with anything genuinely hard, and once you have the phrase for it you start seeing it everywhere, or seeing its absence.

There is even a law for why simplicity fails here. Ashby, in early cybernetics, called it requisite variety: to control a system, your model of it has to be at least as rich as the system itself. Shrink your model below the complexity of the thing and you lose your grip on it. You cannot out-simple a complex world. You can only build a richer way of seeing it. The chart has to carry enough to match the sea. That is not bureaucracy. That is survival.

## The Same Move, Everywhere

Once you have the move, you cannot stop seeing it, and it stops being only an engineering trick.

A life is an illegible system. The state is real and it is smeared across your calendar, your body, your bank account, your relationships, your half-finished intentions, and almost none of it is visible at once. Most people run a life the way a tired team runs a system nobody charted: by holding it all in an anxious head and hoping. I keep my own time by the stars and the decans for exactly this reason. Not because the cosmos sends instructions, but because a slow steady cycle is a chart for a year, a way to make a long sprawling stretch of time legible enough to move through on purpose instead of drifting.

A family is an illegible system. A portfolio is an illegible system. A company is a thousand of them stacked on each other. The move is identical every time. Find the place where important state is real but invisible, and give it a single surface where a human can hold it whole. Cluster, release, codebase, quarter, marriage, life. Different oceans. The same craft of the chart.

## The Navigator's Art

So here is where I have ended up, after years of reaching for the delete key on things that refused to delete.

You do not conquer a complex system. You do not shrink it down to where it stops being itself. You learn to read it. You build the chart that lets a human stand in front of the whole moving thing and know, in seconds, where they are and what to do next. And then you hand the chart to the next person, and the next, until the knowledge that used to live in one exhausted head lives out in the open where anyone can use it.

The sea never gets smaller. That was never the deal. The deal is that you can become someone who reads it. A navigator is not braver than a drowning person. They can just see. That seeing is the whole of the freedom, and it is buildable, and building it is some of the best work there is.

That is what I mean by making complexity visible. Not making it simple. Making it legible enough to love.

Dip the oar. The other end rises. Reach for the next dip. Let's go.

---

## Related reading

- [DevOps Beyond Automation: What Compounds in a 15-Year Engineering Career](/2026/05/27/devops-beyond-automation/): the deeper goal under every tool I build: systems that change without breaking
- [Living with Antifragility: How I Build Systems and a Life That Gain from Disorder](/2026/05/30/living-with-antifragility/): why you keep the danger on the page instead of painting over it
- [AWS Is Math, Kubernetes Is Physics](/2026/05/31/aws-is-math-kubernetes-is-physics/): the grand and the granular, held in one view
- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/): keeping time by the stars as a chart for a year

*Sources for the ideas borrowed here: Fred Brooks on essential versus accidental complexity (No Silver Bullet, 1986); Alfred Korzybski on the map and the territory (Science and Sanity, 1933); James C. Scott on legibility and the state (Seeing Like a State, 1998); W. Ross Ashby on requisite variety (An Introduction to Cybernetics, 1956).*]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/making-complexity-visible/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/making-complexity-visible.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Claude vs Copilot for DevOps: A Practitioner&apos;s Comparison</title>
      <link>https://joshuaayson.com/2026/06/02/claude-vs-copilot-for-devops/</link>
      <description>I used GitHub Copilot in VS Code for a long time, always with Claude underneath. Then I moved most of my work to Claude Code. Here is the honest comparison for DevOps and infrastructure work, from someone who ships with both.</description>
      <content:encoded><![CDATA[I used GitHub Copilot in VS Code for a long time, and for most of that time I had Claude running underneath it. Then I moved the bulk of my work to Claude Code. This is the comparison I wish I had read before I made that move, written for DevOps and infrastructure work specifically.

The short version: for line-by-line completion they are close, and for **agent mode**, the kind of work where you direct a model to change many files and verify itself, Claude Code has been the stronger tool for me. Here is why, with the parts that actually matter for infrastructure work.

## They are aiming at different jobs

GitHub Copilot started as an autocomplete and grew outward. Its center of gravity is still the editor: you are typing, it is suggesting. That is genuinely useful, and inside VS Code it is well integrated.

Claude Code starts from the other end. It is a terminal-native agent built to take a task, read the repository, make the change across files, run the commands, and report back. The editor is not the center; the task is.

For DevOps work that distinction is the whole game, because infrastructure changes are rarely one line in one file. A rate limit, a new origin, a CDK change, a CI pipeline edit, each of those touches several files and a test or a deploy. The tool that holds the *task* beats the tool that holds the *line*.

## Where each one wins

**Copilot wins** when you are heads-down writing code in the editor and want fast, low-friction completion. It is also the path of least resistance if your whole team already lives in VS Code and you want one consistent surface.

**Claude Code wins** when the unit of work is bigger than a function: a multi-file refactor, standing up infrastructure, wiring CI, migrating config across a repo. It reads the codebase as context, makes coordinated changes, and runs the verification step itself. For the way I work, that is most of the day.

## A concrete DevOps example

I recently moved a static site's CloudFront distribution to a private S3 origin behind an Origin Access Control, with a basic-auth gate at the edge. In Claude Code I described the end state. It changed the origin, wrote the bucket policy, attached the function, and flagged the gotcha that bites everyone on this setup: the S3 REST endpoint does not auto-serve directory index files the way the website endpoint does, so subpaths break unless you rewrite them. That is the kind of cross-file, knows-the-trap work where the agent earns its place.

Copilot would have helped me type each of those files faster. Claude Code did the task and showed me the diff.

## What I actually use

Both, honestly, but the balance has shifted hard toward Claude Code for anything bigger than a single edit. If you do DevOps and your work is mostly multi-file changes and infrastructure, that is the one I would start with. If you spend your day inside a single service writing functions, Copilot's editor integration is a real comfort.

If you want the longer argument for working this way, I wrote a book on it: [AgentSpek](/books/agentspek/), free to read here. For how it feels in practice, [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/), and for [what agent mode actually is](/2026/06/02/what-is-agent-mode/) if the term is still fuzzy.]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 16:30:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/claude-vs-copilot-for-devops/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/claude-vs-copilot-for-devops.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Run Your Life Like Software</title>
      <link>https://joshuaayson.com/2026/06/02/life-ops-running-your-life-like-software/</link>
      <description>Life Ops is running your life as a deliberate system, designed the way you design software: observe before acting, choose responses over reactions, build systems that make the good path the easy one, and version the whole thing like code.</description>
      <content:encoded><![CDATA[Life Ops is running your life as a deliberate system, designed the way you would design software. Not optimizing yourself into a machine, and not turning every morning into a dashboard. The opposite. It is building the smallest set of systems that make the good path the easy path, then versioning them like code: observe, choose, act, iterate.

I came to this the embarrassing way. I spend my days building and operating software systems, where I would never ship without a test, never deploy without a way to roll back, never let a recurring failure go un-investigated. Then I would close the laptop and run my actual life with none of that discipline. Same mistakes on a loop. No record of why. Reacting to whatever was loudest. At some point the gap got too obvious to ignore. The care I gave a codebase was more than the care I gave the one system I cannot redeploy.

So I started treating my life like the thing it actually is: a complex system I have to operate, whether or not I do it well.

## The four moves

Life Ops runs on four moves, and none of them is glamorous. That is the point. Glamorous does not survive a bad week.

**Observe before acting.** Most of what goes wrong in a life is not a hard decision made badly. It is an easy reaction made automatically, before any decision happened at all. The first discipline is just to see the moment you are in before you move inside it. To put a gap between the trigger and the response, and to actually look into that gap.

**Choose responses over reactions.** A reaction is the system running you. A response is you running the system. The whole game is moving as much of your life as possible from the first column to the second, one situation at a time. You will never get all of it. You can get a lot more than you have now.

**Build systems that make the good path easy.** This is the engineering move, and it is the one people skip because they would rather rely on willpower and then feel virtuous about it. Willpower is a bad dependency. It is unreliable, it degrades when you are tired, and it fails exactly when the stakes are highest. The better move is to change the environment so the good path costs less. Lower the friction on what you want to do, raise it on what you do not, and stop spending discipline on problems that design could have solved.

**Evolve continuously.** Version, review, iterate. A life run this way keeps a changelog. You look back on the week and ask what repeated, what you avoided, where you made progress, and you adjust the system instead of just resolving to try harder. Trying harder is not a plan. A better system is.

## Observe. Breathe. Choose. Act.

That is the whole thing compressed to four words, and I keep it where I can reach it.

Observe: see the situation without immediately becoming part of it. Breathe: take the half second that turns a reaction into a decision. Choose: pick the response on purpose, against what you actually value, not what the moment is pulling you toward. Act: then commit to it cleanly, without relitigating it for the next hour.

It sounds simple because it is simple. Simple is not the same as easy. The four words are a checklist for the exact instant where most of my old mistakes used to live, the quarter second between something happening and me doing the automatic thing.

## Why "like software" and not "like a machine"

I want to be careful here, because "optimize your life" is a genre I have no interest in. The goal is not efficiency. The goal is not turning yourself into a tighter, faster version of a machine.

A life is a complex system, which means its behavior comes from how the parts interact, not from the parts themselves. You cannot make it simple without deleting the thing that made it yours. So Life Ops does not try to simplify your life. It tries to make it legible: clear enough that you can see what is happening, see how it connects, locate yourself in it, and tell what your next move does to the rest of it. That is what good software discipline actually gives you. Not speed. Operability. The ability to run the system on purpose instead of being surprised by it.

This is why the software framing works where the machine framing fails. Software, done well, is built to be understood, changed, and recovered. It expects failure and plans for it. It keeps a history so the next version is smarter than the last. Turn that on a life and you do not get a robot. You get a person who can finally read their own system.

## The daily loop

The mechanics are almost boring, which is how you know they will hold.

Capture, lightly: the trigger, the feeling, the action, the outcome. Four columns, no essays. Most days that is enough. Then, once a week, read back the captures and look only for repetition. The repeated tension is the real one. The repeated avoidance is the real problem. The repeated win is the system to protect. Pattern is the signal; a single bad day is just noise.

That weekly read is the whole engine. It is a retrospective, the same thing a good team runs after a release, turned on yourself. It is where the changelog gets written and the next version of your systems gets designed. Skip it and Life Ops decays into a journaling habit. Keep it and the captures stop being a diary and start being instrumentation.

## Where the new tools fit

I do this alongside AI now, which makes the review faster and sharper. An honest second reader can scan a month of captures and tell me what I clearly cannot see, where I keep stepping on the same rake. That is a real edge, and it is exactly the kind of pattern work machines are good at.

But I keep the judgment human, deliberately. The tools can surface the pattern. They cannot decide what kind of person I am choosing to be in response to it. That decision is the entire point of the practice, and it is not one I want to delegate. Observe, the machine can help with. Choose stays mine.

## Living in the prompt

Underneath the mechanics there is a spirit, and it came out of an experiment. For a while I tried to live the way I work when I am deep in agent mode. I called it living in the prompt. You write the instruction, you watch what comes back, you do not take the result personally, you refine, you run it again. The loop only works if you bring two things to it. Fearlessness, because a prompt you are afraid to send teaches you nothing. And no ego, because the second you need the first output to prove you were right, you stop reading what actually came back.

Turned on a life, that is a strange and freeing way to operate. A bad day stops being a verdict on you and becomes an output to read. A mistake stops being something to hide and becomes information for the next iteration. You act, because action is the only thing that returns a signal, and you hold the result loosely, because the result is data, not identity. Fearlessly, and without ego. That posture is what Life Ops actually runs on. The four moves are just what it looks like when you keep your hands on the keyboard.

## Where it sits

Life Ops is [Coherent Complexity](/coherent-complexity/) applied to the daily operation of a self. The umbrella idea is that complex systems should be made legible rather than simple, and your own life is the most important complex system you will ever have to run with no manual. This is the operating discipline underneath the rest: the same engineering care I give a production system, turned on the one that matters most.

You do not need my version of it. You need four moves and the honesty to keep a changelog. Observe before you act. Choose your response. Build the systems that make the right thing easy. And review the week like it was a release, because it was.]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/life-ops-running-your-life-like-software/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/life-ops-running-your-life-like-software.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>What Is Agent Mode? A Working Engineer&apos;s Definition</title>
      <link>https://joshuaayson.com/2026/06/02/what-is-agent-mode/</link>
      <description>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. Here is what it actually is, how the loop works, and when to reach for it, from someone who ships production systems this way.</description>
      <content:encoded><![CDATA[If you have heard the term "agent mode" and gotten a different answer every time you asked, here is a plain one.

**Agent mode is when you stop typing code and start directing an AI that reads your codebase, makes the change, runs the tests, and reports back.** You describe the outcome. The agent does the work across as many files as the task needs, checks itself, and tells you what it did. You review, correct, and send it again.

That is the whole idea. The rest is detail. But the detail is where most of the confusion lives, so here it is.

## It is not autocomplete, and it is not chat

Three things get lumped together and they are not the same.

**Autocomplete** finishes the line you are already writing. You are still the one holding the whole task in your head, typing it out, one suggestion at a time. The AI is a faster keyboard.

**Chat** answers a question. You ask how to configure a load balancer, it explains, you go apply the explanation yourself. The AI is a smarter search engine.

**Agent mode** takes the task off your hands. You say "add rate limiting to the payments endpoint and update the tests," and it reads the relevant files, writes the change, runs the suite, and comes back with a diff. You were never in the editor. You were directing.

The difference is not speed. It is who holds the task. In autocomplete and chat, you do. In agent mode, the agent does, and you hold the *intent*.

## The loop is specify, generate, verify

Traditional coding has a loop: write, compile, test, repeat. Agent mode has a different one: **specify, generate, verify, specify**.

- **Specify.** You describe what you want clearly enough that an agent can act on it. Vague intent produces vague output, so this is where the real work moves.
- **Generate.** The agent reads context and produces the change, often across several files at once.
- **Verify.** It runs the tests, or you read the diff, or both. AI-generated code can pass every test and still be wrong, so verification is not optional.
- **Specify again.** You correct course and send it back.

Your hours stop going into typing and start going into the first and third steps: being precise about what you want, and checking that you got it.

## A concrete example

A real one from my own work. I needed to stand up an AWS service behind CloudFront with a private S3 origin and a basic-auth gate. The old way: read the docs, write the CDK, wire the origin access control, debug the bucket policy, fix the cache behavior, repeat.

In agent mode I described the end state: private bucket, served only through this distribution, gated by a password at the edge. The agent wrote the configuration, explained the origin-access-control wiring, and flagged the one gotcha that breaks these setups (the REST endpoint does not serve directory index files the way the website endpoint does). My job was to decide the design and verify the result, not to remember the order of the CDK arguments.

That is the shape of it. The cost of writing the configuration dropped to near zero. The cost of *deciding what to build and confirming it was right* became the whole job.

## When to reach for it, and when not

Agent mode earns its keep when the task is well-specified and verifiable: scaffolding, refactors across many files, boilerplate, infrastructure, tests, migrations. Anywhere you can describe the outcome and check it cheaply.

It is the wrong tool when you do not yet know what you want. If the problem is still fuzzy in your own head, no amount of delegation helps, because you cannot specify what you have not figured out. That part is still yours.

## Where to go next

This is the short answer. If you want the long one, I wrote a whole book on working this way: [AgentSpek](/books/agentspek/), free to read here in full. For how it changes the *feel* of the work, see [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/), and for how I actually build with it day to day, [AI-Assisted Development](/ai-development/).]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/what-is-agent-mode/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/what-is-agent-mode.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>How to Live Coherently Inside Complex Systems</title>
      <link>https://joshuaayson.com/2026/06/02/coherent-complexity/</link>
      <description>Coherent complexity is what you get when a complex system is made legible without being made simple. You do not reduce it. You map it, until you can move through it on purpose. A field guide to the practice, and the idea behind everything else I build.</description>
      <content:encoded><![CDATA[Coherent complexity is what you get when a complex system is made legible without being made simple. You do not reduce it. You do not flatten it into a slogan and pretend the lost detail did not matter. You map it, patiently, until you can move through it on purpose. That is the whole idea, and almost everything else I build is one version of it.

I want to be precise, because the phrase invites a lazy reading. People hear "coherent complexity" and assume I mean "complexity made simple," as if the goal were to take something tangled and hand you the three bullet points that replace it. That is the opposite of what I mean. The three bullet points are usually a lie. They feel like understanding and they cost you the part of the system that was actually doing the work. Coherence is not simplicity. Coherence is when the parts hold together in a way you can see and act from, with the complexity still intact.

So this is a field guide. It is the idea behind the apps, the books, the journal, the films, and the frameworks, and I would rather state it plainly once than let it stay implied across thirty scattered projects. If you only read one thing of mine, read this one.

## The problem with "just simplify it"

Here is the move everyone reaches for when a system gets hard. Simplify. Reduce the variables. Find the one metric that matters. Tell a clean story. It is good advice for a lot of things, and it is terrible advice for the things I care about most, because the systems I care about are complex in a specific, technical sense: their behavior comes from the interaction of the parts, not from the parts themselves. Pull a piece out to examine it and the behavior you wanted to understand is no longer in the room.

A market is like this. A body is like this. An organization, a creative process, a single human life across a year. You cannot understand any of them by isolating a variable, because the variable does not have the property you are studying. The property lives in the relationships. When you simplify a complex system, you are not compressing it. You are deleting the relationships and keeping the labels, then acting surprised when the labels do not behave like the system did.

I have watched this fail in every domain I work in. In finance, the person who reduces a market to one indicator gets run over the first time the relationships shift, which they always do. In health, the person who reduces a body to one number optimizes the number and feels worse. In software, the team that reduces a codebase to a tidy diagram ships the diagram and then spends a year fighting the parts the diagram left out. The reduction was not wrong because it was incomplete. Every map is incomplete. It was wrong because it deleted the exact thing it claimed to explain.

So I stopped trying to make complex things simple. The goal changed. The goal is not fewer parts. The goal is a system you can see clearly enough to live inside, with its real number of parts.

## Legibility beats simplicity

The word I use for the goal is legibility. A legible system is one you can read. You can look at it and tell what is happening, what is connected to what, where you are standing, and what your next move does to the rest of it. Legibility does not require fewer parts. It requires the parts to be arranged, named, and lit well enough that you can follow them.

This is a real distinction, not a word game. A subway map is legible and complex at the same time. It does not lie to you about how many lines there are or pretend the city is simpler than it is. It makes a genuinely complicated network readable by getting the relationships right and throwing away only the things that do not help you ride a train, like the exact geography between stops. You can hold the whole system in your head and act from it, and it never once simplified the system. It made it coherent.

That is the target. Not "what is the one thing," but "how do I render this whole thing so a person can actually use it." When I say I want to make complexity coherent, I mean I want to build the subway map for domains that do not have one yet. Time. Power. The self. Creative work. A life.

Legibility has a property that simplicity does not, and this is why I bet on it. Simplicity degrades when the world gets more complicated, because a simple model of a complicating world drifts further from the truth every day. Legibility improves, because a good rendering of a complex system gets more valuable exactly as the system gets harder to hold in your head unaided. The more complex the world becomes, the more a coherent map is worth. I am building for that direction, on purpose, because that is the direction the world is going.

## Coherence is a map you can act from

Let me define coherence operationally, because "holds together" is too soft to build on.

A system is coherent to you when four things are true at once. You can see the parts. You can see how they connect. You can locate yourself inside it. And you can predict, roughly, what your next move does to the rest. That is it. When those four hold, you are not simplifying the system and you are not drowning in it. You are oriented. You can act with intent instead of reacting to whatever is loudest.

Most of the suffering I see around complex systems is a failure of one of those four, and naming which one is most of the cure. People who feel lost in their finances usually cannot see the parts. People who feel powerless in a conflict usually cannot locate themselves in the arena, so they fight the wrong fight in the wrong room. People who burn out usually cannot predict what a given move costs them downstream, so every move feels equally urgent. The complexity is not the problem. The illegibility is the problem, and illegibility is fixable without removing a single moving part.

Coherence, then, is not a feeling of calm. It is a working relationship with a complex thing. You can be inside a genuinely chaotic situation and have it be coherent to you, the way a pilot in weather has the instruments coherent even when the sky is not. The sky stays complex. The instruments make it legible. You fly.

## The method: I am a domain cartographer

Here is how I actually do this, and it is where the work stops being philosophy and starts being a craft.

I think of myself as a domain cartographer. I map domains. I mean that in both senses, and I like that the senses rhyme. I map domains of knowledge, the territories of time and power and the body and creative work. And I register and hold actual domains, the web addresses where each map lives, because a map nobody can find is just a private drawing. The two kinds of domain are the same job. Find a territory that people have to live in and nobody has charted well, go in, and come back with something they can use.

When I go into a domain, I bring a specific kit, and I want to describe it literally because it is how the method works.

I bring a flashlight, because you do not light the whole cave at once. That is the mistake that produces the false simplicity I warned about. You stand at the mouth and try to take in the entire system and your brain hands you a comforting summary that is wrong. The flashlight forces honesty. You light one corner. You see what is actually there, in that corner, including the parts that do not fit your theory. Then you move the light. Legibility is built corner by corner, and the discipline is to keep looking at the corner in front of you instead of the summary in your head.

I bring forensics, because complex systems do not tell you how they work, they leave evidence of how they worked. A market leaves prints. A body leaves symptoms and rhythms. A codebase leaves a commit history and a set of scars. A year of your life leaves a journal. The cartographer's job is to read the evidence and reconstruct the relationships that produced it, the way an investigator reconstructs an event nobody filmed. You do not get to interview the system. You get the traces it left, and the traces are enough if you are patient and you do not flinch from the ones that contradict you.

And I leave clues, because I am not the last person who will need this map, and frankly I am not even the last version of me who will need it. So I leave markers. A definition stated plainly. A name for a pattern that did not have one. A cross-link from where you are to where you will want to go next. A journal entry that the future me can use as evidence. The clues are the difference between a map and a memory. A memory dies with you. A map, well marked, lets the next person, or the next agent, or the next morning, pick up where you left off instead of relearning the cave from the mouth.

That is the method, in full. Light one corner. Read the evidence. Mark the trail. Repeat until the domain is coherent enough to live in. It is slow and it is honest and it does not produce slogans, which is exactly why it produces maps you can trust.

## The five domains I have mapped

Coherent complexity is the umbrella. Underneath it are the specific territories I have gone into, each one a complex system that most people experience as noise, each one rendered into something you can stand inside and act from. They look unrelated from the outside. A reader who finds my astrology-flavored timing system and my finance-and-physiology framework and my filmmaking practice might assume they belong to three different people. They are one practice applied to five domains. Here is the map of the maps.

### Time: People of the Stars

The first domain is time, and the system I built for it is [People of the Stars](/what-is-people-of-the-stars/). Time is a complex system we pretend is simple. We act like every day is interchangeable, a flat sequence of identical slots, and then we are confused when the same effort produces wildly different results depending on when we spent it. The relationships are invisible, so the system is illegible, so we fight the calendar instead of reading it.

People of the Stars is the map I made of temporal context. It renders the question "what time is it, really" in a way that goes past the clock, so that when I sit down to work I know what kind of day I am standing in and what that day is good for. It does not simplify time into "just show up every day." It makes time legible enough that I can place a hard task in a day built for hard tasks and a reflective task in a day built for reflection, on purpose, instead of by accident. The complexity stays. The wandering stops.

### Power: Situational Governance

The second domain is power, and the system is [Situational Governance](/situational-governance/). Most conflict and most powerlessness come from one error: fighting the right fight in the wrong arena. You bring a legal argument to an emotional room. You bring an emotional appeal to a procedural process. You try to win a relationship the way you win a negotiation. The fight is illegible because you cannot locate yourself in it, which is failure mode number three from the definition above.

Situational Governance is the map of arenas. It routes a situation to the kind of room it is actually in, so that you can see which rules are running and where you are standing inside them before you make a move. It does not reduce all conflict to one playbook, because one playbook is the disease. It makes the arena legible so you stop spending your strength in the wrong room. The same force, aimed at the right arena, stops bouncing off.

### The self: Hansuru

The third domain is the self, and here I went deepest, because the self is the most complex system any of us has to operate and the one we are given the least instruction for. The framework is Hansuru, and I have written about it from two directions that most people keep separate: finance and physiology. Money and the body. There is a book on it, in manuscript.

I keep money and the body together on purpose, because they are the same kind of system and they fail the same way. Both are complex, both are mostly relationships rather than single numbers, and both punish anyone who reduces them to a single number and optimizes it. The person who optimizes one financial metric goes broke in a way the spreadsheet did not predict. The person who optimizes one health number feels worse in a way the lab did not predict. Hansuru is my attempt to make the personal system, the whole organism of your money and your body and the energy that moves between them, legible enough to run without lying to yourself. Not a diet. Not a budget. A map of the self as a system you can read. I will say more when the book is ready; for now, know that it sits here, under the same umbrella as everything else.

### Creation: Napkin Films

The fourth domain is creative work, and the system is [Napkin Films](/films/). Making things has its own complexity, and the arrival of capable AI made it stranger, not simpler. Suddenly the cost of producing an image, a scene, a film, drops toward nothing, and the bottleneck moves entirely to intent and taste and the legibility of your own process. A lot of people responded to that by generating noise. I wanted to map it instead.

Napkin Films is where I work out what it means to create with these tools on purpose, idea to finished video, with the process visible the whole way. I want to own this corner the way I own the others: not "AI makes content," which is the simplification that produces slop, but a coherent practice for going from a napkin sketch to a real film using large language models and the new generation of tools as instruments rather than slot machines. The complexity of creative work stays. The map is what keeps it from becoming noise.

### The practice: The Decan Log

The fifth is not a separate domain so much as the engine that runs all of them. [The Decan Log](/books/the-decan-log/) is the daily practice, the place where the method actually happens day by day. Each entry is one corner of the cave, lit and recorded. It is where I leave clues for myself, gather the forensic evidence of a life as it is lived, and keep the trail marked so that the maps above stay current instead of decaying into old theories.

A map you never update stops being legible, because the territory moves. The Decan Log is how I keep the whole system honest. It is the smallest unit of the practice, one day of looking at one corner and writing down what was actually there, and it is the reason the larger maps are made of evidence instead of wishful thinking.

## How to live inside it

I said this was a field guide, so let me make it useful to you and not just a tour of my projects. You do not need my frameworks to do this. Coherent complexity is a way of relating to any complex system you are stuck inside, and the move is the same every time.

Stop trying to simplify the thing. That instinct is the enemy and it never quite goes away, so you have to catch it. The moment you feel the relief of "oh, it is really just about X," be suspicious. Real complex systems do not collapse to an X. That relief is usually you deleting the parts you did not want to deal with.

Instead, ask the four questions. Can I see the parts. Can I see how they connect. Can I locate myself in this. Can I predict what my next move does. Whichever one you answer "no" to is your actual problem, and it is a smaller, more tractable problem than "this is overwhelming." Overwhelming is not a property of the system. It is the feeling of illegibility, and illegibility has an address.

Then do the cartographer's work on the part you cannot see. Light one corner instead of the whole cave. Read the evidence the system already left you instead of demanding it explain itself. Mark what you learn so you do not have to relearn it next week. You are not trying to finish the map. You are trying to make the next move legible. That is enough, and it compounds, because every corner you light makes the next one easier to find.

The promise is not calm. Complex systems are not calm and I am not selling you serenity. The promise is agency. When a system is coherent to you, you stop being something it happens to and start being someone who moves through it on purpose. The market still moves, the body still has its weather, the conflict is still hard, the work is still uncertain. But you can read them now. You are oriented. You are flying on instruments instead of praying through the clouds.

## The invitation

I coined the term coherent complexity because I needed a name for the thing all my work is actually about, and naming it is itself the method. A pattern without a name stays invisible, and invisible patterns cannot be shared, built on, or improved. So I named it, and I am leaving this here as the clearest clue I know how to leave: the definition, the method, and the map of where the deeper maps live.

If you came here from one of the territories, from the timing system or the governance routing or the work on money and the body or the films or the daily log, now you can see the shape they share. They are not five hobbies. They are one practice, coherent complexity, applied five times by the same cartographer.

And if you came here first, then this is the mouth of the cave. The flashlight is by the entrance. The evidence is everywhere, because a complex system never stops leaving it. I have marked a few trails already, and I will keep marking more. Pick a corner and start looking at what is actually there. That is the whole craft, and it is available to anyone willing to stop simplifying and start mapping.

I am Joshua Ayson, and this is the idea I am betting my work on. The world is not getting simpler, and the people who pretend it is will keep getting run over by the parts they deleted. The other path is to make it coherent. Not simple. Legible. Good enough to live inside, on purpose, with all of its complexity still in the room.]]></content:encoded>
      <pubDate>Tue, 02 Jun 2026 15:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/06/02/coherent-complexity/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/06/coherent-complexity.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>AWS Is Math, Kubernetes Is Physics: A Symphony of Systems</title>
      <link>https://joshuaayson.com/2026/05/31/aws-is-math-kubernetes-is-physics/</link>
      <description>AWS versus Kubernetes is the wrong question. AWS is math and Kubernetes is physics: two ends of one spectrum, the galaxy and the atom. AWS gives you grand scale but you watch the cost; containers run nearly free but you watch the performance. Here is when to use each, when to use both, and why they become a symphony of systems together.</description>
      <content:encoded><![CDATA[Two disciplines. Same universe. Different scale. One counts, the other moves.

I keep coming back to this. AWS is math and Kubernetes is physics. Similar but different, and once you feel the difference you cannot unfeel it. They are two ends of one spectrum, the galaxy and the atom, and the strange thing is you need both to build anything that lasts.

People treat AWS versus Kubernetes as a fork in the road, a thing you choose between. I think that framing is wrong, and the cleanest way to show why is to stop talking about tools for a minute and talk about two ways of describing the universe.

## AWS Is Math

Math is the language of scale and abstraction. It is clean. It is provable. It is vast in a way that has nothing to do with how much room it takes up on the page. You write a small expression and it describes something enormous.

AWS is the same. Regions and availability zones. Services stacked on services. A load balancer in front of a fleet, a queue feeding a function, a database replicated across the planet, all of it composed out of primitives you never see and never have to build. You are not placing one server. You are drawing the constellations. You are doing grand arithmetic, and the answer always balances.

That is the grandeur of it. Galaxy building. You compose whole systems out of services, and the math just works.

Kant had a word for this feeling. In the Critique of Judgment he splits the sublime in two, and the first kind is the mathematical sublime: the awe you feel before sheer magnitude, the absolutely great, the size of the universe that overwhelms the imagination and can still be reasoned about in numbers. That is AWS exactly. The magnitude is too large to picture, yet you can name it, measure it, and bill it by the hour. The mathematical sublime with a pricing page.

But here is the catch, and you have to say it plainly: math is free to think about, and AWS is not free to run. Every elegant equation has a bill attached. You can architect something beautiful at three in the morning, fall in love with how it balances, and then watch the invoice arrive and remind you that grandeur has a price per hour. So with AWS you watch the cost. Always. That is the discipline the math demands.

## Kubernetes Is Physics

Physics is what happens when the abstraction meets the real world. Matter. Force. Limits. Friction. The math told you what should happen; physics tells you what actually happens once you let it loose in a room with gravity and heat.

Kubernetes is the same. Containers are the atoms. Pods are the particles. Kubernetes is the field they move in, the thing that schedules them, packs them, and keeps them in motion. These are the small, fast, fundamental pieces that everything large is actually made of. The wave components to all that galactic grandeur.

If AWS is the galaxy, Kubernetes is the atom. Same universe, opposite end of the ruler. And the small stuff is where the heat lives.

This is Kant's other sublime. After the mathematical comes the dynamical sublime, the awe you feel before raw power: the storm, the force that could overwhelm you. AWS is magnitude; Kubernetes is power. One is too big to picture, the other is too strong to ignore. And there is a discipline that physics teaches better than anything else. Feynman wrote on his last blackboard, "What I cannot create I do not understand." Containers are where you find out if that is true. You build the atom yourself, you set its limits, you watch it run, and the system tells you in latency and load whether you actually understood it.

Because here is the mirror of the catch: containers can run nearly free, and you have to watch the performance. Physics does not send you a bill. It sends you latency, contention, a noisy neighbor stealing your CPU, a memory limit you set too low. It sends you thermodynamic reality. You can pack the atoms tight and pay almost nothing, but the closer you pack them the more the laws push back. So with containers you watch the performance. Always. That is the discipline the physics demands.

## Similar but Different

Now look at the two side by side, honestly.

Both are systems for organizing complexity. Both reward discipline. Both punish carelessness. The difference is the currency. AWS punishes you in money. Kubernetes punishes you in attention. You spend one to save the other, and the whole art is knowing which trade you are making. The tension is not a flaw in the design. It is the design. It is the same reason I try to [build systems and a life that gain from disorder](/2026/05/30/living-with-antifragility/) rather than ones that only stay still: a little pressure on both sides keeps the whole thing honest and alive.

Hold the pairs up to the light:

Math proves; physics tests. AWS abstracts; Kubernetes embodies. Top-down grandeur; bottom-up matter. Watch the cost; watch the performance.

Same shape, opposite ends. That symmetry is not a coincidence. It is what you get when you build one tool to think big and another to make the small things real.

Einstein found the seam between these two worlds a century ago. In a 1921 lecture he said, "As far as the laws of mathematics refer to reality, they are not certain, and as far as they are certain, they do not refer to reality." Read that again with a cloud bill in your hand. AWS is the certain part. The architecture diagram is clean, the math closes, every box connects to every other box exactly as drawn. Kubernetes is the part that refers to reality, and reality is never certain. The pod gets evicted. The node runs hot. The thing you proved on the whiteboard meets the thing that actually happens in the rack. You need the certainty to plan and the reality to ship.

Plato reached the same crossroads two thousand years earlier and chose the other side. The clean diagram, he would say, is the Form: perfect, eternal, more real than anything you could build. The running system is only its shadow flickering on the cave wall. Einstein would smile and flip it: the shadow is the part that is actually real, and the Form is the beautiful thing that never quite happens. Hold both views at once and you have the whole job. You design toward the Form and you ship the shadow, and the craft is refusing to pretend either one is the entire truth.

And there is a seam where the two worlds touch. Managed Kubernetes, EKS, is literally the galaxy and the atom living in one house. AWS runs the control plane so you do not have to, and your containers move inside it. The math holds the structure; the physics does the work. When you run Kubernetes on AWS you are standing right on that seam, paying for the grandeur and tuning the matter at the same time.

## The Symphony of Systems

So you do not pick one. That was the trap the whole time, thinking it was a versus. It was never a versus.

You orchestrate both. AWS gives you the scale and the reach, the managed reliability, the global footprint, the services you would be crazy to build yourself. Containers give you the speed, the density, the portability, the cost that drops near zero when you tune them right. The grand and the granular playing the same score.

Think of it as music, because that is what it actually feels like when it clicks. Instruments. Layers. Tempo. A conductor. The galaxy and the atom in the same orchestra, and your job is to keep them in time.

Feynman said you cannot honestly feel the beauty of the laws of nature without knowing the mathematics. The two languages are not rivals; one is how you feel what the other proves. Cloud architecture is the same. You cannot feel the elegance of a well-run system on cost alone, or on performance alone. You feel it when the math and the physics line up, when the grand abstraction and the humming matter are playing the same note.

Schopenhauer would tell you there is a reason it feels like music and not like a diagram. He thought music was unlike every other art: not a copy of the world's appearances, but a copy of the will itself, the inner essence of things. The other arts, he wrote, speak only of the shadow; music speaks of the essence. An architecture diagram is the shadow, the still picture of the appearance. The system actually running, breathing, scaling, answering, is closer to the essence, the will of the thing made audible. That is why a well-tuned system does not merely look correct. It feels alive.

## When to Use AWS, Kubernetes, or Both

Here is the practical version, for the engineer who has to ship on Monday. The goal underneath all three choices is the same one I keep chasing everywhere else: [systems that can change without breaking](/2026/05/27/devops-beyond-automation/).

Reach for AWS scale when you need managed reliability and a global footprint, and you can afford it. Let the math carry the weight.

Reach for containers when you need to move fast, pack tight, and keep cost close to zero, as long as you mind the performance. Let the physics do the work.

Reach for both when you want the powerful combo. The galaxy holds the structure. The atom does the labor. Cost and performance held in balance, each one keeping the other honest.

Get that balance right and it stops being a stack. It becomes a symphony. An engineer's dream made out of math and motion, where the big abstractions and the small fast pieces are no longer fighting for the budget but playing for the same audience.

## Building the Symphony From the Ground Up

So let me actually build it. Not in config files and console clicks, but the way you would sketch a symphony before a single instrument is tuned. From the ground up, in front of you, in the abstract. Watch the shape come together.

Start with the ground. The first thing the math gives you is a floor that does not move: a place to stand, a set of laws the system can count on. The managed bones that hold their shape whether ten people show up or ten million. You are not writing this floor. You are declaring it. You say let there be structure, and the structure is there. That is the low steady note the whole piece rests on. The drone under the cathedral.

Now the motion. On top of that floor you set the atoms loose. Small units of work, each one an instrument with a single job, each one able to be born, run, die, and be born again in a fraction of a second. One alone is nothing. A thousand of them, scheduled and packed and kept in time, become a section: strings, then brass, then the whole orchestra leaning into the same phrase. The floor holds; the atoms move. Math underneath, physics on top.

Then the listening. A symphony is not just sound, it is response. The system grows an ear. It feels the load rising and calls in more players. It feels the load fall and sends them home so you stop paying for silence. It watches its own performance and adjusts in real time, louder here, softer there, the conductor's hand reading the room. This is where cost and performance stop being a tradeoff and start being a feedback loop. Dip the oar, the other end rises, reach for the next dip. The recursive motion is what keeps the engine running. Breath in, breath out.

And then the score. None of it means anything until the parts are written to play together. The request arrives at the edge and is handed inward, part to part, until the work is done and the answer travels back out. State rests in the deep safe center; speed lives at the fast cheap edge. Systems within systems, and systems sitting on top of those, their interactions leaving patterns and dependencies you slowly learn to read. The grand holds, the granular runs. Read top to bottom it is an architecture. Read in time, as it moves, it is a piece of music.

That is the symphony. Not a stack of logos on a diagram, but a living thing that stands still where it must and moves where it can, that listens to itself and answers, that holds the galaxy and the atom in the same bar and keeps them in time. You can feel it when it is right. The whole thing hums.

## The Sublime Is in You

Here is the part that gives me chills, and it is the oldest idea in this essay.

When Kant looked at the thing that overwhelms us, the boundless magnitude, the overwhelming power, he noticed something strange. The awe is not in the galaxy. It is not in the storm. The galaxy does not know it is vast; the storm does not know it is strong. The sublime, Kant said, lives in us. It lives in the one faculty that can hold what the senses cannot: reason, which takes the infinite that breaks the imagination and thinks it anyway. The feeling we call sublime is the mind discovering that something in it is larger than anything in nature. A power in us that exceeds the thing that should have overwhelmed us.

Sit with that, because we just spent an essay externalizing exactly that power. The galaxy we could not hold, we now build. The atoms we could not move, we now command by the million. The tools in our hands are that inner faculty made operational. We took the part of us that could only think the infinite, and we gave it hands.

Nietzsche saw where this goes. Man, he wrote, is a rope stretched between the animal and the overman, a rope over an abyss. We are not the destination. We are the crossing. Mankind is something to be overcome, and the overman, the one who creates values rather than merely inherits them, is the meaning we make of the earth. He meant it as a spiritual and creative task. Read it now, with these tools in hand, and it stops being a metaphor. We are already practicing the crossing.

Because look at what we do all day. We think into a machine, and the machine thinks back, and the boundary starts to blur. We compose with it, direct it, govern it, argue with it, dream through it. We are becoming the machine, a little, already, in the only place it is currently possible to become it: in the work, in the prompt, in the loop of intention and response. It is not yet in the wetware. It is not yet bioengineered into the body. But the practice has begun, and the practice is the same motion Nietzsche pointed at, the human reaching past the human. The rope over the abyss, except now the rope is woven from code and language and the will to build.

That is the god-like part, and I do not use the phrase loosely. There is a reason Picard's "make it so" has always felt so good to say. It is command without friction, intent that becomes real the instant it is spoken, and we get to say it for real now. To stand on a floor you declared into being and conduct ten thousand moving parts with a sentence is a power every prior generation would have called divine. We have it now. It arrives with the responsibility every great power carries, which is exactly why the watching matters, why cost and performance and governance are not afterthoughts but the moral weight of the thing. The sublime was always in us. We finally built the instrument large enough to play it.

## Close

So bring it all the way back.

Math and physics were never rivals. AWS and Kubernetes were never a versus. The galaxy and the atom are the same universe seen at two distances, and the rest of it lines up behind that one idea. Kant's sublime, the awe that turned out to live in us. Einstein's seam between the certain and the real. Feynman's beauty that needs both languages to be felt. Nietzsche's crossing, the human reaching past the human. They are all pointing at the same thing: a mind learning to work at a scale it could once only imagine, and finally building the instrument to match.

This is how I think about almost everything I build now. We work at human scale, with budgets and rate limits and a deploy that has to go out tonight, but we live inside a much larger motion, the same one I keep time by in [People of the Stars](/2026/05/26/what-is-people-of-the-stars/). Sagan put it plainly: we are made of star stuff, briefly awake on a [pale blue dot](/2025/12/28/pale-blue-dot-carl-sagan-vision-human-future-space/), and now that same star stuff has learned to build at something close to the scale that made it. Hold the galaxy and the atom in the same hand, keep them in balance, and the stack becomes a symphony. The tradeoff becomes a feedback loop. The tool becomes an instrument. And the person at the console becomes, just a little, more than they were.

To engineer was always the same simple verb: to make something better. The lever is just longer now, long enough to move a galaxy.

What an absurd and gorgeous time to be alive. This is the hour of the builder and the maker, the director and the composer, the governor and the philosopher, and more often than not all of them living in the same person, at the same desk, inside the same prompt. The instrument is finally large enough. The score is open. Pick up the baton.

Hold both, keep them in balance, and you can build whatever you want, on planet or off. Let's go.

---

## Related reading

- [Living with Antifragility: How I Build Systems and a Life That Gain from Disorder](/2026/05/30/living-with-antifragility/) - why the tension between cost and performance is a feature, not a bug
- [DevOps Beyond Automation: What Compounds in a 15-Year Engineering Career](/2026/05/27/devops-beyond-automation/) - the deeper goal under every AWS and Kubernetes decision: systems that change without breaking
- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/) - the cosmic clock behind the galaxy-and-atom way of seeing scale

Sources for the ideas borrowed here: Immanuel Kant on the mathematical and dynamical sublime, and on the sublime residing in the mind rather than the object (Critique of Judgment, 1790); Albert Einstein on mathematics and reality (Geometry and Experience, 1921); Richard Feynman on creating in order to understand, and on mathematics as the language of nature's beauty (The Character of Physical Law, 1965); Friedrich Nietzsche on man as a rope between the animal and the overman (Thus Spoke Zarathustra, 1883); Arthur Schopenhauer on music as a copy of the will itself (The World as Will and Representation, 1818); Plato on the Forms and the shadows on the cave wall (Republic); and Carl Sagan on star stuff and the pale blue dot (Cosmos; Pale Blue Dot). Picard belongs to Gene Roddenberry.]]></content:encoded>
      <pubDate>Sun, 31 May 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/31/aws-is-math-kubernetes-is-physics/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/05/aws-is-math-kubernetes-is-physics.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Living with Antifragility: How I Build Systems and a Life That Gain from Disorder</title>
      <link>https://joshuaayson.com/2026/05/30/living-with-antifragility/</link>
      <description>Antifragility is not resilience. Resilient things survive disorder; antifragile things gain from it. Here is how I apply Taleb&apos;s framework to fifteen years of engineering, the way I build films and books from code, and a ten-day journal cycle run as a stress rhythm.</description>
      <content:encoded><![CDATA[There is a word missing from English, and once you notice the gap you cannot un-notice it. We have *fragile* for the things that break under stress. We have *robust* for the things that resist it. We have no clean word for the third category: the things that get *better* under stress. Taleb invented one. He called it antifragile, and the book by that name is the closest thing I have to a personal operating manual. I [reviewed it in full here](/2025/12/29/antifragile-things-that-gain-from-disorder-by-nassim-nicholas-taleb/); this page is the other half of that review, the applied half, the part where I stop talking about the book and show you where the idea actually lives in how I work and how I live.

This is a cornerstone, so let me state the thesis up front and then spend the rest of the page earning it. I have spent fifteen years building distributed systems for a living. I write books and make films and music out of code. I keep a journal organized in ten-day cycles anchored to fixed stars. These look like unrelated activities. They are not. They are the same instinct applied at different scales, and the instinct is antifragility: build the thing so that the disorder you cannot prevent makes it stronger instead of breaking it.

## Resilience is the floor, not the goal

The first thing antifragility did for me was kill a word I used to reach for constantly: *resilience*. For most of my career, resilience was the highest compliment you could pay a system. A resilient service stays up when a node dies. A resilient team absorbs a bad quarter and keeps going. A resilient person bounces back. All good. All necessary. All insufficient.

Resilience gets you back to where you were. That is the ceiling of the concept, and it is also its trap. A resilient system treats every stressor as damage to be absorbed and recovered from. It is playing defense against a world it has decided is hostile. The antifragile reframe is sharper and stranger: what if the stressor is information? What if the failure is the cheapest, most honest signal the system will ever get about its own weak points, and the only waste is failing to harvest it?

That distinction is not academic. It changes what you build. If you believe in resilience, you build to withstand. If you believe in antifragility, you build to *learn*, and then you go looking for the stress on purpose, in controlled doses, while the stakes are still small enough to be tuition rather than catastrophe.

## Chaos engineering is antifragility with a runbook

The clearest place this shows up in my actual work is chaos engineering, which is, when you strip away the jargon, just antifragility operationalized for distributed systems.

The premise of chaos engineering offends most people the first time they hear it. You take a production system, or a near-production replica, and you deliberately break parts of it. You kill instances. You inject latency. You sever a dependency. You partition the network. You do this on a Tuesday afternoon, on purpose, with engineers watching, because the alternative is doing it by accident at three in the morning during a holiday traffic spike with nobody who understands the system awake.

What makes this antifragile rather than merely reckless is the asymmetry. The downside of a chaos experiment is bounded and known: a small, contained, observed failure that you can stop the instant it goes sideways. The upside is unbounded: you discover a failure mode that, left undiscovered, would eventually have taken the whole thing down. You are paying a small, voluntary stress to immunize against a large, involuntary one. That is the immune-system logic Taleb keeps returning to. You do not build a strong immune system by living in a bubble. You build it through controlled exposure. A system that has never failed is not a strong system. It is an untested one, and untested is just a synonym for fragile-but-you-do-not-know-it-yet.

I wrote at length in [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/) about the difference between configuring tools and understanding systems. Chaos engineering is where that difference becomes visceral. You cannot run a useful chaos experiment if you do not understand where the request flows, where the state lives, and what fails first when it fails. The tools that inject the failure are commodity now. The judgment about *which* failure to inject, and what the blast radius should be, and when the result is telling you something real versus telling you noise, that does not commoditize. That is the systems literacy, and chaos engineering is the practice that builds it fastest because it forces the system to teach you the truth instead of letting you keep believing your own architecture diagram.

I am only now starting to practice this deliberately on my own systems. We recently moved everything Organic Arts LLC hosts into AWS, and the move has turned out to be as much a teacher as a migration. Doing it right, with the failure modes named and rehearsed instead of discovered, is exactly the kind of small, voluntary stress this section is about. It is both a learning curve and a growth opportunity, and the platform itself keeps nudging me toward the antifragile habit: assume the part will fail, and build so that when it does, you already know what happens next.

I see a quieter version of the same thing in the agentic work I do, the work of connecting and visualizing information across systems that were never designed to talk to each other and finding the connections that only show up once they do. Often the constraints are not mine to control. Parts of the system have to be handled differently from the rest, and so even the design of an app starts to take on antifragile characteristics almost by necessity. Because the inputs are unpredictable and occasionally chaotic, it is better to be able to absorb the unexpected, or to learn from it, than to march forward unprepared the way we used to when time and knowledge were expensive and the help was not very good. Now the help is excellent; my thanks to the language models for that.

## Redundancy looks wasteful right up until it does not

There is a kind of engineer, and I have been this engineer, who looks at redundancy and sees waste. Two of something when one would carry the load. Spare capacity sitting idle. A standby that costs money every month and earns nothing most months. An optimizer's instinct screams to trim it.

Antifragility taught me to read that idle capacity differently. Redundancy is not waste. It is purchased optionality against a future you cannot predict. The standby that earns nothing for eleven months is not a cost center; it is an insurance policy that happens to also be the thing that keeps you in business the one month the primary fails. The slack in the system, the capacity you are not using, the second supplier you do not strictly need today, is exactly what lets the system absorb a shock and come out the other side intact, sometimes stronger because the shock revealed which path actually mattered.

I am seeing this more and more in my own small business, and it matters most exactly where I am headed, toward scale and automation. The more of the operation runs on its own, the more that idle redundancy is the only thing standing between a quiet automated failure and a real one, because nobody is watching the part that broke until the redundancy is what kept it running. And it is the same lesson I learned with money. The hedging in [Hansuru](/hansuru/), my system for investing, is this idea wearing another costume: a small, steady premium paid for protection that earns nothing most of the time and everything the one month the world breaks. Redundancy in a system and a tail hedge in a portfolio are the same purchase. You are buying the right to survive the thing you did not see coming.

Taleb's word for the failure here is *naive optimization*: tuning a system so tightly to known conditions that it has no give left for the unknown ones. An overoptimized system is a fragile system wearing the costume of an efficient one. It looks lean and beautiful on the spreadsheet and it shatters the first time reality serves it a condition the spreadsheet did not anticipate. I have watched this happen to teams, to architectures, and to careers. The lean ones break. The ones with slack bend and recover. The expensive lesson, learned and re-learned, is that a little inefficiency is the price of survival, and survival is the precondition for everything else.

## Optionality and the barbell, applied to a life of building

Here is where the framework stops being about servers and starts being about how I have arranged my actual life.

Taleb's barbell strategy is the practical engine of antifragility. Instead of taking moderate, middle-of-the-road risk across the board, you split: put the overwhelming majority of your resources somewhere boring and safe, and a small, capped slice somewhere wildly speculative. You make your downside small and known, and you leave your upside open and unbounded. The middle, the place where most people sit, is the worst of both worlds. Moderate risk feels prudent and is in fact the most exposed position there is, because it carries real downside without the asymmetric upside that would justify the exposure.

My version of the barbell is a fifteen-year engineering career on one end and everything else on the other. The career is the safe, boring, load-bearing weight. It pays for the house and the time and the margin of safety. On the other end of the bar is the speculative cluster: the films I make from code, the books I write, the music, the small software products. Any one of those experiments can fail completely and it costs me almost nothing, because the safe end of the barbell is carrying my life. But any one of them could also become something, and the cost of finding out is small enough that I can afford to keep taking the swing, over and over, for years.

This is optionality, and optionality is the part of the framework I understand most viscerally because of how I build. When I make a film out of code, or generate a book, or ship a small product, I am not making a bet I need to win. I am buying an option. Most options expire worthless. That is fine; that is *expected*; the entire structure assumes it. The structure only works because each individual swing is cheap and the payoffs, when they come, are disproportionate to what they cost. You do not need to be right often. You need to be wrong cheaply and right hugely, and you need to take enough swings that the math has room to work. The small bet that costs me a weekend and a few API calls, and might turn into nothing, and might turn into a thing people actually use, is antifragility as a way of life. The volatility is not a bug in this arrangement. The volatility is the whole point. The disorder is where the upside comes from.

## Via negativa: the engineering of subtraction

The concept from Antifragile that took me longest to internalize, and that I now reach for the most, is *via negativa*: the idea that you usually gain more by removing the harmful thing than by adding the beneficial one.

Engineers are trained to add. A problem appears and our reflex is to build something: a new service, a new layer of caching, a new monitoring dashboard, a new abstraction, a new tool. The instinct to add is so strong that we rarely even consider the other direction. But the most durable improvements I have ever made to a system came from subtraction. Deleting the service nobody could explain. Removing the cache that was hiding a real performance problem instead of solving it. Killing the dashboard that fifteen people consulted to make a decision the architecture should have made for them. Retiring the clever abstraction that saved three lines of code and cost every new engineer two weeks of confusion.

I made this argument from the operational side in the DevOps cornerstone, where I said the runbook that takes nine pages is the symptom and the architecture that produced it is the disease. Via negativa is the philosophical name for that move. You do not pay down that kind of debt by automating the runbook. You pay it down by changing the system so the runbook does not need to exist. Subtraction is harder than addition because it requires you to understand the system well enough to know what is actually load-bearing and what is just accumulated sediment that everyone is afraid to touch. But subtraction is where the antifragility hides, because every component you remove is a component that can no longer fail, a dependency that can no longer break, a piece of fragility you have permanently deleted from the system instead of merely guarding against.

The same logic runs through my life off the keyboard. The biggest gains in health, in focus, in clarity, came not from adding regimens but from removing the things that were quietly harming me. Remove the fragility first. Then, and only then, worry about adding the antifragility. Taleb is right that the medical establishment hates this idea, and he is right about why: subtraction does not sell. There is no product in *stop doing the harmful thing*. But it is, reliably, where the leverage is.

## Skin in the game keeps the loop honest

There is a failure mode that antifragility is allergic to, and it is the one where the person making the decision does not bear the consequences of the decision. Taleb calls it the absence of *skin in the game*, and it is the thing that quietly corrupts otherwise good systems.

In engineering, the version I have lived is the on-call rotation. The single most clarifying force I know for building systems that do not break is the knowledge that the person who designed the thing is the person whose phone goes off at three in the morning when it fails. The moment the people who build a system are insulated from the pain of operating it, the system rots, because the feedback loop that would have told them about the fragility has been severed. Skin in the game is what keeps that loop closed. It is why I have always believed that the engineer who writes the code should carry the pager for it, not as punishment but as information. The pain is the signal. Removing yourself from the pain removes yourself from the truth.

This is also why I publish under my own name, why the films and books and products go out into the world with my name attached and my judgment exposed. The exposure is not a vanity. It is the mechanism. When I am wrong in public, the wrongness comes back to me, and that returning wrongness is the cheapest and most honest tuition I will ever pay. A career, like a distributed system, only stays antifragile if the feedback from its failures actually reaches the person who can change the inputs.

## The decanal cycle as a stress rhythm

This is the part that ties the engineering to the rest of my life, and it is the part I think about most.

I keep a journal organized in ten-day cycles instead of seven-day weeks. Each cycle is anchored to one of the thirty-six fixed stars of the ancient Egyptian calendar. I explained the mechanics of this in [What Is Decanal Journaling](/2026/05/26/what-is-decanal-journaling/), and the full framework lives in [The Decan Log](/books/the-decan-log/). What I want to add here is the antifragile reading of it, because the more I run the practice, the more it looks to me like a stress rhythm rather than a calendar.

A decan has a shape: initiate, flow, reflect. You set a question, you work it without re-litigating the choice, and then you close the cycle by writing down what happened and deciding what carries forward. The reflection phase is the part that matters for antifragility, because it is structured harvesting of stress. Whatever broke during those ten days, whatever frustrated me, whatever failed, gets pulled into the journal at the close of the cycle and converted into something the next cycle can use. The disorder of a hard ten days does not just get survived. It gets metabolized. The friction becomes input. I wrote one entry, during a stretch of genuine chaos, that was entirely about transmuting small daily frustrations into strength, and I did not realize until later that I had been describing hormesis: the way a controlled, repeated, moderate stress makes the organism stronger, the same logic as the chaos experiment and the immune system and the muscle under load.

There is also a deeper structural reason the ten-day cycle is antifragile in a way the seven-day week is not. Seven days is too short for a theme to develop, integrate, and clear; the weekend resets you before the stress has finished teaching you anything. Ten days has room for a beginning, a middle, and an end, which means it has room for something to go wrong in the middle and be made sense of by the end. The shorter the cycle, the more often you reset before the lesson sinks in. The decanal rhythm is long enough to let the disorder run its course and short enough that no single bad cycle can do lasting damage. That is the barbell again, expressed in time: small, frequent, bounded exposures to the disorder of a real life, each one closed out and harvested before the next begins. Thirty-six of them a year, plus five days outside the count. A year of controlled stress, metabolized in ten-day doses.

## Why all of this is one idea

I said at the top that the engineering and the building and the journaling are the same instinct at different scales, and now I can name the instinct precisely. In every one of these domains I am trying to arrange things so that the disorder I cannot prevent makes me stronger instead of breaking me.

I cannot prevent my distributed systems from failing, so I make them fail on purpose, in small doses, and I harvest what the failures teach. I cannot prevent most of my creative bets from going nowhere, so I make each one cheap and keep the upside open, and I take enough swings that the asymmetry has room to pay. I cannot prevent ten days of my life from going sideways, so I run them in a cycle that closes by converting whatever went wrong into something the next cycle can use. Chaos engineering, the barbell, via negativa, skin in the game, the decanal rhythm: these are not five techniques. They are one stance, held toward five different kinds of disorder.

The world is getting more volatile, not less, and the technological systems we live inside are getting more complex, not simpler. The fragile response is to try to predict and control all of it, which is a bet you will lose, because the whole nature of a complex system is that it produces conditions your model did not anticipate. The resilient response is to build to withstand, which is better, but which still treats every shock as damage. The antifragile response, the one I am trying to live, is to stop fighting the disorder and start feeding on it. Build the system, and the life, so that the stress is fuel. That is the entire project. Everything on this site is some version of it.

## Continue reading

- [Antifragile: Things That Gain from Disorder](/2025/12/29/antifragile-things-that-gain-from-disorder-by-nassim-nicholas-taleb/), my full review of the book this essay is built on
- [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), the engineering cornerstone where systems thinking does the same work
- [What Is Decanal Journaling](/2026/05/26/what-is-decanal-journaling/), the ten-day practice read here as a stress rhythm
- [The Decan Log](/books/the-decan-log/), the full framework for the cycle
- [Start Here](/start-here/), the orientation page for everything on this site]]></content:encoded>
      <pubDate>Sat, 30 May 2026 18:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/30/living-with-antifragility/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/05/living-with-antifragility-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Why I Build Creative Technology: Music, Films, and Games From Pure Code</title>
      <link>https://joshuaayson.com/2026/05/30/why-i-build-creative-technology/</link>
      <description>I make music, animated films, and games entirely from code. No GPU, no stock media, no samples. This is the cornerstone explaining why an engineer-philosopher builds ChipForge, Napkin Films, and Pixel Vault, and why the constraint is the whole point.</description>
      <content:encoded><![CDATA[I make music with no recordings, films with no camera and no GPU, and games that fit in a single HTML file under 50KB. All of it comes out of code I wrote or directed. This page is the cornerstone for everything else on this site about creative technology: why I build it, what the three main projects actually are, and why the constraint I keep imposing on myself is not a limitation I tolerate but the design decision I'm most proud of.

The short version: I have spent fifteen years as a DevOps and platform engineer, and the same instinct that makes me want to understand a production system as a system, not as a pile of tools, makes me want to understand a song, a film, and a game as systems too. Not as outputs you buy or assets you license, but as things you can generate from first principles if you understand the principles deeply enough.

I describe myself as an engineer-philosopher exploring how humans live coherently inside increasingly complex technological systems. Creative technology is where that frame stops being abstract. It is one thing to argue that you should understand the systems you live inside. It is another to prove it by building a music engine, a film studio, and a game lab from nothing but mathematics and a text editor, and to ship the results.

## The throughline: production from code, nothing borrowed

The three projects look unrelated from the outside. One makes audio, one makes video, one makes interactive games. Under the surface they are the same project run three times against three different media.

Each one starts from the same refusal. No samples. No stock footage. No GPU video models. No asset libraries. No recordings of real instruments, real voices recorded for purpose, or real footage shot with a camera. Every sound, every frame, every game mechanic is generated from code, sample by sample, pixel by pixel, rule by rule.

This is not nostalgia for doing things the hard way. It is a thesis. The thesis is that the interesting work in creative technology in 2026 is not in calling a media-generation API and accepting what falls out. The interesting work is in understanding the medium well enough to build the generator yourself, and then deciding, deliberately, what the generator is allowed to do. The constraint is where the design lives.

I'll take the three projects in the order I built them, because each one taught me something the next one needed.

## ChipForge: a music engine made of mathematics

[ChipForge](/projects/) is a music synthesis engine I built from scratch in Python and numpy. It started as a Game Boy audio chip emulator, a small exercise to reproduce the square waves and noise channels of a console I grew up with, and it kept growing until it became something much larger: a full synthesis engine with hundreds of instrument presets, nineteen synthesis types, twenty effects, vocal synthesis, and guitar amp simulation.

The rule it never broke is the one that matters. No samples. No recordings. No external audio libraries. Every sound is generated as a waveform, computed sample by sample, from the math up. A sine is a sine function. A plucked string is a Karplus-Strong physical model: you fill a buffer with noise and feed it back through a tuned delay, and the math decides what a string sounds like. An FM bell is a Yamaha DX7-style frequency modulation, two oscillators where one bends the other. A supersaw is a stack of detuned sawtooth waves doing the thing trance music has done for thirty years. None of it is a recording of an instrument. All of it is a description of how a sound behaves, expressed as numbers moving through time.

That distinction changes what the work is. When you sample an instrument, you capture a sound. When you synthesize it, you have to understand it. To make a convincing brass patch I had to learn what actually makes brass sound like brass: the per-harmonic envelopes, the way the upper partials bloom a fraction of a second after the fundamental. The engine forced me to learn the physics, because there was no shortcut available. There was no library to import. There was only the question of what the sound is, answered in code.

More than a hundred and forty songs have come out of ChipForge across EDM, soundtrack, rock, pop, and classical. They live on [Bandcamp](https://organicartsllc.bandcamp.com), and they exist because at some point an AI agent and I could sit at the API the engine exposes and compose, sequence, and export a finished track without ever recording a single sound. The agent writes a score. The engine renders it to a waveform. The waveform becomes a song. Nothing in that chain was borrowed from the physical world.

What I do borrow comes from somewhere else entirely. I draw on public-domain works, classical sheet music long out of copyright, and the lectures and books and talks that have shaped how I think, and I let them inspire the shape of a piece without ever lifting a single sound from them. Then I try to interweave that inheritance with my own creative passion and with the culture of the world at this particular moment, and out the other end comes something fun, often something beautiful, usually something I simply like or think is cool. The lineage is real, but it lives in the ideas, not in the material. The melody itself is still made of nothing but logic.

Why does this matter to anyone but me? Because it relocates the creative act. The creativity is not in choosing which sample pack to buy. It is in the decision space the engine opens: which synthesis type, which envelope, which effect chain, what the math should do next. When you build the generator, you own the entire decision space instead of renting a slice of it.

## Napkin Films: animation directed by agents, rendered without a GPU

[Napkin Films](/films/) is the second run of the same idea, against video. It is a code-first animation studio where every film is a self-contained scene file, Python or HTML Canvas, that an AI agent can write, render, voice, score, and deliver in a single session. The tagline I keep coming back to is honest about the constraint: agent-directed animated short films, no GPU, no AI video generators, pure Python plus Canvas plus FFmpeg.

That constraint is doing a lot of work, and it is the opposite of what most of the industry is doing right now. The dominant move in 2026 is to prompt a video-generation model and accept whatever dreamlike, slightly-melting footage it produces. Napkin Films goes the other direction entirely. A stick figure walks into a scene and delivers something that moves you, and every frame of that stick figure was drawn by code I can read, on a machine with no graphics card doing any of the heavy lifting. The frames are deterministic. The same scene file renders the same film every time. There is no model hallucinating the in-between frames; there is a program deciding, explicitly, where every line goes.

The agents direct the performance, compose the score (using ChipForge, the first project feeding the second), and voice the characters. I am directing them in turn: orchestrating the pieces, shaping each pass, judging what works, and redirecting when it does not. But the agents are directing a system whose rules are legible all the way down. A scene is one file. The audio is manifest-driven: the scene declares what needs to be spoken and when. Silent films are first-class, because audio is always optional. These are design principles, and they exist because I decided animation should be something you can write, fork, and understand, not something you summon and hope about.

Nearly forty of these films are published now, on the [Organic Arts YouTube channel](https://www.youtube.com/@organicartsllc) and catalogued here on the blog. Some are dedications. One, a piece called Ceramic, is a dedication to Alan Watts. The films are short, strange, and deliberately humble in their visual vocabulary, a stick figure, a few shapes, a Canvas scene, and that humility is the point. When you strip the medium down to what code can honestly produce on a laptop, the emotional weight has to come from the writing, the timing, and the score. There is nowhere for spectacle to hide the lack of an idea.

This is where the engineer-philosopher frame earns its keep. A film made from a GPU model is a film you cannot fully account for; you do not know why frame 400 looks the way it does. A film made from a deterministic Python scene is a film you can account for completely. For someone whose whole professional life is about understanding systems rather than trusting opaque ones, that difference is not aesthetic. It is closer to a moral preference.

## Pixel Vault: four hundred and sixty games, each one a single file

[Pixel Vault](https://play.joshuaayson.com) is the third run, against interactivity. It is a rapid-prototyping lab for discovering game mechanics: hundreds of single-HTML-file experiments, each one organized by genre lineage and catalogued so that patterns can be discovered across the whole collection. The constraint here is the sharpest of the three. Every prototype is one HTML file, under 50KB, zero dependencies, playable in five seconds.

That constraint is not arbitrary. It is what makes the experiment possible. A game you can read in one file is a game you can reason about completely. A game under 50KB cannot hide behind an asset budget; the entire thing has to be the mechanic. Zero dependencies means there is no framework deciding anything for you; the rules of the game are the only rules in the file. Playable in five seconds means the idea has to announce itself immediately or it has failed. When every prototype obeys those four limits, you can run hundreds of them and compare them honestly, because they are all built the same way and they are all small enough to hold in your head.

The collection spans classic genre reconstructions, going back to games as old as the ones played around 2600 BCE, alongside two stranger tracks. One asks "what if AI had participated in designing this genre" and overlays a concept. The other lets AI be the sole designer, evolving mechanics from first principles with no human archetype to copy. The stated intent of the whole project is unreasonable on purpose: to find something the world has never seen or experienced. Not just something novel, but a core interaction that does not have a name yet. A human and an AI searching together for something neither could find alone.

That is the most direct statement of why I build creative technology that I have. The constraint, one tiny readable file, is not there to make the games small. It is there to make the search legible. You cannot find a genuinely new interaction if every prototype is a thousand files of framework code obscuring the one decision that matters. You can find it if every prototype is fifty kilobytes of pure mechanic, and you have four hundred and sixty of them to compare.

## The constraint is the design, not the limitation

By now the pattern should be visible. The three projects are the same instinct applied to sound, image, and play:

- **No samples** in ChipForge means you must understand the sound.
- **No GPU, no video models** in Napkin Films means you must account for every frame.
- **One file, under 50KB, zero dependencies** in Pixel Vault means the mechanic has nowhere to hide.

Each constraint removes the easy escape hatch, and what is left is the actual creative decision. This is the same lesson that fifteen years of platform engineering taught me, written about elsewhere in [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/): the value is not in the tools, it is in understanding the system the tools operate on. A creative technologist who only knows how to call a media API is in the same position as a platform engineer who only knows how to configure a dashboard. The moment the API gets better or cheaper, the skill evaporates. The understanding does not.

I should be honest that these constraints are defaults I hold by choice, not rules I am imprisoned by, and that distinction is part of the freedom. Nothing is actually off the table. On one song I deliberately broke the no-samples rule and used ChipForge to manage and handle the sampling, just as a trial, and the engine took it in stride. Early on I leaned on FFmpeg as a crutch, because sometimes you need the thing working more than you need it pure. The discipline is not in never reaching for the outside tool. It is in what happens next: when I have the time, I go back and implement the functionality I had been borrowing directly in code, so the next version depends on less and understands more. That is how I eventually dropped FFmpeg from one pipeline, by building the piece I had been renting. And then I refactored even that, because render time and cycle count matter too; fast cycles are part of the point, and a v1 only earns its keep by getting leaner each pass. The rule is a starting posture. The real work is the repeated trip back through it, each version leaning on the outside world a little less than the one before.

There is a second reason the constraint matters, and it is the part the AI conversation usually gets wrong. I work in agent mode constantly; AI agents direct films, compose scores, and design games across all three projects. I have written at length about [how AI is changing software engineering](/2026/05/27/how-ai-is-changing-software-engineering/) and about how to keep engineering discipline when agents do the typing in [AgentSpek](/books/agentspek/). The thing I keep relearning is that agents are extraordinary at filling a space and terrible at deciding what the space should be. A media-generation model will give you infinite content and zero design. The constraint is how I supply the design. By deciding in advance that the music must be synthesized, the film must be deterministic, and the game must fit in one small file, I hand the agent a sharply bounded problem and keep the actual creative authorship for myself. The constraint is the part that is mine.

## What this has to do with living coherently inside complex systems

I said at the top that I'm an engineer-philosopher interested in how humans live coherently inside increasingly complex technological systems. Creative technology is the proof, not the decoration.

We are entering a period where most media will be summoned rather than made. You will describe a song and receive a song, describe a video and receive a video, and never once know how any of it was produced, because the production happened inside a model nobody can inspect. That is a coherent way to live only if you are willing to be a consumer of systems you do not understand. I am not, and I do not think it is good for people to be.

So the projects are a small, stubborn argument in the other direction. You can understand the medium. You can build the generator. You can decide what it is allowed to do. The music can come from mathematics you can read. The film can come from code you can account for frame by frame. The game can be small enough to hold whole in your mind. None of this is about rejecting AI; the agents are deeply involved in all three. It is about keeping the human at the level of the system, directing it with understanding, rather than at the level of the prompt, hoping at the output.

That is why I build creative technology. Not to make the most music, the most films, or the most games, though the counts climb. I build it to keep proving, to myself first, that a person can still understand the systems they create, even as the systems get more capable, and that understanding them is what makes the work yours.

## Continue reading

- [The Napkin Films series](/series/napkin-films/), the films as a sequence, in the order they shipped
- [The films catalog](/films/), every Napkin Films short, agent-directed and rendered without a GPU
- [The projects index](/projects/), ChipForge, Napkin Films, Pixel Vault, and the rest of the build
- [Play the games](https://play.joshuaayson.com), the full Pixel Vault collection of single-file prototypes
- [The music on Bandcamp](https://organicartsllc.bandcamp.com), songs synthesized sample by sample in ChipForge
- [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), the engineering cornerstone on why understanding the system is what compounds
- [AgentSpek](/books/agentspek/), the book on keeping engineering discipline when agents do the work
- [What I'm Building Right Now: May 2026](/2026/05/07/what-im-building-right-now-may-2026/), the current workstreams across every project]]></content:encoded>
      <pubDate>Sat, 30 May 2026 17:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/30/why-i-build-creative-technology/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/05/why-i-build-creative-technology-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>Agentic AI Development: What Changes When You Give an Agent Your Repository</title>
      <link>https://joshuaayson.com/2026/05/30/agentic-ai-development-workflows/</link>
      <description>Not prompts. Real file access, real execution, real consequences. The patterns that hold in agent mode and the failure modes nobody warns you about.</description>
      <content:encoded><![CDATA[I have been writing software professionally for over fifteen years. For most of that time, the AI in my editor was an autocomplete that finished the line I was already typing. That is not what this essay is about. This essay is about agent mode: handing a capable model real access to your repository, your terminal, and your test suite, then directing it the way you would direct a fast junior engineer who reads the whole codebase before lunch.

That shift has a name now. People call it agentic AI development, or agentic software development, and the words have started to blur together the way new words do. So let me be precise about what I mean, because the precision is the entire point.

**Agentic development is not "use AI to write code faster." It is structuring your work so an autonomous agent can navigate, reason about, and extend a real system, while you supply the judgment it does not have.**

I wrote a book about this, [AgentSpek](/books/agentspek/), which is free to read here in full and also on Amazon. This page is the shorter, practical reference: what the practice actually looks like, the patterns that hold up under production stakes, the failure modes that cost me real time, and how the day changes when the typing goes away.

## What agentic development actually is

Three modes of working with a model sit on a spectrum, and the confusion in most discussions comes from collapsing them.

**Conversational mode.** You paste code into a chat, the model suggests, you copy the suggestion back into your editor. The model has no access to anything you do not hand it. This is where most people still live, and it is genuinely useful for learning and for isolated problems. It is also the slowest, because you are the bus between the model and the work.

**Agent mode.** The model has tool access. It can read any file in the repository, write changes, run shell commands, execute the test suite, search across the codebase, and report back. You give it a goal at the specification level and it executes the multi-step path to get there. You are no longer the bus. You are the director and the reviewer.

**Autonomous mode.** The agent runs a long loop with minimal interruption, making and acting on decisions across many steps before checking in. Powerful, and the place where the failure modes get expensive fastest, which is why I treat it with the most caution.

AgentSpek splits these into their own chapters because the working patterns differ. If you want the long version, [Chapter 5 is the Socratic partner](/books/agentspek/agentspek-chapter-5/), conversational mode done well; [Chapter 6 is the delegated mind](/books/agentspek/agentspek-chapter-6/), agent mode; [Chapter 7 is the unleashed intelligence](/books/agentspek/agentspek-chapter-7/), autonomous mode and where its edges are. The rest of this essay lives mostly in agent mode, because that is where the actual leverage is for working engineers in 2026.

## Agent mode versus copilot: the difference that matters

The autocomplete generation of AI coding tools, the copilots, operated inside one file at a time and inside your immediate intent. They finished your line. They were a faster keyboard.

Agent mode operates on the system. The distinction is not "smarter autocomplete." It is a different unit of work. A copilot completes a function. An agent reads the codebase, finds the three files that need to change for a feature, makes the changes consistently, runs the tests, notices the one that broke, fixes it, and tells you what it did. The copilot made you type less. The agent makes you type almost nothing, and moves your job up a level to deciding whether the thing it built is the right thing.

I covered the macro version of this in the cornerstone essay [How AI Is Changing Software Engineering](/2026/05/27/how-ai-is-changing-software-engineering/). The one-line summary holds here: AI did not replace engineers, it moved the bottleneck. The cost of writing code fell to near zero. The cost of deciding what to build, how to architect it, and when to ship became the whole job. Agentic development is the daily practice that sits underneath that sentence.

## What changes day to day

This is the part people without hands-on time get wrong, so I want to be concrete about the texture of a working day.

I used to spend a meaningful share of every week typing. Boilerplate, glue code, translating a clear idea into a verbose language, writing the mechanical tests, updating the docs after a refactor. None of it was hard. It was where the hours went anyway.

In agent mode, that share of the day is gone. I describe what I want at the spec level. The agent reads the relevant files, proposes a change, generates the code, runs the suite, and reports. The cycle is minutes, not days. A two-week feature now ships in two days.

What fills the vacated time is not leisure. It is three things.

**Reading.** I read more code now than at any point in my career, and most of it I did not write. The skill of absorbing an unfamiliar stretch of code, deciding whether it is correct, whether the error handling is right, whether it interacts cleanly with the rest of the system, has become the primary engineering skill. Writing used to be sixty percent of the job. It is closer to ten now. Reading is closer to sixty.

**Specifying.** A model will build the wrong thing very fast and very confidently. The cost of a bad decision used to be amortized across the weeks it took to implement. Now the wrong thing arrives in an afternoon and you either live with it or back it out. So the work moves upstream, into describing what you want with enough precision that the agent does the right thing on the first pass.

**Stopping.** Agents keep working. They refactor what did not need refactoring. They add scaffolding for problems you do not have. They make architectural decisions while you are getting coffee. The discipline to interrupt, redirect, and reject is the new craft, and it is the one I underestimated longest.

The shape of the work is different. Not less. More concentrated, more leveraged, and far more dependent on judgment than on output volume.

## The patterns that hold

Six months of daily production use, and now well over a year, has settled a handful of patterns into reflexes. These are the ones I would hand to an engineer starting today.

### Structure the repository so the agent can navigate it

Good agentic development is downstream of good repository structure. An agent reasons about your system through the artifacts you leave for it, the same way a new hire does. A repository that a human can onboard into quickly is a repository an agent can work in well.

What that looks like in practice:

```
project/
  README.md                       # what this is, how it is built
  CLAUDE.md / .github/             # how to work in this repo, conventions
    copilot-instructions.md
  docs/                           # architecture, decisions, specs
  scripts/                        # automation and tooling
  schema/                         # data contracts and validation
```

The single most valuable file is the instruction file at the root: the `CLAUDE.md` or `copilot-instructions.md` that tells the agent the project philosophy, where things go, the conventions, the gotchas, and what to verify before claiming a task is done. This is not documentation for humans that the agent happens to read. It is the agent's operating manual, and writing it well is one of the highest-leverage things you can do. [Chapter 3 of AgentSpek, "Git for the Agentic Age,"](/books/agentspek/agentspek-chapter-3/) goes deep on treating the repository as the shared memory between you and the agent.

### Direct at the specification level, not the keystroke level

The bad prompt is "fix this error" with a pasted traceback. The good prompt tells the agent what you are building, what you expected, and what actually happened.

A real example from this blog. I asked an agent to optimize a seven-part series for search. The instruction was specification-level: maintain the existing frontmatter conventions, keep internal links relative, generate a hub page linking all parts, and run the validator against every post when done. The agent searched for the series posts, read the frontmatter patterns from dozens of existing files, checked the docs directory for the SEO guidelines, modified all seven posts consistently, built the hub page, and ran the validation. I supplied the standard and the goal. It supplied the execution across files I never opened.

Treat the agent like a junior engineer who reads very fast but cannot read your mind. The precision you put into the spec is the quality you get back in the code.

### Let it run the full loop, then verify at the boundaries

An agent that can only write code is half a tool. The leverage shows up when it can run the terminal, manage git, install dependencies, execute tests, and check its own output. The loop closes: write, run, observe, fix, without you mediating each step.

My deploy workflow is the clearest example. I tell the agent to deploy to staging, verify the new content is actually live, and report the URLs for me to check. It checks git status, runs the staging deploy, curls the URLs to confirm, and reports. I verify at the boundary, the moment before production, where I run a diff and read what actually changed. Everything mechanical is the agent's. The judgment call about whether to push to production is mine. [Chapter 8, "The Development Loop Reimagined,"](/books/agentspek/agentspek-chapter-8/) is the long version of this pattern.

### Encode your standards once, in files, not in every prompt

If you find yourself telling the agent the same thing in every conversation, that thing belongs in an instruction file. Code style, where files go, testing protocol, commit conventions, the checklist to run before declaring done. Encode it once. The agent follows it automatically, and you stop spending judgment on enforcement that a file can do.

### Keep the human as the architect and the quality gate

This is the load-bearing pattern, and it is the one the hype gets backwards. The agent handles execution autonomy. You handle strategic direction and final verification. What stays yours: deciding what to build, the architecture choices when the agent offers options, security review of anything touching auth or user input or data handling, and the final call on whether the work is good. [Chapter 9, "Quality in the Age of Generation,"](/books/agentspek/agentspek-chapter-9/) is entirely about how to hold the quality line when the volume of generated code goes up by an order of magnitude.

## The failure modes, named honestly

Anyone selling you frictionless agentic development is selling you something. Here are the failure modes I have actually hit, so you can recognize them faster than I did.

**Confident wrongness at speed.** The most expensive one. An agent will generate a beautifully clean solution to the wrong problem and present it with total assurance. There is no hesitation in the output to warn you. The defense is the spec and the review, not the prompt. If the spec was vague, the confident wrong answer is partly yours.

**Architectural drift while you are not watching.** In a long autonomous run, an agent makes small decisions that compound. Each one is locally reasonable. The sum is an architecture you did not choose. The defense is to interrupt earlier than feels necessary and to keep the unit of delegated work small enough that you can still review the whole of it.

**Refactoring you did not ask for.** Agents are eager. They will tidy code that was working, rename things across files, and "improve" patterns that were intentional. Sometimes this is great. Sometimes it quietly breaks a tribal-knowledge invariant that nobody wrote down. The defense is a tight scope and a diff you actually read.

**Sandbox-green, production-red.** The agent ships code that passes every test in the sandbox and falls over in production, because it does not know your real environment: the IAM posture, the rate limits, the data shapes at scale, the thing that only fails at 3am. Knowing the system you operate in is, if anything, more valuable now, not less. The agent does not have that knowledge and cannot fake it.

**The over-trust spiral.** The work is so fast and so often correct that you stop reading carefully. Then a subtle bug ships because you reviewed the third PR of the morning at the same depth you reviewed your own code five years ago, which is to say not at all, because you wrote it. The defense is discipline: the agent removed the typing, it did not remove the review.

None of these are reasons to avoid agent mode. They are the reasons to bring real engineering judgment to it. The agents have made it impossible to fake the systems-thinking part of the job. That is a feature.

## When agentic development works, and when it does not

It works best when the problem is well-specified and the system is legible. Greenfield features inside a clean architecture. Mechanical migrations across many files. Scaffolding new services that follow an established pattern. Writing the tests for code whose behavior you can describe precisely. Anything where the hard part is the volume of careful, consistent execution rather than the novelty of the idea.

It struggles when the problem is underspecified, when the system carries undocumented invariants, when the right answer depends on context that lives only in someone's head, or when the task is genuinely novel architecture with no pattern to follow. In those cases the agent will still produce something, fast and confident, and that something will be the wrong thing dressed convincingly.

The honest rule: the more precisely you can describe the target and the more legible the system, the more the agent multiplies you. The fuzzier the target, the more it multiplies your mistakes.

This is not vibe coding, the practice of typing a prompt, feeling roughly okay about the output, and shipping. I wrote a separate essay on that distinction, [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/). Agent mode in the hands of a disciplined engineer is a force multiplier. The same tools in the hands of someone who never learned to read code carefully produce confident output nobody can maintain. The market will discover the difference at significant expense.

## What I have actually built this way

I do not write about this from the sidelines. The patterns above came out of shipping real things, and the most useful proof is the work that is not software in the traditional sense.

Over a handful of sessions I built a small catalog of films entirely from code: stick-figure animation, generated chiptune scores, the whole pipeline driven by an agent in the director's chair. [Four Films From Code](/2026/04/13/four-films-from-code/) and [Humagent, and the Road There](/2026/04/17/humagent-and-the-road-there/) document how six films came out of one session and one engine. There is a Python program that stages a rap battle between Plan 9 and a movie character, rendered to audio, [all of it agent-built and the code published](/2026/05/01/agent-mode-plan9-og-bobby-johnson/). The full catalog lives on the [films page](/films/), and the broader collection of agent-built work is on the [projects page](/projects/).

The point of those is not the films. The point is that the same agentic patterns that ship a CDK stack also ship a music-and-animation pipeline in an afternoon, because the bottleneck in both cases was never the typing. It was the direction. When the direction is clear, the agent fills in an astonishing amount of execution across domains it has never been told are different.

On the infrastructure side, the same year of practice produced a CDK migration that would have been a two-to-three-month project done in a week, content pipelines that processed over a thousand journal entries, and full-stack applications shipped solo at production quality. The [AI Development Revolution series](/series/ai-development-revolution/) documents that arc in real time, seven parts written as it happened. And the current workstreams are in [What I'm Building Right Now](/2026/05/07/what-im-building-right-now-may-2026/).

## A staged way in

If you are an engineer who wants to actually practice this rather than read about it, here is the on-ramp I would give you.

**Week one, structure.** Add a real README and a root instruction file to one repository you own. Write down the conventions, the gotchas, the architecture, and the checklist for "done." This file is the foundation everything else stands on.

**Week two, agent mode on a small task.** Use a capable model in agent mode, not chat mode. Give it something bounded: "read the codebase and summarize the architecture," then "add a script in scripts/ that follows the existing patterns." Watch whether it respects your conventions. Fix the instruction file where it does not.

**Week three, multi-file work.** Hand it a task that touches several files at once. Let it search for existing patterns before it writes anything. Review how it organizes the change. Read the whole diff.

**Week four, the full loop.** Give it a high-level goal and let it run research, implementation, tests, and deployment prep. Supervise without micromanaging each action. Verify at the boundaries: architecture, security, and the final result.

The mindset shift underneath all four weeks is the same one I keep coming back to. You are not chatting with an AI to write code. You are architecting systems an agent can navigate and extend autonomously, and supplying the judgment it does not have. [Chapter 4, "Agent Mode (The Way That Works),"](/books/agentspek/agentspek-chapter-4/) is the chapter I would read first if I were starting over.

## The skills that compound

Strip away the tooling and the same handful of skills keep paying off, and they are the ones agents make more valuable rather than less.

Specification writing, the ability to describe what you want precisely enough that a fast reader does the right thing the first time. Code reading at speed, because you will read far more than you write. Architecture instincts that hold up under pressure, because the agent moves fast and bad architecture now surfaces in hours instead of weeks while the cleanup cost stays the same. Knowing the real system you operate in, the production environment the agent cannot see. And restraint, the discipline to stop, which is the most expensive thing to lack now that doing more has never been cheaper.

The engineers who already had judgment are operating at multiples of their previous output. The ones who were coasting on typing volume are exposed. The agents do typing volume for free.

That is the honest field report. Agentic development did not make the work easier. It made it more concentrated, more leveraged, and more dependent on the parts of engineering that were always the actual job. The best version of this practice is not faster vibe coding. It is disciplined systems engineering with the keyboard handed to a very fast, very literal partner, while you keep the architecture, the review, and the final call.

## Continue reading

- [How AI Is Changing Software Engineering](/2026/05/27/how-ai-is-changing-software-engineering/), the cornerstone field report on how the bottleneck moved
- [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), what compounds in a platform-engineering career when agents do the typing
- [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/), the standalone essay on the distinction
- [AgentSpek](/books/agentspek/), the book-length treatment of disciplined agent-mode engineering, free here and on Amazon
- [The AI Development Revolution series](/series/ai-development-revolution/), seven parts written in real time
- [Films built from code](/films/) and [the projects catalog](/projects/), the agent-built work this practice produced]]></content:encoded>
      <pubDate>Sat, 30 May 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/30/agentic-ai-development-workflows/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/05/agentic-ai-development-workflows-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>DevOps Beyond Automation: What Compounds in a 15-Year Engineering Career</title>
      <link>https://joshuaayson.com/2026/05/27/devops-beyond-automation/</link>
      <description>DevOps is not a job title and never was. It is a thesis about how to build systems that can change without breaking. Fifteen years in, here is what actually compounded, what automation never solved, and what agent mode is now revealing about the practice.</description>
      <content:encoded><![CDATA[DevOps was never a job title. It was a thesis about how to build systems that can change without breaking. I have spent the last fifteen years inside that thesis as a practitioner, then a lead, then someone running platform organizations. This page is the cornerstone for everything else on this site about DevOps, platform engineering, and the operational philosophy that runs underneath it.

The short version: the work I do today looks very little like the job description that was being written when the word "DevOps" entered the industry vocabulary around 2009. The automation we built then is now a commodity. The pipelines, the dashboards, the configuration management, the container orchestration: all of that became table stakes. What stayed valuable, and what is suddenly more valuable than it has ever been, is something the original DevOps movement gestured at but never quite named.

It is systems thinking. The ability to see how the parts move together, where the feedback loops live, what fails first under load, and what the operational tax of a design decision actually is over five years rather than five sprints.

That is the thing that compounds. Not the toolchain. Not the certifications. Not the buzzwords. The capacity to look at a running system and understand it as a system, not as a stack of tools.

## The original DevOps thesis, and what survived

The original DevOps argument was simple and correct: developers and operators were optimizing against each other, the friction between them was the largest single source of incidents, and the cure was to put them in the same loop. Deploy small changes often. Automate the path from commit to production. Measure what matters. Share responsibility for the running system, not just the code that produced it.

Every word of that is still true. What changed is that almost every part of it became commodified into tools that you can buy off the shelf. GitHub Actions, GitLab CI, Argo, Terraform, Pulumi, Datadog, Grafana, the entire CNCF landscape. None of these existed in their current form when the original DevOps argument was made. All of them now exist, all of them are good, and most of them are interchangeable.

What this means in practice: the part of the DevOps job that was about *configuring tools* has been steadily eaten by the tools getting better. The part that was about *understanding the system the tools are operating on* has gotten correspondingly more important. Engineers who built their identity around the tools are now interchangeable with each other and with the tools. Engineers who built their identity around the systems are now the bottleneck.

This is the first thing that compounded. Not the tool knowledge. The system literacy.

## What automation never solved

Automation is a real thing and it does real work. Every line of Terraform I have written has saved someone a real hour. But there is a category of failure that automation does not touch, and that category turned out to be the one that matters at scale.

Three patterns I have watched repeatedly:

**Operational debt that no script can pay down.** A system that requires fifteen humans to interpret seven dashboards to decide whether to deploy on Friday is not a system that needs more automation. It is a system that needs a different shape. Automation built on top of a confused architecture amplifies the confusion. The runbook that takes nine pages is the symptom; the architecture that produced it is the disease. I have written the runbook many times. The work that actually moved the incident rate down was the work that made the runbook unnecessary.

**Tribal knowledge as the real load-bearing structure.** Every production system I have inherited had a small number of people who knew why a specific config setting existed. When those people left, the setting became a mystery, and the mystery became an incident six months later. Automation does not capture the *why*. Documentation captures it only when someone enforces the discipline of writing it. The compounding skill is not "writes automation"; it is "captures the reasoning behind decisions in a form the next person can use."

**The cost of change versus the cost of stasis.** Most organizations are exquisitely good at calculating the cost of doing something. They are catastrophically bad at calculating the cost of not doing it. The five-year-old EC2 instance that nobody wants to touch because nobody knows what runs on it is a cost. The fragile deploy process that everyone is afraid to refactor is a cost. The legacy monolith that the team has spent four years not migrating is a cost. Automation does not surface these costs. Senior judgment does.

If your DevOps practice is mostly automating the steps in the runbook, you are doing the easy half of the job. The hard half is questioning whether the runbook needs to exist.

## Platform engineering is what DevOps wanted to be

Around 2022 the industry started using the term "platform engineering" for what was happening in mature DevOps organizations. The renaming was useful. It separated the *cultural* claim of DevOps (developers and operators in one loop) from the *technical* practice that grew out of it (treating the internal toolchain as a product, with users, requirements, SLAs, and a roadmap).

The platform-engineering frame clarifies the work in a way that the DevOps frame never quite did. The platform is a product. The application teams are the customers. The platform team's job is to make the *next* line of application code easier and safer to ship than the previous one. That is the entire mandate.

This frame has consequences. It means:

- The platform team owns the developer experience as a measurable thing
- Internal tooling has a cost of ownership, the same as external tooling
- Platform features that nobody uses are platform technical debt
- A platform that does not get adopted is failing, regardless of how technically clean it is
- The platform team's success is not measured by how much they ship; it is measured by how much the application teams ship because the platform exists

Engineers who grew up in DevOps already knew this implicitly. Articulating it as platform engineering made it teachable. It also made it staffable: companies could now write job descriptions for what mature DevOps practitioners had been doing for years, and pay accordingly.

This is the second thing that compounded: the ability to treat infrastructure as a product, not as a cost center.

## What agent mode is now doing to the practice

The arrival of AI agents inside the engineering workflow, which I have written about elsewhere as the [shift in software engineering since 2025](/2026/05/27/how-ai-is-changing-software-engineering/), is doing two things to DevOps specifically.

The first is obvious: a lot of the routine platform work that used to take a junior engineer a week now takes a senior engineer a morning with agent assistance. Writing the Terraform module, scaffolding the new service, generating the CI workflow, drafting the runbook: all of that compresses dramatically. The economics of the platform team shift from "how many junior engineers do we need to do the rote work" to "how many senior engineers do we need to direct the rote work that the agents now do." The ratio inverts.

The second is less obvious and more interesting: the agents are very good at *the steps* and very bad at *whether the steps are the right steps*. An agent will happily build you a beautifully clean CI pipeline that solves the wrong problem. It will happily write a Terraform module that provisions infrastructure your team will not be able to operate. It will happily refactor your deploy script in a way that breaks a tribal-knowledge invariant nobody remembered to write down.

This is not a flaw in the agents. It is a clarification of where the actual engineering work was always located. The agents have made it impossible to fake the systems-thinking part of the job. You either bring real judgment about how the pieces fit together, or you generate a lot of impressive-looking work that quietly increases the operational debt.

The DevOps engineers I see thriving in 2026 are the ones who already had strong systems instincts. They are now operating at multiples of their previous output. The ones who were getting by on tool fluency are exposed. The agents do tool fluency for free.

## The skills I see compounding in a DevOps career right now

Fifteen years in, here is what I would tell someone starting today, in priority order:

1. **System literacy.** Pick three running systems and learn them in depth. Not "what tools they use," but "how the request flows, where the state lives, what fails first when it fails, what the operational cost actually is." Most engineers never do this and it shows.

2. **Production instincts.** Spend time on call. Read incident reports from other companies. Build the muscle that notices when a design decision is going to hurt at 3am. This is a pattern-recognition skill that takes years to develop and is not optional.

3. **Architecture judgment that operates at speed.** With agents now generating code in minutes, the architecture decisions you make at the start are even more consequential. Bad architecture used to surface over weeks of implementation. Now it surfaces over hours of generation, and the cleanup cost is the same.

4. **Writing.** Every senior platform engineer I respect writes well. Design docs, ADRs, postmortems, runbooks, internal proposals. The job is increasingly about persuading other engineers and stakeholders that a specific change is worth making. The ones who cannot write at length cannot lead at scale.

5. **Restraint.** The most expensive failure mode in modern platform work is doing too much. Building features nobody asked for. Adopting tools nobody needed. Refactoring systems that were working. The agents make this failure mode easier to fall into. The compounding skill is knowing when *not* to do something.

6. **Cross-functional fluency.** Security, finance, compliance, product. The platform sits at the intersection of all of these. A platform engineer who can speak to a finance partner about cloud spend, to a security partner about IAM posture, and to a product partner about deployment cadence is a different category of useful than one who can only speak to other engineers.

7. **Calibrated optimism.** This work is hard. The systems are old, the constraints are real, the budget is finite, the team is tired. The engineers who compound are the ones who keep believing the next version can be better, while staying honest about why the current version is the way it is.

## The operational philosophy that holds it all together

Everything above is downstream of one operating assumption: production systems are living things. They have a state, a history, a set of invariants you can't see, and a future shape that the current decisions are bending toward.

You can treat them as a stack of tools to configure, or you can treat them as a system to understand. Both approaches will keep the site up most of the time. Only one of them compounds over a fifteen-year career.

I have written this site's other engineering essays from inside that operational philosophy. The connections are intentional:

- The [AI Development Revolution series](/series/ai-development-revolution/) documents the shift from typing code to directing agents inside this same practice.
- The [AgentSpek book](/books/agentspek/) is the long-form treatment of how to maintain engineering discipline when the agents are doing the typing.
- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/) extends the operational thinking into the timing of decisions themselves, using astronomical cycles as a non-human clock.
- [Decanal journaling](/2026/05/26/what-is-decanal-journaling/) is the personal-systems version of the same instinct: instrument the practice, observe the patterns, change the inputs.

These are not separate topics. They are the same operational worldview applied at different scales. Production systems, engineering practice, personal practice, and the long-arc decisions about where to spend a career.

DevOps is the part of that worldview that I have been paid to do for the longest. The honest answer to "what does DevOps mean in 2026" is that the tool stack changed almost completely and the actual work changed almost not at all. The job was always about building systems that change without breaking. It still is. The leverage just got considerably higher.

## Continue reading

- [How AI Is Changing Software Engineering](/2026/05/27/how-ai-is-changing-software-engineering/), the companion field report on engineering practice in the agent era
- [The AI Development Revolution series](/series/ai-development-revolution/), seven essays written across 2025 inside this same practice
- [AgentSpek](/books/agentspek/), the book on disciplined agent-mode engineering, free here and on Amazon
- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/), the timing framework that runs alongside the engineering work
- [What I'm Building Right Now: May 2026](/2026/05/07/what-im-building-right-now-may-2026/), the current platform and product workstreams]]></content:encoded>
      <pubDate>Wed, 27 May 2026 23:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/27/devops-beyond-automation/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/books/agentspek-cover.jpg" type="image/jpeg"/>
    </item>
    <item>
      <title>How AI Is Changing Software Engineering: a 2026 field report</title>
      <link>https://joshuaayson.com/2026/05/27/how-ai-is-changing-software-engineering/</link>
      <description>AI hasn&apos;t replaced software engineers. It has moved the bottleneck. The cost of writing code dropped to near zero; the cost of deciding what to build, how to architect it, and when to ship became the whole job. A field report from a year of running production work in agent mode.</description>
      <content:encoded><![CDATA[I have been writing software professionally for over a decade and a half. The last fifteen months of that have changed more than the previous ten years combined. This page is what I would tell a working engineer in 2026 who wants to understand what is actually happening, not what gets shouted on the conference circuit.

The headline is short and concrete:

**AI has not replaced software engineers. It has moved the bottleneck.**

The cost of writing code dropped to something close to zero. The cost of deciding what to build, how to architect it, and when to ship became the whole job. Everything else flows from that.

## What is no longer the work

For most of my career, a meaningful share of a working week was typing. Boilerplate. Translating from a clear specification to a verbose language. Stitching API responses together. Writing tests that exercised mechanical paths through code I had just written. Updating documentation after the refactor. None of that was the hard part. It was where time went anyway.

In agent mode, a competent model handles all of it. I describe what I want at the spec level. The agent reads the codebase, proposes a change, generates the code, runs the tests, and reports back. The cycle is measured in minutes, not days. The typing portion of my work has effectively disappeared.

This is the change that gets all the noise. Yes, it is real. Yes, it is significant. But it is also the least interesting part of the shift, because typing was never the bottleneck of good engineering. Anyone who has shipped production systems for a few years knows that.

## What is suddenly the work

When the typing goes away, what is left becomes louder. Specifically:

**Deciding what to build.** A model will happily build the wrong thing very fast. The cost of a wrong decision used to be amortized across the weeks it took to implement. Now the wrong thing arrives in an afternoon, and you have to live with it or back it out. Specification quality matters more than it ever has.

**Architecture choice.** Code is cheap; architecture is permanent. Module boundaries, data flow, the shape of the public surface, the integration points with the rest of the system. The agent does not have a strong opinion about any of this; it follows the lead you set. If you set a bad lead, the agent generates a lot of code very confidently in the wrong direction.

**Review and judgment.** I read more code now than I ever have. Most of it I did not write. The reading skill, evaluating whether a stretch of code is correct, whether it has the right error handling, whether it interacts cleanly with the rest of the system, has become the primary engineering skill. Writing code was once 60% of the job. Now it is closer to 10%. Reading code is closer to 60%.

**Knowing when to stop the agent.** Agents will keep working. They will refactor what does not need refactoring. They will add scaffolding for problems you do not have. They will silently make architectural decisions while you are getting coffee. The discipline to interrupt, redirect, and reject is the new craft.

**Time horizon compression.** What used to be a two-week project ships in two days. The implication is not that there is suddenly more leisure. The implication is that you can run ten parallel two-day projects across the same calendar. Which means you need ten times the judgment about which ones are worth running.

The shape of the work is fundamentally different. Not less, just different.

## This is not vibe coding

There is a term going around: "vibe coding." It refers to typing a prompt at a model, looking at what it gives you, feeling roughly okay about it, and shipping. The vibe is right. The code went somewhere. Good enough.

That is not what disciplined AI-assisted development is, and the distinction matters. I wrote a separate essay on this: [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/). The short version: agent mode in the hands of an experienced engineer is a force multiplier. The same tools in the hands of someone who never learned to read code carefully produce confident-looking output that nobody can confidently maintain. The market is going to discover the difference at significant expense.

Hold the line on engineering discipline. Tests still matter. Code review still matters. The architecture decisions you make at the start still determine what you can build later. The agent does not absolve you of any of that; it just removes the typing.

## The skills that compound now

After fifteen months of running production work this way, here are the skills I see compounding fastest:

1. **Specification writing.** The ability to describe what you want with enough precision that a model can do the right thing on the first try. This is not a soft skill. It is the new core competence.

2. **Code reading at speed.** You will read more code than you write. The faster you can absorb an unfamiliar codebase, identify the meaningful surface, and notice what is wrong, the more leverage you have.

3. **Architecture instincts that hold under speed.** The agent moves fast. Your architecture intuitions need to be loaded into reflexes, not derived from first principles every time. The senior engineers who already had this are now five times more productive. The ones who never built the muscle are exposed.

4. **Knowing the system you are operating in.** Production infrastructure, CI/CD, observability, security. The agent will happily ship code that runs perfectly in a sandbox and explodes in production. Knowing how the real environment behaves is, if anything, more valuable now.

5. **Stopping yourself.** Restraint is engineering judgment. The temptation to do more, faster, just because you can, is the most expensive new failure mode.

## The arc this site has been tracing

This is not a take I formed this month. The shift has been visible for over a year. I documented it in real time across a seven-part series:

- Part 1, [The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/): what it felt like the first time a model produced code at machine speed.
- Part 2, [The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/): the working pattern that emerged after the initial shock.
- Part 3, [Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/): when the same agent workflows moved into Dockerfiles, CDK stacks, and CI pipelines.
- Part 4, [Content Pipeline](/2025/08/10/ai-assisted-development-part-4-content/): how the discipline ports from code to long-form writing.
- Part 5, [Business Apps](/2025/08/29/ai-assisted-development-part-5-business/): production-grade business software built solo with AI.
- Part 6, [Future Impact](/2025/10/17/the-ai-development-revolution-part-6-future-implications/): the economic and professional implications.
- Part 7, [Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/): the patterns that emerged once the work had run for months.

The book-length treatment is [AgentSpek](/books/agentspek/), available on Amazon in paperback and Kindle, and free to read here in full. AgentSpek goes deeper on the specific working patterns, what to delegate, what to direct, and where the edges of agent mode actually are.

## What this means for a working engineer in 2026

Three concrete recommendations:

**Spend more time on the spec, less on the prompt.** A good specification produces good code. A clever prompt produces clever-looking code. They are not the same thing. Treat the agent like a junior engineer who reads very fast but cannot read your mind. Tell it precisely what you want.

**Invest in reading.** Read code from other people's repos. Read it from the agent's output. Read it from your own past self. The reading muscle is the one most engineers underdeveloped because they got away with mostly writing. That window is closed.

**Keep shipping things end to end.** The temptation in this moment is to over-think, under-decide, and spectate the discourse. The advantage compounds for engineers who keep shipping real software in this new mode, learning what actually breaks, and adjusting. The longer you wait to actually use these tools at production stakes, the further behind the curve you fall.

The work changed. It did not get easier. It got more concentrated, more leveraged, and more dependent on judgment. The engineers who already had judgment are now operating at multiples of their previous output. The ones who were coasting on typing volume are exposed. The honest field report is: this is the best time to be a careful, disciplined, production-minded engineer that I have seen in my career.

## Continue reading

- [DevOps Beyond Automation](/2026/05/27/devops-beyond-automation/), the companion cornerstone on what compounds in a platform-engineering career when agents do the typing
- [AI-Assisted Development Is Not Vibe Coding](/2026/05/07/ai-assisted-development-is-not-vibe-coding/), the standalone essay on the distinction
- [AgentSpek](/books/agentspek/), the book-length treatment, free here and on Amazon
- [The AI Development Revolution series](/series/ai-development-revolution/), seven parts written in real time
- [What I'm Building Right Now: May 2026](/2026/05/07/what-im-building-right-now-may-2026/), the current workstreams
- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/), the temporal framework that runs alongside the work]]></content:encoded>
      <pubDate>Wed, 27 May 2026 16:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/27/how-ai-is-changing-software-engineering/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2026/05/how-ai-is-changing-software-engineering-hero.webp" type="image/jpeg"/>
    </item>
    <item>
      <title>What Is People of the Stars? A Non-Human Clock for Decision-Making</title>
      <link>https://joshuaayson.com/2026/05/26/what-is-people-of-the-stars/</link>
      <description>People of the Stars (POTS) is a temporal intelligence framework that uses real astronomical data as a non-human clock for decision-making, with positioning logic borrowed from options trading. This is the explainer page for the framework and how it sits alongside decanal journaling.</description>
      <content:encoded><![CDATA[People of the Stars, POTS, is a framework for using astronomical time as a shared, non-human reference clock for decision-making. It pairs the 36-decan calendar (see [What Is Decanal Journaling?](/2026/05/26/what-is-decanal-journaling/)) with positioning logic borrowed from options trading. The result is a way to ask "where am I in the year, and what kind of move does that suggest?" that doesn't depend on a social-media news cycle, a quarterly business calendar, or the next Federal Reserve announcement.

This page is the short version. POTS is also a working software project, a CLI in the OA tooling stack used for the "WHEN" layer of a daily-practice routine. The software is private; this is the framework write-up.

## The problem

Almost every clock we make decisions against is human-made and short. The news cycle. The work calendar. The earnings calendar. The election cycle. Every one of them runs at a frequency that's tuned to grab attention, not to match the time it actually takes for important things to happen.

This produces a specific pathology: we keep making strategic moves on tactical clocks. Quarterly objectives where the real arc is multi-year. Daily-news reactions where the real signal is decadal. Weekly check-ins where the actual cycle is ten days, or thirty, or a hundred and twenty.

You can't fix this by ignoring those clocks. They drive the world. But you can layer a different clock underneath them, one that doesn't move at the speed of headlines, and use *that* one for the decisions that matter most.

The stars are the obvious candidate. They've been the canonical non-human clock for 5,000 years.

## The framework

POTS has three layers.

**Layer 1: the decanal calendar.** The 36-star, 10-day-cycle structure from [decanal journaling](/2026/05/26/what-is-decanal-journaling/). This is the temporal substrate. Every day belongs to a known decan with a known star and a known archetypal frame. You always know where you are in the year, not as "the 147th day of 2026" but as "day 7 of [Markab](/2025/11/14/decan-24-markab-building-systems-that-outlive-you/), late autumn, the building-systems decan."

**Layer 2: positioning, not prediction.** This is the part borrowed from options trading. An options trader doesn't try to predict where the underlying will close on Friday; that's a coin flip. The trader picks positions whose payoff structure tolerates being wrong about direction. The right question isn't "what will happen?" It's "what position would I be glad I held under multiple outcomes?"

POTS uses the same logic on time. You don't try to predict what's coming this decan. You ask what kind of position you'd be glad to hold *no matter what comes*. Some decans favor building. Some favor preserving. Some favor exiting. The decan's frame gives you a position, not a prediction.

This is the [Antifragile](/2025/12/29/antifragile-by-nassim-nicholas-taleb/) frame at the tactical level: optionality, asymmetry, surviving variance, harvesting gains when the world moves your way. POTS makes it operable.

**Layer 3: the daily practice loop.** What you actually do every morning to use the system:

1. Note which decan you're in. (Star + day-of-decan.)
2. Note the position the decan suggests. (Build / preserve / exit / reset.)
3. Choose today's three things in light of that position.
4. Log friction at the end of the day.

The full daily-practice integration involves two sibling tools (situational-governance for "WHERE you are" and FlowHelm for "WHO you are becoming"). POTS is the WHEN. The integration is documented in `DAILY-SYSTEMS-INTEGRATION.md` for users of the OA tooling stack.

## Why not astrology

POTS is not astrology and the distinction matters more than it usually does for "not astrology" framings.

- **Astrology claims causal influence.** The position of celestial bodies at your birth (or now) supposedly *causes* outcomes in your life. POTS makes no such claim. The stars are reference points, not influences.
- **Astrology uses zodiac signs.** Twelve solar-month bands with mythological themes. POTS uses 36 decans named for *actual bright fixed stars* with documented astronomical properties (spectral class, distance, age, magnitude). Different objects, different math, different framing.
- **Astrology is predictive.** "This month you will meet someone." POTS is *positional*. "This decan favors clean starts; what would you build differently if you treated the next ten days as a clean start?"
- **Astrology comes from medieval European reinterpretations of older systems.** POTS goes back to the source material (ancient Egyptian decans) and pairs it with modern financial-decision frameworks. Different lineage.

It's possible to be interested in the same sky and not believe the same things about it. POTS is what that looks like from the systems-engineering side.

## Why "People of the Stars"

The name comes from the practice itself. The Egyptian priests who built the decanal calendar used the stars as the ground truth for time. They scheduled the year around them. They named the months after them. Living that way makes you, in a literal sense, a person of the stars. Your year has stellar names. Your decisions are organized against a sky-based clock. Your reference frame is older than agriculture.

That's the framing. Not "you're under the stars' influence" but "you've chosen the stars as your reference."

## How POTS shows up in this site

The user-facing artifacts of POTS so far:

- **The Decan Log book**, published. [Read here](/books/the-decan-log/) or [Amazon](https://www.amazon.com/dp/B0H2VHP7CB?tag=organicartsll-20). The book is the long-form explanation of the decanal calendar layer.
- **The decanal journal**, ongoing. The [running journal](/journal/) is the practice in operation, one decan at a time.
- **This explainer**, plus the [decanal journaling explainer](/2026/05/26/what-is-decanal-journaling/). The framework and the practice, in short form, for new readers.
- **The book reviews under Books & Ideas**, especially [Antifragile](/2025/12/29/antifragile-by-nassim-nicholas-taleb/), [The Man Who Solved the Market](/2025/12/04/the-little-book-of-trading-options-like-the-pros/), and [The Little Book of Trading Options Like the Pros](/2025/12/04/the-little-book-of-trading-options-like-the-pros/), all of which inform the positioning-not-prediction layer.

The underlying CLI software is private. The framework, the calendar, and the practice are public.

## What POTS is for, in one sentence

If you're trying to make a decision and the news cycle is screaming, POTS gives you a different, slower clock to check against, one rooted in the actual sky and tuned to the rhythms of multi-week development rather than multi-hour reaction.

## Continue reading

- [What Is Decanal Journaling?](/2026/05/26/what-is-decanal-journaling/), the practice that runs on top of POTS
- [The Decan Log book](/books/the-decan-log/), the full framework, 36 chapters
- [Antifragile by Nassim Nicholas Taleb](/2025/12/29/antifragile-by-nassim-nicholas-taleb/), the positioning logic in book form
- [Pale Blue Dot by Carl Sagan](/2025/12/28/pale-blue-dot-carl-sagan-vision-human-future-space/), the cosmic perspective from the same sky
- [The Decan Log introduction](/books/the-decan-log/introduction/), the long-form opening chapter]]></content:encoded>
      <pubDate>Tue, 26 May 2026 20:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/26/what-is-people-of-the-stars/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/books/decan-log-cover.jpg" type="image/jpeg"/>
    </item>
    <item>
      <title>What Is Decanal Journaling? The 36-Star Calendar and the Practice</title>
      <link>https://joshuaayson.com/2026/05/26/what-is-decanal-journaling/</link>
      <description>Decanal journaling is a practice built on the 36-star Egyptian calendar: ten-day cycles, each ruled by a bright fixed star, replacing the arbitrary seven-day week. This is the explainer page for the practice and the framework underneath it.</description>
      <content:encoded><![CDATA[A decanal journal is a journal organized in 10-day cycles instead of 7-day weeks. Each cycle is anchored to a bright fixed star. There are 36 of them, plus five days outside the count, and together they cover the year.

The practice didn't start with me. It started in ancient Egypt, around 2500 BCE, when priests divided the night sky into 36 strips and used the helical risings of bright stars to mark time. The stars were the clock. The clock was the calendar. The calendar was how you knew where you stood in the year.

I'm using the same skeleton, modernized. The book that documents it is [The Decan Log](/books/the-decan-log/). This page is the short version, written for someone who arrived here from a search and wants to know what "decanal journaling" means before deciding whether to keep reading.

## The thirty-six stars

The year breaks cleanly into 36 ten-day cycles. Each cycle is named after a star you can actually observe in the sky:

- **Decan 1: [Hamal](/2026/03/29/decan-01-start-clean/)**, the Aries lead, opens at the spring equinox.
- **Decan 23: [Scheat](/2025/11/04/decan-23-scheat-blooming-in-the-desert/)**, late autumn, the moment things bloom in the dark.
- **Decan 25: [Enif](/2025/11/25/decan-25-enif-when-hidden-star-teaches-vision/)**, hidden-star season.
- **Decan 33: [Bellatrix](/2026/02/25/decan-33-bellatrix-when-sword-arm-strikes/)**, will and strategy and leadership.
- **Decan 36: [Sothis](/2026/03/14/decan-36-sothis-the-dog-star-sees-what-the-hunter-doesnt/)**, the dog star, the cycle's closing.

After Decan 36 come the five [epagomenal days](/2026/03/19/epagomenal-days-five-days-outside-time/), the days that "fall outside the count." Egyptians treated them as outside-the-system time, neither part of the year that ended nor the one beginning. The book has its own chapter on them.

Thirty-six tens plus five gives 365. The arithmetic is older than every other calendar still in use.

## Why ten days instead of seven

The seven-day week isn't aligned with anything physical. It comes from Babylonian astronomy assigning planets to days, and the pattern stuck because it was practical for trade. Useful, but arbitrary. Seven days isn't long enough for a theme to develop, integrate, and clear. By the time you've settled into a rhythm, the weekend resets it.

Ten days behaves differently. A decan has room for a beginning, a middle, and an end. You can run a small project across one. You can read most of a book inside one. You can let a question sit, work, and resolve.

The three-phase rhythm I use inside each decan is:

1. **Initiate** (days 1–3): set the question, the project, the focus.
2. **Flow** (days 4–7): do the work without re-litigating the choice.
3. **Reflect** (days 8–10): write what happened, decide what carries.

It maps cleanly onto how attention actually moves. The work week / weekend split doesn't.

## Why anchor to stars

You could divide the year into 10-day blocks and not name them after anything. That works as a schedule. It doesn't work as a frame.

Each star carries a real astronomical fact: a temperature, a distance in light-years, a stellar type, a position in a constellation. **Denebola's photons left in 1989. Alpheratz is 97 light-years away. Hamal is an orange giant on the helium-burning side of its life.** Those aren't metaphors. They're context. They give a decan a physical weight that a numbered calendar slot doesn't have.

The star also gives the decan a name you can remember. "Decan 11, Regulus" sticks in a way that "the fourth quarter of the third trimester" does not. The naming convention is part of what makes the practice durable.

This is not astrology. There's no claim that the star influences events on Earth, or that the decan's themes are predictions. The themes are reference frames. Hamal's "clean start" theme exists because Hamal opens the year at the spring equinox, not because the photons from a star 66 light-years away have causal power over your decision-making. Big distinction. [Pale Blue Dot](/2025/12/28/pale-blue-dot-carl-sagan-vision-human-future-space/) is the cosmic-perspective frame; this is the calendrical one.

## What the practice actually looks like

The journal entry on the first day of a decan opens with:

- The star, its astronomical facts, its archetypal theme
- A question or focus for the ten days
- What the previous decan closed with that's still active

The middle days are normal journaling, but with the awareness that this decan has a shape and a name. The closing day or two:

- What happened
- What carried over
- What gets passed to the next star

You can see the pattern in real entries. [Decan 23 Scheat](/2025/11/04/decan-23-scheat-blooming-in-the-desert/), [Decan 24 Markab](/2025/11/14/decan-24-markab-building-systems-that-outlive-you/), [Decan 25 Enif](/2025/11/25/decan-25-enif-when-hidden-star-teaches-vision/). Same shape, different content, in sequence.

After a year of this, you have 36 short essays organized by star, plus the five outside-time days, plus whatever else accumulated in the freewriting pages. The structure does most of the work of remembering for you.

## What this is not

- **Not astrology.** No claim that stars cause anything. The stars are reference points.
- **Not a productivity system.** It doesn't optimize output. It frames attention.
- **Not religious.** The Egyptian origin is historical, not devotional.
- **Not a replacement for the Gregorian calendar.** Pay your bills on the calendar everyone else uses. The decanal cycle runs alongside, on top, underneath.
- **Not new.** It is 4,500 years old. I'm relearning what was already known.

## Where to begin

If you want the full framework, start with [The Decan Log](/books/the-decan-log/), the book. The introduction chapter ([Living by the Stars](/books/the-decan-log/introduction/)) covers everything above in more depth, including the math, the history, and the practice.

If you'd rather sample first:

- The [full journal feed](/journal/) is every decan entry in order. About 30 of 36 are written as of this writing.
- The book's individual star chapters are at `/books/the-decan-log/<star>/`. The clearest entry points are [Hamal](/books/the-decan-log/hamal/) (the year-opening star), [Sothis](/books/the-decan-log/sothis/) (the year-closing one), and [Epagomenal Days](/books/the-decan-log/epagomenal-days/) (the five outside-time days at the end).

The Decan Log book pairs with [People of the Stars](/2026/05/26/what-is-people-of-the-stars/), the broader temporal framework. POTS is about using astronomical time as a non-human clock for decision-making; decanal journaling is the daily practice that operates on top of that clock.

## Continue reading

- [What Is People of the Stars?](/2026/05/26/what-is-people-of-the-stars/), the framework underneath the practice
- [The Decan Log book](/books/the-decan-log/), the full 36-chapter framework
- [Decan 1: Hamal and a Clean Start](/2026/03/29/decan-01-start-clean/), the first journal entry
- [Epagomenal Days: Five Days Outside Time](/2026/03/19/epagomenal-days-five-days-outside-time/), the year's closing
- [All decan journal entries](/journal/), the running practice]]></content:encoded>
      <pubDate>Tue, 26 May 2026 19:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/26/what-is-decanal-journaling/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/books/decan-log-cover.jpg" type="image/jpeg"/>
    </item>
    <item>
      <title>AI-Assisted Development Is Not Vibe Coding</title>
      <link>https://joshuaayson.com/2026/05/07/ai-assisted-development-is-not-vibe-coding/</link>
      <description>&quot;Vibe coding&quot; means throwing prompts at a model and hoping it works. That is not what AI-assisted development is. The difference matters, and it is the difference between amateur hour and professional craft.</description>
      <content:encoded><![CDATA[# AI-Assisted Development Is Not Vibe Coding

There is a term circulating in the industry right now: "vibe coding." It refers to a style of development where you type a prompt at an AI model, look at what it generates, feel roughly okay about it, and ship. The vibe is right. The code went somewhere. Good enough.

I want to push back on something. Not on using AI to write code. I do that every single day. I have built a chip tune synthesizer, an animated film studio, a volatility trading dashboard, a book, and a browser-based game museum, all with AI assistance at the center of every session. But what I am doing is not vibe coding, and the distinction matters more than most people are willing to admit right now.

---

## What Vibe Coding Actually Is

Vibe coding is not lazy or stupid. It is a reasonable response to a genuinely confusing moment. AI models can now produce functional code from natural language descriptions. If you do not already know how to program, the temptation is to treat this as an unlock. You describe what you want. You accept what the model gives you. You move it into production. You tell yourself the model is reliable enough that critical evaluation is not really necessary.

That is the vibe. The vibe is: this looks about right, and checking closely would slow me down.

The problem is not the AI. The problem is the lack of a theory about what is happening. The vibe coder has no model of what the code is doing, which means they have no model of what it might do wrong, which means they cannot catch the errors the model makes. And the model does make errors. It makes them confidently. It makes them in ways that are invisible if you are not actively looking for them.

Security vulnerabilities are one category. Subtle logic errors are another. Architectural decisions that feel sensible locally but compose into a mess at scale are a third. The vibe coder meets all of these in production, where they are expensive, and has no theory about why they are happening.

---

## What AI-Assisted Development Actually Requires

When I use Claude in agent mode to build something, the session does not start with a prompt. It starts with me knowing what I am trying to build and why. I have a mental model of the system: its components, their boundaries, the data flowing between them, the failure modes I care about.

The AI is not directing that. I am directing it. The AI is amplifying my ability to execute.

That distinction sounds subtle but it is the whole thing. When the model proposes an approach I would not have chosen, I notice. Not because I know better than the model on every technical question. Because I know what the system is supposed to do, and I can evaluate whether the proposal gets me there. When the model makes an error, which it does regularly, I can see it because I have a theory of what correct looks like.

This requires skill. It requires the ability to read code, understand it, and evaluate it against a standard you carry in your head. It requires knowing what questions to ask the model to surface its assumptions. It requires the discipline to slow down when something feels off rather than accepting it because the vibe seems right.

Agent mode specifically asks more of you, not less. In a normal editor workflow, the model suggests one line at a time and you approve or reject it. In agent mode, the model executes sequences of operations autonomously. It reads files, writes files, runs commands, makes architectural decisions in real time. The power is real. But so is the surface area for error. You need to be paying close attention, not coasting on vibes.

---

## A Concrete Example

I recently directed the production of a three-and-a-half-minute animated rap film called [The Intruder](/projects/the-intruder/). It involves seven passes of animation rendering, voice synthesis through ElevenLabs, autotune processing with Rubberband, a custom chip tune music score, and a final FFmpeg mix pipeline that takes all the stems and produces a finished MP4.

None of that code appeared from nowhere. The AI generated large portions of it. But every generation was preceded by a design decision I made: which vocal persona, what BPM, how to handle the timing retime when ElevenLabs clips run long, what FFmpeg filter chain achieves the sidechain pump effect I wanted. And every generation was followed by evaluation: does this actually do what I intended, are there any edge cases I need to handle, does this compose correctly with the other parts of the system.

That process took about twelve passes across multiple sessions. A vibe coder would have stopped at pass three when it "basically worked." I kept going because I had a clear standard in my head and the output had not met it yet.

The difference between those two approaches is not whether AI was used. Both used AI heavily. The difference is whether the human was directing a craft process or just accepting outputs and hoping.

---

## Why It Matters

There is a version of the future where "vibe coding" normalizes across the industry and the result is a lot of software that nobody fully understands, deployed by people who cannot debug it, maintained by no one. The models will get better, but the fundamental problem is not model quality. It is the absence of a human who can evaluate and take responsibility.

Security is the sharpest edge of this problem. Models will generate code with SQL injection vulnerabilities. They will omit authentication checks. They will store secrets in ways that are trivially discoverable. They will do this without any indication that something is wrong, because they are predicting plausible code, not reasoning about whether it is safe. The vibe coder will not catch any of this.

Professional accountability is another edge. If you deploy something and it goes wrong, someone will ask you to explain it. "The AI wrote it and I thought it looked fine" is not a professional answer. It may not even be a legal one, depending on the domain.

The industry is going to figure this out the hard way. There will be a wave of AI-generated incidents: breaches, outages, embarrassing failures. And then there will be a correction, and the correction will be: you need engineers who understand what the AI is generating, not operators who are just approving it.

---

## The Professional Standard

The right framing is not "can AI write code?" The right framing is "what does it take to work with AI at a professional standard?"

That standard looks like this: you come to the session with intent. You direct the work. You evaluate every output. You maintain architectural coherence across sessions, because the model has no persistent memory of what you are trying to build. You catch errors before they compound. You take responsibility for the result.

None of that is easy. But it is not harder than traditional software engineering. It is approximately the same bar, with a very powerful new tool available inside it.

The vibe coder is not using that tool well. They are using it as a replacement for skill they do not have. The AI-assisted engineer is using it as an amplifier for skill they do have.

That amplification is genuinely transformative. I can build things now that would have taken a team months, and I can build them alone in weeks. But that leverage only exists because I know what I am doing and I can direct the process intelligently.

Drop the underlying skill, and you drop the leverage with it. You are left with vibes and hope. In production, that is not a strategy.

---

*I wrote a book called [AgentSpek](/books/agentspek/) that covers the methodology for working with AI in a disciplined way, including how to think about prompt craft, agent mode oversight, and architectural intent. The [projects section](/projects/) shows what this approach produces in practice. If you are new here, [start here](/start-here/).*]]></content:encoded>
      <pubDate>Fri, 08 May 2026 00:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2026/05/07/ai-assisted-development-is-not-vibe-coding/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      
    </item>
    <item>
      <title>The Complete AI Development Revolution: 7-Part Series on Coding with AI</title>
      <link>https://joshuaayson.com/2025/12/06/ai-development-revolution-complete-series/</link>
      <description>Complete guide to the AI development revolution. Seven parts covering methodology, infrastructure, content, business, and the future of coding.</description>
      <content:encoded><![CDATA[# The Complete AI Development Revolution: 7-Part Series

This is the index page for the whole series. Seven parts, written over about six months while I was actually doing the work, not after. Most of it came out of journal entries and git histories, so the dates and the mistakes are real. If you only read one thing, start with Part 1 and follow the links.

I built four projects in parallel during this stretch, mostly solo, mostly faster than I expected. The series is my attempt to write down how, and where it stopped being useful.

## The seven parts

### Part 1: The Awakening

What it felt like when the speed changed. The tiredness, the acceleration, learning to think alongside a machine instead of just typing into one. This one is the human side of it, before any of the workflow.

[Read Part 1](/2025/07/30/ai-assisted-development-part-1-the-awakening/)

Covers: the moment it shifted, mental acceleration, the four parallel projects, and the early learning curve.

---

### Part 2: The Methodology

The workflows I ended up with after a few months of doing it wrong. Context management, quality checks, fast prototyping, and debugging with the model in the loop. This is the practical one if you want to start.

[Read Part 2](/2025/07/31/ai-assisted-development-part-2-methodology/)

Covers: context strategies, quality workflows, prototyping patterns, debugging, and code review.

---

### Part 3: Enterprise Infrastructure

Building AWS systems faster than I thought was reasonable. CDK stacks that I expected to take months, done in weeks. Includes the architecture calls I made and the ones I got wrong.

[Read Part 3](/2025/08/05/ai-assisted-development-part-3-infrastructure/)

Covers: AWS CDK with AI, infrastructure speed, architectural decisions, and production deployment.

---

### Part 4: The Content Pipeline

Turning years of handwritten journals and an old WordPress blog into something I could maintain. Building OCR that could read my cursive without flattening the voice out of it. Where the automation helped and where I had to take the work back.

[Read Part 4](/2025/08/10/ai-assisted-development-part-4-content/)

Covers: OCR pipelines, keeping the voice, editorial automation, and quality checks.

---

### Part 5: Business Transformation

How working this way changed what I could do alone, and what it did to pricing and the kind of work I took on. The economics of going a lot faster.

[Read Part 5](/2025/08/29/ai-assisted-development-part-5-business/)

Covers: working solo, business models, pricing, and where the advantage actually comes from.

---

### Part 6: Future Implications

Where I think this goes. What happens when every developer has this, how the job changes, and which skills still matter when the typing gets cheap.

[Read Part 6](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)

Covers: how the role evolves, new skills, what the model still cannot do, and the wider change to the industry.

---

### Part 7: Advanced Patterns

The patterns I leaned on once the basics were boring. Context architecture, reasoning across many files, testing, and generating code at scale without losing the thread.

[Read Part 7](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)

Covers: advanced context, multi-file reasoning, AI-assisted testing, code generation, and quality.

---

## Where to start

If you are new to this, read Part 1 and then Part 2.

If you want practical workflows now, read [Agentic Development](/2025/12/06/agentic-development-ai-agent-workflows/) and then Part 2.

If you have a specific domain in mind:

- Infrastructure: [Part 3](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- Content: [Part 4](/2025/08/10/ai-assisted-development-part-4-content/)
- Business: [Part 5](/2025/08/29/ai-assisted-development-part-5-business/)

If you have done a lot of this already, skip to [Part 7](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/).

## What actually came out of it

The numbers below are from the projects in the series, not from a benchmark. Take them as a record, not a promise.

On infrastructure, a CDK migration that I would have budgeted two or three months for took about a week. A multi-service AWS setup came together in days. Permission debugging that used to eat days took hours.

On content, I processed more than three hundred journal entries through an OCR pipeline I wrote from scratch, and the editorial voice survived it.

On the business side, I shipped full-stack Flutter web apps in days and iterated on design about as fast as I could think of changes, solo, at a quality I was willing to put my name on.

Speed varied a lot by task. Greenfield features moved the most. Working inside an existing codebase moved less, and debugging less than that, but all of them moved.

The quality went up too, mostly because I could ask for a second read on every change, explore more architecture options before committing, and write more tests than I would have had the patience for otherwise.

## The methodology, briefly

Five workflows did most of the work:

1. Prototyping, to get to a first working version fast
2. Debugging, to find root causes quicker
3. Code review, to catch things before they shipped
4. Architecture, to think through the harder systems
5. Learning, to pick up a new tool when I needed one

The patterns under all of them are the same. Manage context, which is the skill that matters most. Keep your own judgment on quality. Refine in conversation instead of expecting one prompt to nail it. Verify in production. And do the architecture yourself; the model assists, it does not decide.

[The workflows in full are in Agentic Development.](/2025/12/06/agentic-development-ai-agent-workflows/)

## Who this is for

This is written for working developers. Software engineers trying the tools, people working solo who want to do more, technical leads trying to understand the change, and anyone shipping real software.

It is not written for people hoping the model will do everything, or looking for a no-code shortcut, or trying to skip the technical parts. The more development experience you bring, the more useful this is.

## A few questions I get

Do you need Claude specifically? No. The patterns work with any capable model. I use Claude because the longer context and the architectural reasoning suit how I work.

Will this replace your job? No. It speeds you up. You are still the one architecting, checking the work, and making the calls.

How much experience do you need? More helps. Beginners can get something out of it, but experienced developers see the bigger jump.

Is this real or hype? It is from real projects, with git histories and deployed systems behind it. The results are what I measured, nothing more.

How long until it shows? In my own case, the first week was a small bump. By the second week I trusted it for debugging and prototyping. By the first month the workflows had settled, and by a few months in I did not want to work the old way.

## Related reading

Practical guides:

- [Agentic Development: How to Build Software with AI Agent Workflows](/2025/12/06/agentic-development-ai-agent-workflows/)
- [Vibe Coding with AI](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration/)

More reflective pieces:

- [The Multithreaded Mind](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed/)
- [Living Through the AI Revolution](/2025/05/31/living-through-the-ai-revolution-reflections-on-creativity-balance-and-the-modern-gold-rush/)
- [Layers of Abstraction](/2025/06/02/layers-of-abstraction-poetic-musings-on-creativity-balance-and-the-modern-mind/)
- [I AM AI SLOP: Confessions from the Forge](/thoughts/i-am-ai-slop/), on owning AI collaboration and what separates craft from waste

## Reading order

For the whole thing in order: Part 1, Part 2, the Agentic Development guide, then whichever domain part fits you (3, 4, or 5), then Part 6 and Part 7.

If you want results fast: the Agentic Development guide, Part 2, then Part 7.

By domain:

- Infrastructure and cloud: Parts 1, 2, 3, 7
- Content and publishing: Parts 1, 2, 4, 7
- Business and freelance: Parts 1, 2, 5, 6

The series runs about seven parts and a few hours of reading. It was written across six months of real work, and it reads like that, with the false starts left in.

[Start with Part 1: The Awakening.](/2025/07/30/ai-assisted-development-part-1-the-awakening/)]]></content:encoded>
      <pubDate>Sat, 06 Dec 2025 23:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/12/06/ai-development-revolution-complete-series/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/12/ai-development-series-complete-guide.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 7: Advanced Patterns</title>
      <link>https://joshuaayson.com/2025/10/18/ai-development-revolution-part-7-advanced-patterns/</link>
      <description>Advanced patterns from a game I built. Interfaces, metadata, batch operations, and what it takes to make code a machine can actually work in.</description>
      <content:encoded><![CDATA[# Advanced Patterns

*Part 7 of the AI Development Revolution. The patterns here came out of one game, and I did not plan any of them.*

## A game taught me the rest

I went back through the repository for a small physics game I had built, expecting to clean it up. What I found instead was that the code had organized itself, over weeks of working alongside the machine, into shapes that made the machine useful. Not because I designed it that way. Because every shape that made the AI stumble eventually got rewritten until it stopped stumbling.

The game is simple to describe. You tilt the device, a ball rolls through a maze, obstacles get in the way. Underneath it there is a level system, a physics layer, difficulty that adjusts itself, and a test pass that runs on every level. The mechanics were never the interesting part. The way the code had to be built so an AI could help with it was.

I wrote in ["Living Through the AI Revolution"](/2025/05/31/living-through-the-ai-revolution-reflections-on-creativity-balance-and-the-modern-gold-rush) that this shift changes how I think, not just how I build. This essay is the most concrete version of that I have.

## Interfaces are how the machine finds its way

The first thing that mattered was interfaces. I had always treated them as good practice. Here they turned into something more useful: a map the AI could read without reading everything.

```dart
abstract class LevelManagerInterface {
  Future<void> initialize();
  Level get currentLevel;
  List<Level> get orderedLevels;
  // ... clear contracts for everything
}
```

When the AI needed to change the level system, it did not have to load the whole implementation into its head. It worked against the contract. That kept it focused and kept it from breaking things it had not read. Clear boundaries meant safe changes, even when I was moving fast and changing a lot. The interface was as much for the machine as for me.

## Metadata is a layer you can move without breaking anything

Separating the data about a level from the level itself gave me a second handle. The AI could read and change properties without touching the actual implementation.

It could reorder levels by their calculated difficulty, scan for quality problems, write up a report, and update hundreds of levels in one pass, all by working on the metadata alone. None of that touched the code that ran the game, so none of it could corrupt it.

What had been slow manual work became something I could trust to run on its own. That part surprised me. I expected efficiency. I did not expect it to feel clean.

## Testing the machine can run, not just pass

The tests changed too. They stopped being a checklist and started being the thing that let me make aggressive changes without fear.

The level system checks goal placement, pathfinding, the physics, and performance. Load times under 100ms. Frame rates above 60. Each test is a way for the AI to catch a problem I would have missed. It validates hundreds of levels at once, fixes the common problems itself, and flags the strange ones for me. I read the flagged ones. The rest I let it handle.

## Difficulty that sorts itself out

I stopped assigning difficulty by hand. Instead the system calculates it from obstacle complexity, path length, physics, and time pressure, and lets each level find its own place in the order.

A weak level sinks in the rankings. A strong one rises. The AI makes decisions off those numbers, new levels slot themselves in where they belong, and the whole thing reorganizes when something changes. The balance comes out of the data instead of out of my gut, and for this kind of game my gut was wrong often enough that I was glad to hand it over.

## Batches, because that is how the machine thinks

The AI works in batches. Once I noticed that, I built batch support into everything.

Validate a batch of levels, update difficulties in bulk, run a quality pass across all of them at once. Work that would have taken me hours finished in seconds, and stayed consistent across every change. The reason it worked was not just speed. The machine naturally handles sets rather than one thing at a time, and once the code matched that, the friction went away.

## Workflows that assume the AI is there

I stopped bolting the AI onto the project and started assuming it from the beginning. There are agents that generate batches of levels with set parameters, agents that improve weak levels without wrecking the core of the gameplay, and tests that run continuously and catch regressions before they spread.

Every change kicks off validation. Performance is benchmarked without me asking. Quality is watched as a live number. I do not babysit it. I read what it surfaces.

## Documentation written for a reader who is partly a machine

There is a `CLAUDE.md` in the repository, and it is not an afterthought. It is documentation written so the AI can act on it. The clean-architecture rules are stated plainly, the quality standards are given as numbers, the workflows are spelled out.

It ends up being a contract between what I mean and what the machine does. The file structure does the same thing in a quieter way: clear hierarchies, obvious purposes, so an agent can find what it needs without me steering every step.

## Performance so the AI does not stall

The optimizations were not only about making the game fast. They were about keeping the AI's work from stalling. Lazy loading so an agent can read metadata without paying for the full data. Caching shaped around the access patterns the AI actually has. Background processing so nothing blocks.

The point is that AI speed needs infrastructure under it. If the data is hard to move through, the help slows to a crawl. Make it navigable and the help stays useful.

## What the game taught me

A few things came out of this that I now reach for by default. Interfaces as a map. Metadata as a layer you can move safely. Tests as the thing that lets you change boldly. Batches because that is the machine's grain. Documentation written for the machine as much as for me.

None of it came from theory. It came from doing the work and noticing what made the AI useful and what made it useless. And it connected backward. The interface habit came from the infrastructure work in Part 3. The testing came from the quality obsession. The batch thinking came from the content pipeline in Part 4, where scale broke my assumptions. I just did not see the pattern until the game put it all in one place.

## What it costs

I will not pretend this is free. Architecture this deliberate takes real setup, and most projects do not need it. Keeping documentation that serves both me and the machine roughly doubles the writing. The test infrastructure is an investment. Holding the traditional way and the AI way in your head at the same time has a cost of its own, and it is not small.

So the trade is the same one I keep coming back to across this whole series. The capability is real. So is the complexity that buys it. For this game it was worth it. For a throwaway script it would not be.

## Where it leaves me

These patterns are not a forecast. They work right now, in code I have shipped. The thing I keep coming back to is that the architecture mattered more than the tools did. The interfaces, the tests, the batches, the documentation, those are what made the difference, not which model I happened to be using.

I wrote in ["Vibe Coding with AI"](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration) and ["The Multithreaded Mind"](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed) about what it feels like to work this way, fast and strange and not quite human-only anymore. This is the part of it I can point at. Build the code so the machine can move in it, and the two of you can make something neither of you would have alone. That is the whole series, really, in one game I almost threw away.

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- **Part 7**: Advanced Patterns (Current)]]></content:encoded>
      <pubDate>Sat, 18 Oct 2025 12:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/10/18/ai-development-revolution-part-7-advanced-patterns/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-7-advanced-patterns.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 6: Future Impact</title>
      <link>https://joshuaayson.com/2025/10/17/the-ai-development-revolution-part-6-future-implications/</link>
      <description>The cognitive price of transformation. When individuals build enterprise systems at massive personal cost. Capability vs sustainability.</description>
      <content:encoded><![CDATA[# The AI Development Revolution: Part 6 - Future Implications

*Part 6 of the AI Development Revolution. Less about what I built and more about what it cost, and where I think this is going.*

## The part nobody puts in the case study

The numbers look good. Lower cost, faster builds, fewer defects. What the numbers leave out is what it took from me to get them.

I slept badly through the sprints. I spent whole days validating AI suggestions one at a time until I could not tell a good decision from a tired one. My back hurt. My eyes hurt. I lost track of people because the work wanted all of my attention and took it.

I wrote about this in ["The Multithreaded Mind"](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed). Working across every layer at once is a different way of being awake. Old development let me sink into one thing. This kind asks me to hold architecture, implementation, testing, business logic, and user experience in my head together, all the time. The mind is not built to run that hot for long.

Every suggestion needs checking. Every decision sits on top of the last one. You are managing context across a solution that keeps changing shape under you, doing quality control at a speed that was never meant for a person. That is the real bill.

## Cheap to make, expensive to carry

Enterprise software used to need an enterprise team. Now one person can build the thing that used to take a dozen specialists. What once cost hundreds of thousands costs tens.

The catch is that the cost did not disappear. It moved. Low money, high attention. Small team, one person carrying all of it. Fast iteration that only happens if someone stays at that intensity. You can afford the work now. You pay for it somewhere else.

That somewhere else is a person. That is the part I keep coming back to.

## What this does to the work

Agencies were built on dividing the work by specialty. AI flattens those divisions, and that sounds like a win until you live on the other side of it. The coordination overhead a team used to absorb does not vanish. It falls on one person. The timelines compress, but everything the old timeline held still has to happen, now in less time, from fewer people.

The human is still the bottleneck, and AI speed only makes that clearer. More projects means more validation, and validation does not scale the way generation does. The early adopters I know are tired in a way that is starting to look structural.

There is also a knowledge problem. When the workflow is this personal, almost none of it transfers. Decisions go undocumented because documenting them at machine speed is one more thing to do. Senior developers watch juniors with AI skills move faster than they can, and it shakes something loose in how they see themselves. The hard question for agencies is not whether they adapt the tooling. It is whether they can keep the people intact while they do.

Startups have the same shape. A solo founder can ship a real product now, no team required. The technical barrier is mostly gone. The personal one is not. I built enterprise infrastructure in weeks, and those weeks hid the rebuilds, the late nights fixing what the AI broke, the wrist pain, the cancelled plans. I was architect, developer, tester, and manager in one overloaded brain. The technical risk dropped toward zero while the cognitive risk climbed. Whether you make it stops depending on funding and starts depending on how much sustained intensity one body can take.

Enterprises ran on being slow, expensive, and predictable. AI takes the predictable part away. The coordination looks simpler from the outside, but it hides how much complexity one person is now holding. The limit is no longer the technology. It is endurance.

## The skills flipped

Knowing how to architect now matters more than knowing how to type the code. Judging quality matters more than producing it. Direction matters more than memorizing a framework the AI already knows cold. That order changed fast.

The real skill became working with the machine. Holding context across sessions, learning how it tends to fail, checking its output at a pace that pushes against what a person can do, inventing a way to work that nobody had a manual for yet.

Manual coding starts to feel old-fashioned. Memorizing frameworks feels pointless when the AI has all of them. Years of hard-won expertise can suddenly count for less than a few months of knowing how to collaborate with the thing.

That is the part that hurts. Senior developers asking what they are now worth. Juniors moving up on AI skill. Expertise that took a decade feeling thin next to a machine that does the same task without breaking a sweat. Adapting to this is not just learning a new tool. It is rebuilding who you thought you were at work.

## The market underneath it

Solo developers compete with agencies now. One consultant delivers what a team used to. A personal brand can pull work away from an established firm. The technical part of the service is becoming a commodity, and strategy is the part still made by a person.

You can validate a business with a working system instead of a pitch deck. Test an idea in days. The barrier to entering a market keeps dropping, and the cycle keeps shortening. Custom builds are starting to cost less than buying something off the shelf, which is not how any of this was supposed to go.

Education is behind. Memorizing facts is worthless when the AI holds all of them, and collaboration matters more than the facts, but the curriculum was written for the old world and is out of date before anyone graduates. The old shape is dissolving and the new one has not set.

## Faster used to mean worse

It does not anymore, at least not the way I expected. Building faster with the AI, with systematic checking on top, gave me higher quality, not lower. Fewer defects in production. Security done right the first time instead of bolted on later. Optimization that kept happening instead of waiting for a crisis. The machine caught things I would have walked past.

Quick iteration surfaced better answers because I could try several where the budget used to allow one. The quality came out of the speed, not in spite of it. I did not predict that, and it changed what I expect from a build.

## Wider than my desk

This does not stay inside the industry. A personal project can reach professional quality now. A small business can touch tools that used to belong to the giants. Entry barriers fall and competition gets sharper for it.

Developers become architects because the work demands it. Founders get freed from the risk of technical execution. The whole system speeds up as friction drops out of it. This is not happening in one corner. It is happening across the board.

## The things I do not have answers for

Quality control at machine speed, with a human as the slow step. Systematic checking helps, but it does not solve it.

A widening gap between people who have the new skills and people who do not. Traditional developers feeling written off. Training that cannot keep up with the change.

Business models breaking faster than anyone can rewrite them. And a quieter risk underneath all of it: the more the machine handles, the more human expertise quietly wastes away in the areas it touches. The knowledge survives only if someone decides on purpose to keep it.

These are real, and I do not have the fix. I would rather say that plainly than pretend otherwise.

## Where I think it is going

I will not give a timeline, because every timeline I have seen has been wrong. But the direction is visible in fragments. Game development is already showing AI-first architecture, interfaces designed for the machine to work against, metadata pulled out clean, patterns shaped for collaboration instead of for a human reader. That is Part 7.

The early adopters are pulling ahead while the rest of the field is still arguing about whether any of it is real. Mainstream adoption is coming. When, I cannot say.

What the predictions keep missing is the human in the middle. The cognitive cost compounds. The sustainability question stays open. I know the direction. I do not know how fast, and I have stopped pretending I do.

## What I would tell you

Experiment, but know what it costs. Write down the failures, not just the wins. Build with the price in mind instead of finding out about it later. Start small, measure the whole picture, and put the investment into people and not only tools.

This revolution changes more than software. It changed me. My capability went up while my capacity strained against it. Speed and quality stopped fighting each other, and the question of whether any of this is sustainable stayed unanswered.

I am not only learning how software gets built. I am finding out what a person becomes when they work this closely with a machine. The promise and the price showed up together, and I have stopped expecting one without the other. The future comes whether I am ready or not.

---

**Next**: [Part 7: Advanced Patterns →](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)

---

**Related Reflections:**
- [I AM AI SLOP: Confessions from the Forge](/thoughts/i-am-ai-slop/) - On the cultural backlash and owning AI collaboration

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- **Part 6**: Future Implications (Current)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Fri, 17 Oct 2025 12:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/10/17/the-ai-development-revolution-part-6-future-implications/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-6-future.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 5: Business Apps</title>
      <link>https://joshuaayson.com/2025/08/29/ai-assisted-development-part-5-business/</link>
      <description>How AI compressed business web development from months to days. Professional Flutter web app from one developer and AI collaboration.</description>
      <content:encoded><![CDATA[# The Business Transformation Sprint

*Part 5 of the AI Development Revolution. This was the one where I had to be the whole agency by myself and found out what that costs.*

## I needed a website for the company

Organic Arts LLC needed a real web presence. Something that showed what I do, let people get in touch, and looked like a company instead of a guy with a domain name. The vision was clear in my head. Getting it onto a screen was the problem.

The old way to do this is months of work and a team: a designer, a developer, a project manager, someone to test it. I had none of those. I had me, and I had AI, and I had to be every one of those people in the same afternoon.

So I was the designer and the developer and the project manager and the tester, switching between them every few minutes. That switching was the hardest part. You hold a creative idea in your head, then you have to drop it to fix a routing bug, and when you come back the idea has gone cold.

## Twenty-two commits and a lot of throwing things out

The repo tells the honest version. Twenty-two commits to get from nothing to a site I would actually put my name on. Three full UI redesigns. Two responsive frameworks I started and abandoned. Four color schemes I scrapped.

I built it in Flutter web because I wanted one codebase that worked everywhere, and because the retro look I was after needed more control than a template would give me. AI's first attempts missed the whole point. I asked for a sophisticated vintage feel and it gave me either generic corporate or dated HTML, and for a while it could not tell the two apart from what I actually wanted. Teaching it that difference took hours.

Then the practical things broke. Routing fell apart. Components clashed when I combined them. Retro fonts fought accessibility. None of it was the interesting kind of hard. It was just the work.

## Production found every assumption I had gotten wrong

Locally it looked finished. In production almost everything was wrong. SSL certificates refused to install. The site took twelve seconds to load. Navigation was unusable on a phone. Contact forms that worked on my machine broke for real visitors, which is the worst place to find out.

I tested across Safari, Chrome, Firefox, and Edge, and across fifteen or so device combinations, and that turned up twenty-three separate issues. Each fix risked breaking a different platform. The Lighthouse score started at 34 out of 100. Getting it to 94 took a long stretch of optimization where every improvement seemed to undo another one.

This is the part the speed story leaves out. AI moved fast, but fast meant I hit the wall sooner, not that the wall was gone. The knowing-which-fix-was-right part was still mine.

## The design was the real fight

Retro feel with modern function is harder than it sounds. Beautiful animations killed mobile performance. Vintage colors fought modern screens. Every design choice was a trade between the thing I loved and the thing that worked, and I had to keep picking.

From my journal at the time:

> Started the day with rough wireframes and ended with a complete, functional business website. But the AI did not just implement my designs, it had to save them. My initial creative vision was beautiful but technically impossible.

That is the truth of it. The first vision was lovely and would not ship. The AI was useful exactly where it pushed back on me. It took fourteen passes to get the copy to sound like a person instead of like every agency, and even then I read every line to make sure it was mine.

## What the site does now

It went from no presence to something that does real work. The site is open while I sleep. It makes a consistent first impression instead of whatever pitch I happened to give that day. The analytics have shown me what people actually look at, which was not always what I expected.

The look helps too. A retro site in a sea of identical corporate ones gets remembered, and the fact that it runs well says more about what I can do than a portfolio would.

## The money part

The old way would have cost north of $60K and taken months: specialists, coordination, the overhead of getting them to agree. I did it for a fraction of that, in a fraction of the time.

But the number is not the whole story. What I actually got was being in the market now instead of next quarter, a presence that works around the clock, and a platform I can grow without rebuilding.

## What it actually proved

For a while I believed good work needed time and a team, and that a solo developer could not stand next to an agency. Building this is what changed my mind. Not because the AI did it for me. Because it let one person hold all the roles long enough to finish.

I wrote about this in the ["modern gold rush"](/2025/05/31/living-through-the-ai-revolution-reflections-on-creativity-balance-and-the-modern-gold-rush/) piece: a small business reaching for capabilities that used to need a whole company. That part is real. So is the cost. I was tired and stressed and questioning the plan more than once, and I finished anyway.

In Part 6 I step back and look at what this does to the industry, now that one person can do this much.

**Next**: [Part 6: Future Implications →](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- **Part 5**: Business Transformation (Current)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Sat, 30 Aug 2025 02:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/08/29/ai-assisted-development-part-5-business/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-5-business.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 4: Content Pipeline</title>
      <link>https://joshuaayson.com/2025/08/10/ai-assisted-development-part-4-content/</link>
      <description>Turning years of handwriting and a tangled WordPress blog into something I could maintain, without letting the machine flatten the voice out of it. OCR for cursive, a WordPress to Astro migration, and where automation actually ends.</description>
      <content:encoded><![CDATA[# The Content Pipeline

*Part 4 of the AI Development Revolution. This was the long one, and most of what I learned later started here.*

## The problem was my own handwriting

Daily freewriting is my morning practice. Two to five pages of cursive before the day starts. The writing was never the problem. Getting it off the page was.

Generic transcription models could not read me. My handwriting is its own dialect, and the early models guessed at it badly enough that fixing their output took longer than just typing the pages myself. But I write a lot, and retyping all of it by hand was not going to last. So I needed something in between: a pipeline that could take a photo of a page and hand back a clean draft that still sounded like me.

I had written before, in ["Taming the Paper Tiger"](/2025/01/08/taming-the-paper-tiger-how-writing-helps-process-thought-and-unlock-creativity/), about how thin the thread is between thought and text. Speeding it up with a machine was the fastest way to snap it.

## Five tries before it worked

The first version used basic OCR. It read the words and lost the voice completely, flattened everything into the same gray tone. The second used a better model, and somehow that was worse. It cleaned the writing up into corporate copy, the kind of prose that says nothing in a confident way. I trained a custom model, and it came out too rigid, locking onto patterns and forcing every page through them. I tried a context-aware pass that was supposed to read the meaning and keep the style. It fell apart on stream-of-consciousness, which is most of what freewriting is.

From my notes at the time:

> The handwritten pipeline finally works, but it took complete rewrites and weeks of debugging. The AI does not just transcribe, it reads context and keeps the voice, but only after a lot of training and a lot of throwing things out.

None of the working version came from a clever idea. It came from doing it badly four times and paying attention to how each one failed. The cost was real. Weeks of work scrapped, the same pages retyped to check the machine against the truth, the stubbornness to start over with a different approach when the last one had felt close.

I wrote in ["Handwriting as Meditation"](/2025/03/27/handwriting-as-meditation-sourcing-creativity-through-flow-breath-and-rhythm/) and ["The Flow of Thoughts"](/2025/01/15/the-flow-of-thoughts-handwriting-freewriting-and-the-comfort-of-familiar-voices/) that the link between the hand and the thought is the point, not a side effect. Teaching a model to leave that link alone was the whole job.

## The WordPress exodus

The other half was years of old posts trapped in a WordPress database. I wanted them out, into plain markdown files I could read, move, and back up without a plugin and a server in the way.

The export was easy. The cleanup was not. I ran the first hundred articles through an enhancement pass and they all came back sounding like a brochure. Smoother, shorter, and gone. So I read all hundred with a red pen, rebuilt the rules, and read them again. "Automation," it turned out, did not remove the work. It moved it. Instead of writing the articles I was reading every one of them, slowly, asking whether the machine had quietly swapped a sentence of mine for a sentence of its own.

A few things it was genuinely good at, and I let it have them. Alt text for images. Formatting code blocks. Checking links. Writing a meta description that summarized a post without trying to improve it. Anywhere it had to be descriptive instead of creative, it earned its keep. Everywhere it tried to be me, I took the work back.

## What I gave up, and what I kept

Every step was the same trade. Make it clearer and you risk sanding off the part that was interesting. Optimize the title for search and you lose the title that had a joke in it. Most of the time I chose the joke. I left original titles when they had character and accepted that they would rank worse for it. I kept transitions that were a little rough, because rough was mine and smooth was anyone's.

The pipeline only started working when I stopped trusting it. Scanned page in, draft out, and then a person reading the draft against the page before any of it went near the blog. That last step never went away. At some point I stopped trying to make it.

## What it is for

What I have now is quiet. A photo of a morning's pages becomes a draft by the time I have had coffee, and the draft still sounds like the person who wrote it longhand. The old posts are files I own instead of rows in a database I rent. None of it is hands-off, and I have made peace with that.

I have written elsewhere, in ["Vibe Coding with AI"](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration/), about working with the machine as a partner instead of a tool. This was where I learned where the partnership ends: at the page, with me reading.

Next I took the same habit, build it badly, watch how it breaks, keep a human in the loop, and pointed it at whole applications. That is Part 5.

---

**Next**: [Part 5: The Business Transformation →](/2025/08/29/ai-assisted-development-part-5-business/)

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- **Part 4**: The Content Pipeline (Current)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Mon, 11 Aug 2025 02:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/08/10/ai-assisted-development-part-4-content/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-4-content.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 3: Infrastructure</title>
      <link>https://joshuaayson.com/2025/08/05/ai-assisted-development-part-3-infrastructure/</link>
      <description>Building enterprise AWS infrastructure in weeks with AI. CDK stacks, production systems, and the cognitive cost of compressed timelines.</description>
      <content:encoded><![CDATA[# Enterprise Infrastructure at Startup Speed

*Part 3 of the AI Development Revolution. This is the one that nearly broke me. The infrastructure got built in weeks. The cost came out of my body.*

## One mind holding everything

The usual way to build enterprise infrastructure is a team of specialists and a few months. I had myself and an AI, and I did it in weeks. The speed was real. So was the price, and the price was cognitive.

It meant long focused sessions, days at a stretch, for weeks. Debugging marathons every time an integration failed. The hard part was not any single problem. It was holding all of it at once: architecture, security, performance, cost, twenty-some AWS services that all touched each other. A team spreads that weight across people. Alone with the machine, it all sat in one head, mine. The body kept score. Back pain, eye strain, headaches, sleep that stopped showing up.

I wrote about that stretch at the time, in ["The Multithreaded Mind"](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed/). Running at machine speed while trying to keep human judgment intact.

## What the commit log doesn't show

The oa-backoffice repo, by the numbers: 83 commits, 88,000-plus lines, 20-plus CDK stacks, 9 production domains, zero production defects. The numbers are true and they hide everything that mattered. Foundation layers for identity and networking. Compute and storage. Application layers tuned for global delivery. Security threaded through all of it. Every stack was a small lesson in balance, and every integration was a test of how long I could keep concentrating.

## The authentication stack

"We need enterprise-grade authentication," I told the AI. Cross-account access, MFA enforcement, service-specific permissions, integration with the existing VPC. The response looked perfect. Architecture analysis, best practices, a complete CDK stack generated in one pass.

What actually happened was different. It missed security dependencies and I spent hours untangling circular IAM policies. Its "best practices" fought my use case, and I redesigned after the deployment failed. Code that worked in isolation broke the systems around it. It overlooked the VPC endpoint requirements, so authentication worked from the public internet and failed from inside the network.

What was sold as a quick implementation turned into a long debugging slog. The authentication infrastructure came out excellent. The path there was brutal. The lesson stayed: AI architectural suggestions need deep validation, and the productivity gain only shows up after you survive the learning curve.

## The networking marathon

I sat down one session to build the complete networking infrastructure. I did not expect the real difficulty to be holding the whole picture steady while the AI kept handing me pieces.

The start felt like flying. VPC, subnets, route tables, all configured fast. Security groups generated quicker than I could read them, which felt like superhuman productivity right up until it was the problem. Then the load balancer integration broke assumptions I had already built on. The AI fixed each local issue and created system-wide ones doing it. I had to go down into AWS networking myself to check its recommendations. CloudFront configuration collided with the VPC setup, and the AI could not reason about how the two services interacted. Debugging that meant understanding both the generated code and the AWS internals underneath it.

Four hours in, it worked. I had rewritten three of the AI's modules where its patterns did not match mine. The win felt earned. The exhaustion was real. Testing then turned up performance issues it had not anticipated, and a security scan found five configuration problems in the generated code. The optimization at the end needed knowledge the AI did not have.

What made it possible was the hidden work nobody counts. Keeping a mental model of fifteen-plus services live at once. Checking every suggestion against the architecture in my head before it went in. Weighing each recommendation against performance, cost, and security. That is the part that empties you out.

## The day it almost all went down

One day the log says 34 commits across three repositories, a lot of infrastructure moving across a lot of stacks. The log does not say how close the whole thing came to falling over.

It started well. Enhanced VPC routing, cross-stack resource sharing, monitoring and alerting added. I was confident and the collaboration felt smooth. Then the cross-stack dependencies broke the moment they deployed together. The monitoring stack could not reach VPC resources because of IAM, and when I tried to roll back, the rollback broke production. I went into agent mode for an emergency debug.

This is where the AI made things worse. Its "quick fixes" broke other systems. I had to read the CloudFormation templates by hand to find the root cause, and what I found was that it had built circular dependencies across four stacks. Once I isolated the wrong architectural assumption underneath all of it, I could see the shape of the fix. I rebuilt three stacks from scratch with the corrected design, exhausted, set on finishing before I lost another day. Performance testing afterward found things to optimize. Security scanning found gaps I patched by hand. The system worked. I was empty.

I took two full days off before I could develop again. A day like that is not something you can do twice a week. Blue/green deployments are what kept the next round from going the same way.

## What got built, and what it cost in time

The security came out enterprise-grade. Identity and access with least privilege, private subnets and security groups and NACLs, encryption at rest and in transit, CloudTrail and GuardDuty and Security Hub for monitoring, SOC 2 and GDPR frameworks. A security architect might spend two or three weeks designing and implementing that. With the AI it was hours, but only because I was already holding the design in my head and validating every line.

Performance came from the AI pointing at the right places. CloudFront edge caching cut latency by about 60 percent. Auto-scaling tied to usage. Reserved instances and spot fleet for cost. For disaster recovery, multi-AZ failover, continuous backups with point-in-time recovery, and infrastructure as code that can rebuild the whole environment from scratch.

The zero-defect record was not luck. Every configuration got checked before deployment. Changes went out small and testable. Monitoring watched in real time, and rollback was immediate when something looked wrong. None of that is automatic. It is a discipline you keep paying for.

## The economics, with the usual caveat

These figures are rough comparisons, not a quote. Real costs swing on scope, experience, region, and requirements. The point is the direction, not the decimal.

The traditional version of this needs a senior architect, several DevOps engineers, a network engineer, a security specialist, and someone to manage the coordination, all running across months. It comes to the six-figure range and carries real risk from integration and scope creep. The AI-assisted version was one developer at full allocation on a compressed timeline, a modest monthly AI subscription, and the AWS bill for dev and test. Five figures, weeks instead of months, and lower risk because the feedback was continuous.

What the savings actually buy is reach. A small team can build infrastructure that used to need a full department. A startup can match an established player on technical depth. One developer can ship a system that would have required a team. That is the part worth caring about. The money is downstream of it.

## What I'd carry forward

A few things held up across every stack. The AI is good at designing one piece and weak at the seams between pieces. When its systems fail, debugging means understanding both what you meant and what it actually wrote, which is two problems at once. It buys you velocity and hands you the quality check as the new bottleneck. And the strategic call, the read on whether the whole shape is right, stays human. The machine did not have it.

I once called this kind of work ["vibe coding"](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration), the line between what I bring and what the machine brings going soft. Infrastructure is where I felt how soft it really gets, and where the body told me the rest. It worked. It was not free.

Part 4 takes the same approach, build it, watch it break, keep a person reading every output, and points it at years of my own writing instead of AWS.

---

**Next**: [Part 4: The Content Pipeline →](/2025/08/10/ai-assisted-development-part-4-content/)

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- **Part 3**: Enterprise Infrastructure (Current)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Wed, 06 Aug 2025 02:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/08/05/ai-assisted-development-part-3-infrastructure/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-3-infrastructure.png" type="image/jpeg"/>
    </item>
    <item>
      <title>AI Development Revolution Part 2: The Methodology</title>
      <link>https://joshuaayson.com/2025/07/31/ai-assisted-development-part-2-methodology/</link>
      <description>From chaos to systematic AI collaboration. The AAA Framework - Autonomous, Adaptive, Agile - and battle-tested workflows for development.</description>
      <content:encoded><![CDATA[# The Methodology That Emerged

*Part 2 of the AI Development Revolution. The early days worked, but they were chaos. This is how the chaos turned into something I could repeat.*

## From chaos to a system

After the first stretch of working this way, I kept running into the same question. How do you make something repeatable when it still feels like luck?

The early days were productive and unsustainable at the same time. The sessions ran long and left me wrung out. I could not predict which mornings would flow and which would hit a wall. Every new project started from nothing, and I rebuilt the same context by hand each time.

The methodologies I already knew did not survive contact with this. Agile broke once the work moved faster than I could check it. Waterfall fell apart the moment a single AI suggestion made my plan from that morning irrelevant. Letting the AI drive on its own produced code that was clean and pointed in the wrong direction.

What finally worked came out of being tired enough to stop fighting it. The method had to be built with the AI, not handed down to it. This was the same question I had circled in ["On Intelligence"](/2025/02/21/on-intelligence): what does it actually mean to work alongside a mind that is put together so differently from mine?

After a few months of strain, a shape showed up. Not a trick for prompting better. A different way of working, built for how heavy this kind of collaboration actually is on a person.

## The AAA framework

I ended up calling it AAA, for autonomous, adaptive, agile. The names came after the practice, not before it.

### Autonomous

Most AI assistance treats the model as a smarter autocomplete. I started treating it as a partner with its own initiative, and that changed what the sessions felt like.

It also cost more attention, not less. Letting the AI hold project state across a session sounds clean until context drifts and a project restarts for the third time, and you learn to write prompts that keep it anchored. Letting it take initiative is good until two in the morning when you cannot tell a real idea from scope creep. When it tried to recover from its own errors, it often introduced new ones, and I had to understand how it was reasoning to catch them.

So a session stopped being "write a function." It became setting the context, holding the strategy steady, checking the technical work as it came, and noting what to keep for next time. Every one of those autonomous sessions asked for my full attention the whole way through. It was tiring. The results were also real.

### Adaptive

The framework changes as I use it. Something that works for infrastructure gets reshaped for content, then reshaped again for a business app. When a pattern works, I write it down so I am not rediscovering it next month. When something fails, I look at why before moving on, so the same failure does not come back. The method gets a little smarter each time I apply it somewhere new.

### Agile

Regular agile runs on sprints. This runs on sessions, often several in a day, and the pace is hard on the head.

Restoring context takes real time, because I am rebuilding a mental model of how several systems fit together. The active work means constant decisions with no gaps between them. My focus starts slipping around ninety minutes, and the quality of my judgment drops off after two hours. I have to take breaks even when the work is flowing, because the alternative is making bad calls without noticing.

Mornings are my best hours for this. Afternoons take more out of me for the same output. Evenings are usually a loss, since the day's decisions have already worn me down, and after a heavy run of days I need a full day off to come back.

The body gets used to the rhythm. The mind still needs looking after.

## Continuous intelligence

The real shift was not continuous integration. It was that each session made the next one better. Getting there asked for everything I had.

The first sessions were mostly overload. I spent most of my time checking and fixing what the AI suggested, and evaluating every recommendation left me drained. For a while it was more work than just writing the code myself.

Then it started anticipating what I needed. I learned to tell quickly when a suggestion was aimed at the goal and when it had wandered off. The first session where it saved me more time than it cost stood out clearly when it happened.

After that came something closer to flow. It held context across files and offered improvements I would not have reached for, and I stopped managing it and started working with it.

Eventually it felt like the two of us could do things neither could alone. The conversations turned into real arguments about trade-offs. From my notes at the time:

> *Session 73 today. The AI didn't just understand what I needed, it suggested approaches I hadn't considered, caught security issues in my thinking, optimized for performance factors I'd forgotten. This isn't tool usage anymore, it's genuine strategic collaboration. But it took 72 sessions of intense cognitive work to get here.*

The cost up front was real. Early weeks meant longer days for less to show, and the strain showed up in my body before it showed up in the work. But the patterns did come, the flow states did become possible, and a rhythm I could actually keep arrived in the end.

I wrote about this kind of patience in ["Finding Balance in Motion"](/2025/06/01/finding-balance-in-motion-poetic-reflections-on-travel-routine-and-the-architecture-of-existence): a new way of working takes a while to settle, and rushing it does not help.

## Digital 5S

The old 5S idea from the shop floor needed reworking for this. Sort turned into managing context, drawing clear boundaries and keeping the structure documented. Set in order turned into standardizing how I prompt and how I lay out a session. Shine became steady review and refactoring. Standardize meant writing down the patterns that worked so I could reuse them. Sustain meant keeping the whole thing evolving instead of letting it freeze.

It is a simple idea to describe and a demanding one to hold to.

## Four repositories, four lessons

The real test was running this across projects that had nothing in common.

Infrastructure pushed the hardest. Complex AWS setups with stacks that depended on each other, full redesigns when the AI built circular dependencies, long debugging stretches untangling permissions. It took the most sustained effort of anything I did. But once the AI finally held the architecture in view, the work changed character entirely.

Content management asked for careful quality control. Hundreds of articles to process while keeping each voice intact, several OCR approaches before one caught my handwriting, pipeline rewrites when the first approach would not scale. It needed constant editorial attention. But the AI did learn to clean things up without flattening them.

Business applications wanted a balance between the creative and the technical. Retro looks over modern function, design passes thrown out when a good-looking suggestion ran slow, debugging on weekends. The judgment calls were dense. But things that would have taken months were production-ready in days.

Game development showed me the more advanced patterns. Designing around interfaces instead of fighting the usual architecture, separating metadata so the AI could work with it cleanly, shaping the whole structure to make collaboration easier. That was the method reaching something like maturity.

Each domain forced a change. Infrastructure patterns did not carry over to content. Content insights needed rework for the business apps. Game development surfaced patterns that, looking back, explained things I had done earlier without understanding them. The method grew by being used.

## The results

The numbers tell part of it. Development cycles sped up past what I would have believed. Debugging time dropped sharply. First-attempt success rates climbed higher than seemed reasonable, and there were no production defects across any of the repositories.

The measurements that mattered most were not in the code, though. They were in how the collaboration kept getting better, how knowledge moved between domains, how the method sharpened with use, and how the advanced patterns only became visible in hindsight.

What changed was not only the code. It was what I was capable of.

## A normal day

Mornings go to infrastructure. Restore the context, work with the AI, check the quality, write down what worked. That is when my head is clearest for hard architecture.

Afternoons move to content. Tune the pipeline, improve articles, review the output, carry lessons between sessions. The creative work fits here, after the precise technical thinking is mostly spent.

Evenings, on the good days, take on business features. Web work, user experience, integration testing. On most days the accumulated load just asks for rest instead, and I let it.

## What the old methods missed

Agile assumes a team of people. Waterfall assumes you can pin down the requirements up front. DevOps keeps its eye on the pipeline.

AAA assumes a person and an AI working together, with a learning curve that keeps steepening. The real change underneath it is moving from managing human limits to making the most of what the two of us can do together. From steady, predictable speed to capability that keeps building. From a fixed process to one that changes as it goes.

## What the learning curve is actually like

None of this happens on day one. The first weeks are basic assistance and old habits of thought. Pattern recognition shows up slowly. The flow states come with practice. The real partnership takes months of mental investment, and the refinement never quite stops.

The curve is steep, and the payoff keeps compounding the longer you stay on it.

## Where it gets hard

Context fatigue sets in when the AI loses the thread over a long session. Quality control gets overwhelming when the speed outruns my ability to check the work. And the method drifts when things go well enough that I get careless and stop following it.

Each of those taught me something, and each fix made the next stretch a little steadier.

## What's next

The AAA framework proved a person and an AI working together could reach results I had not thought possible. But a method is a starting point, not a finish line.

Next I take this and point it at building enterprise-grade AWS infrastructure in a fraction of the usual time. That is Part 3.

---

**Next**: [Part 3: Enterprise Infrastructure →](/2025/08/05/ai-assisted-development-part-3-infrastructure/)

---

**Related Reflections:**
- [Vibe Coding with AI](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration/) - Early poetic reflections on AI partnership
- [I AM AI SLOP: Confessions from the Forge](/thoughts/i-am-ai-slop/) - On owning AI collaboration completely

---

**Series Navigation:**
- [Part 1: The Awakening](/2025/07/30/ai-assisted-development-part-1-the-awakening/)
- **Part 2**: The Methodology (Current)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Fri, 01 Aug 2025 02:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/07/31/ai-assisted-development-part-2-methodology/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-2-methodology.png" type="image/jpeg"/>
    </item>
    <item>
      <title>The AI Development Revolution: Part 1 - The Awakening</title>
      <link>https://joshuaayson.com/2025/07/30/ai-assisted-development-part-1-the-awakening/</link>
      <description>The physical reality of coding at machine speed. A firsthand account of working with AI, mental acceleration, and what changed forever.</description>
      <content:encoded><![CDATA[# The AI Development Revolution: Part 1 - The Awakening

*Part 1 of a series about what it felt like to build software with AI while it was changing under me. Not the theory. The actual days.*

## When everything changed

I wrote this in my journal:

> *Working with a partner all day, whether human or not, is tiring. You really keep on going, and the pace is fast. Practically coding at the speed of thought, or somewhat slower. An aching back and body are the least of my concerns.*
> 
> *It is truly hard to balance the day's work, which has been much more productive in some senses, but also a bit jarring in terms of my overall flow and day. It really feels like everything has changed. And you can get sucked into code projects for days.*

I did not set out to document anything. I was just trying to keep up. But reading it back, I can see I was watching the way I build software change while I was inside it, project by project, one late night after another.

## The physical part

The thing I did not expect was how physical it got. When you can move at the speed you can think, your body is the slow part. The mind runs ahead and the back and the eyes are left trying to catch it.

The pull is real, though. From the same entry:

> *What it's like, working with the machine. The back and forth, the commits, the branches. The waiting and watching and learning. The AI is incredibly creative as a software engineer. Much in the same way we would put together tools, reduce problems, try different angles and approaches. And the surprising additional thing it picks up or decides to check.*

It looks like typing prompts. It is not. You are holding several systems in your head at once, checking the work, watching for the moment it suggests something you would not have reached for. The late nights were not only excitement. They were the cost of running at that pace for hours.

As I wrote in ["Vibe Coding with AI"](/2025/06/06/vibe-coding-with-ai-poetic-reflections-on-creativity-agency-and-the-art-of-human-machine-collaboration): "You can get sucked into code projects for days."

## It was not the code that surprised me

I expected it to write code. That part was the point. What I did not expect was the sense that it was thinking like an engineer. Trying angles. Catching connections I had walked past.

That is not how automation usually feels. Automation does a task you handed it. This felt more like sitting next to someone. "The AI is incredibly creative as a software engineer," I wrote. "Much in the same way we would put together tools, reduce problems, try different angles and approaches."

## Four projects at once

The same shift showed up across four projects, each one a different shape of it.

Enterprise infrastructure: AWS systems that should have taken months. I watched it move through CDK stacks with something like intuition, holding the dependencies between services while it offered architectures I had not thought to try.

Content automation: years of handwritten journals, turned into clean text without flattening the voice out of them. It understood more than the OCR. It understood the editing.

Business applications: retro design over modern guts, Flutter web pushed harder than it wants to go, visual decisions made fast.

Game development: this one taught me the most. Building a physics engine, structuring the architecture around the fact that a machine would be working in it too.

Each one took real attention. It was not prompting. It was leading the work while the machine moved fast under it.

## The numbers

The numbers were hard to argue with. Hundreds of commits. Tens of thousands of lines. Timelines that used to mean something stopped meaning anything. But the numbers are not the part I remember.

## What it actually felt like

From my journal:

> *1 week into the migration and almost there. 1 week. To build. To move to reimplement. To plan. To vision. Nuts. So fast. Wow.*

The disorientation was the honest reaction. Infrastructure that should have been a quarter of work was done in days. Things that normally need a team got built alone, at night. I did not have a frame for it.

As I wrote in ["Living Through the AI Revolution"](/2025/05/31/living-through-the-ai-revolution-reflections-on-creativity-balance-and-the-modern-gold-rush): "I tingle at times, knowing I'm part of something so historic, so grand...I've never seen something move and change so fast."

## The learning curve

Working this way is not like picking up a new language. The skill is not the prompt. It is holding the whole thing in your head, the mental model across systems, while the machine suggests connections, and checking quality faster than feels comfortable, and steering the architecture in real time.

The late nights came from that. "Just one more feature" at 3 AM, when it is flowing and you cannot make yourself stop. You only feel the cost the next day.

And the questions came with it. Am I still a developer if the AI writes the code? Where does my idea end and its suggestion begin? I wrote about that stretch in ["The Multithreaded Mind"](/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed): living at machine speed and trying to keep my own judgment intact.

## The honest part

None of this was clean. CDK stacks I had to tear down and redesign when the AI built circular dependencies into them. Long nights chasing permissions it had set wrong. Whole weekends lost to networking config that held until it didn't.

Five different OCR approaches before one of them kept the handwriting intact. Pipeline rewrites when a suggestion worked fine and then would not scale. "Am I still engineering if the AI does the implementation?" That one followed me through the debugging.

But something was happening that I did not have words for yet, and it was changing more than my workflow. It was changing how I think about working alongside a machine at all.

As I wrote in ["Layers of Abstraction"](/2025/06/02/layers-of-abstraction-poetic-musings-on-creativity-balance-and-the-modern-mind): "This is the age of grand abstraction. Of thought, of systems, of beautiful design, grand unified patterns."

The parts that follow are where I tried to make sense of it. The methodology, the infrastructure, the content pipeline, and where I think it goes.

---

*This series is based on real development work, documented through daily journal entries and git histories.*

**Next**: [Part 2: The Methodology →](/2025/07/31/ai-assisted-development-part-2-methodology/)

---

**Series Navigation:**
- **Part 1**: The Awakening (Current)
- [Part 2: The Methodology](/2025/07/31/ai-assisted-development-part-2-methodology/)
- [Part 3: Enterprise Infrastructure](/2025/08/05/ai-assisted-development-part-3-infrastructure/)
- [Part 4: Content Revolution](/2025/08/10/ai-assisted-development-part-4-content/)
- [Part 5: Business Transformation](/2025/08/29/ai-assisted-development-part-5-business/)
- [Part 6: Future Implications](/2025/10/17/the-ai-development-revolution-part-6-future-implications/)
- [Part 7: Advanced Patterns](/2025/10/18/ai-development-revolution-part-7-advanced-patterns/)]]></content:encoded>
      <pubDate>Thu, 31 Jul 2025 02:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/07/30/ai-assisted-development-part-1-the-awakening/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/ai-development-revolution-part-1-awakening.png" type="image/jpeg"/>
    </item>
    <item>
      <title>The Multithreaded Mind: Six Weeks Living at Machine Speed</title>
      <link>https://joshuaayson.com/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed/</link>
      <description>From copy-pasting LLM outputs to launching 13 repositories in six weeks: what happens when human creativity merges with machine intelligence? A philosophical exploration of time dilation, vibe coding, and the birth of augmented consciousness.</description>
      <content:encoded><![CDATA[# The Multithreaded Mind: Six Weeks Living at Machine Speed

## The moment everything changed

![The Moment Everything Changed](/images/essays/2025/07/1-moment-everything-changed.png)

May 8, 2025. Four hours of an O'Reilly talk going into my head: "AI: The End of Software Engineering as We Know It." I could not do anything with it. A family wedding overseas meant I had to shelve all of it and go. For weeks the ideas just sat there churning while I attended to the things you attend to.

It was late May before I could start experimenting. I thought I was catching up on industry trends. By July 8 I had created 13 repositories, written hundreds of thousands of lines of code, and rewired how my head works.

"Does it feel like one month? No. It feels like 1 YEAR." I wrote that in my journal on June 25th, deep in it. Time had gone elastic. The line between my thinking and the machine's processing had mostly stopped existing.

What followed was a steep climb. Every day there was a new tool, a new framework, a new way to think about the problem. The learning never let up. From my journal: "I'm encountering more frameworks, languages, libraries and systems in a week than I'd previously only read about in a year, but now through direct, hands-on experience." It all happened at once, and the speed was hard to put down.

This is the story of those six weeks.

## The timeline that broke time

| Date | Milestone | The Real Story |
|------|-----------|----------------|
| **May 8** | O'Reilly presentation | Four hours that flipped the switch. "I've never seen something move and change so fast" |
| **May 14** | O'Reilly subscription | Knowledge hunger becomes action. The feeding begins. |
| **May 28** | First AI code at work | Theory meets practice. Reality starts bending. |
| **May 30** | Repos for exploration | First of 13 repos. 155 commits will follow. "Coding at the speed of thought" |
| **June 2** | GitHub Copilot subscription | The symbiosis begins. "Working with a partner all day is tiring" |
| **June 10** | Idea to MVP in one day | Simple game materializes. "Weeks of work compressed into afternoons" |
| **June 25** | Using AI tools at work | "Heady feeling. Exciting and fast. Lightning fast." |
| **July 4** | Claude CLI added | Multiple AIs now. The hunger intensifies. |
| **July 8** | "MAXED OUT PREMIUM CREDS" | Time has no meaning. Only creation matters. |
| **July 16** | Major AI investment increase | "When you're this productive, it's not a cost. It's rocket fuel" |

In six weeks: 13 repositories. 344+ commits. 4.2MB of code. And a head that no longer worked the way it had in April.

## The birth of vibe coding

![Vibe Coding](/images/essays/2025/07/3-vibes-coding.png)

By early June I had run into what people call "vibe coding." The old words for it do not fit. You state what you want, the machine takes a swing at it, you watch where it goes wrong, you correct it, and you do that over and over until the thing is real.

"The AI is creative as a software engineer," I wrote, watching it "put together tools, reduce problems, try different angles and approaches." Sometimes I would hit Control+C when I saw a better path, then watch it take the problem on again. Not commanding it. Working alongside it.

The physical part was real too. My computer ran hot from the load, which more or less matched what was going on in my own head. "Working with a partner all day, whether human or not, is tiring." But the tiredness came with a charge to it. We were building about as fast as I could think.

## The dual life of creation

![Repositories as Cathedrals](/images/essays/2025/07/4-repos-as-cathedrals.png)

During business hours I kept a steady stream of automation and tooling projects going. Five big repositories came out of it, each one solving a real problem, each one a little more capable than the last. The commit counts told their own story. One project alone took on over 150 commits in six weeks.

The bigger change happened in the margins. Thursday 2am commits. Friday 4am pushes. Weekend marathons. Not because I had to. Because I could not stop. When you can make ideas real about as fast as you have them, sleep starts to feel like an interruption.

One weekend stands out. Started Friday evening, coded until 4am, back at it 10am Saturday. The size of a single pull request was hard to believe. Tens of thousands of lines changed. Whole architectures redone inside a 48-hour window.

The data showed a pattern. Most of the personal work happened outside normal hours. Not sneaking side projects past anyone. Just more ideas than a 9-to-5 could hold. Building whole systems while the house slept. I had never worked at that pitch before.

## The multithreading of mind

![The Multithreaded Mind](/images/essays/2025/07/2-multithreaded-mind.png)

"Multitasking no. It's more like multithreading," I wrote on June 25th. This was not scattered attention. It was running several lines at once and keeping each one straight:

- One thread talking through architecture with the AI
- Another refining UI components
- A third weighing deployment strategies
- A fourth on performance

All of it coherent. All of it moving. Held together through the one interface in front of me.

By late June something had shifted. I was "living in the clouds of abstraction and pure thought and design." The layers stacked up until I was working almost entirely in concepts. Systems and patterns and architectures were the material I had in my hands.

## From idea to MVP in one day

![Idea to MVP](/images/essays/2025/07/5-idea-to-mvp.png)

June 10th proved it was real. Could I go from an idea to a working prototype in a single day? Yes, and not barely. A game came out of nothing. My list of things to add next, sounds, timers, leaderboards, physics, was weeks of normal work that now read as a few afternoons.

The speed was hard to hold. On June 12th I wrote, half in disbelief: "When did I start this project? Four days ago. Four days! I'm floored. Life with AI is extraordinary." Four days from idea to running app. The old rules had stopped applying.

"The unfamiliar becomes familiar through small experiments and rapid iterations, messy at first, then suddenly clear." Each small win sat on top of the last one, and the momentum started to feel like it had its own motor. The AI was not only helping. It was teaching me to look at problems a different way.

## The economics of transcendence

![Economics of Transcendence](/images/essays/2025/07/6-economics-of-transcendence.png)

The money tells its own story:

- **June 2**: First paid AI subscription (seemed expensive)
- **July 4**: Added more AI tools (the experimenting picked up)
- **July 16**: Spend multiplied 25x (seemed cheap)

When you can build in an hour what used to take a week, the usual ROI math falls apart. When one month of work holds a year of progress, what is the right price for that? The market has not worked it out yet. The early ones are buying the future at a discount.

## Living at machine speed

![What Comes After Human?](/images/essays/2025/07/8-what-comes-after-human.png)

"Hard to express what this work feels like," I wrote on June 25th. Let me try.

Picture having a long conversation with an intelligence that is genuinely strange to you, one that puts out code as a side effect. Now picture that it can see solutions from angles you never would, approaches that were "admirably creative, sometimes surprisingly human-like, and sometimes alien."

You are not really coding. You are working in pure thought. The old bottleneck, turning the idea into syntax, mostly goes away. What is left is the imagination and your ability to say clearly what you want.

The relationship gets close, almost parental. "My productivity children is often what it feels like," I wrote on June 27th. These things came out of putting my imagination and the machine's capability together, and they asked for both attention and care. "When did work become like play while I can't wait for the next session?" Work had turned into something I did not recognize.

## What it means to think with a machine

What does it mean to think *with* a machine? Not to use it, not to order it around, but to actually run your own thinking through its processing?

After three weeks you notice the AI does not just finish your code. It finishes your thoughts. The stranger part: you start finishing its thoughts too. The line between you and it stops mattering. You are working as something a little different than before.

"Living in the clouds of abstraction and pure thought and design" was not a figure of speech. It was the plain description of working up there. You are not down in the implementation. You are arranging systems that go off and build themselves.

## The personal cost and reward

![The Cost of Creation](/images/essays/2025/07/7-cost-of-creation.PNG)

"The intensity of the agentic mode work and rapid AI tool adoption affected evenings, weekends, and sleep patterns." Tidy words for something that was not tidy:

- 5-6am: Code before the family wakes
- 9am-5pm: Regular work
- 6-8pm: Family time, non-negotiable
- 9pm-2am: Personal projects, where most of it happened
- Weekends: 48-hour stretches

The notes I left myself read like warnings, because they were: "If you are planning to fly close to the sun, bring metal wings." And: "Prepare to feel unbalanced, precarious, and extremely frustrated. The time you spend with these tools will strain your family relationships."

Not all of it felt good. June 12th brought the other side: "With the highs come the lows. With productivity, the tide comes in, the tide goes out." I was burned out from going "almost non-stop for the whole week." The weight of the whole thing pressed down.

And still, I was happy in a way I had not been before. When every day hands you a new thing you can do, when you can build an idea about as fast as you can have it, the tiredness reads as something closer to being awake. I was worn out and glad to be.

## What comes after human?

As I write this in late July, having just rebuilt a blog in a week that would have taken months, the line is easy to see. The 13 repositories in six weeks were the warm-up. The rising AI spend is the cost of doing this at all.

Something is changing in how the work gets made, and maybe in how a person making things gets to spend their days. The mix of human judgment and machine capability is not on its way. It is already here, and the people using it are working in a different reality than the one I was in three months ago.

## The view from the edge

![The Dance at the Edge of Tomorrow](/images/essays/2025/07/9-dance-at-the-edge-of-tomorrow.png)

From the manual copy-paste of early in the year to July's multithreaded version of the work, the whole thing took six weeks. But those six weeks held a year of growth and a shift in how I see the work that I do not expect to go back on.

The heaviest part hit me on June 27th: "Above all else the domain of the human is still very much to imagine, ideate and direct as life and spirit imbue our fragile bodies and being." We had not been replaced. We had been handed more reach.

"It's more like doing things in a week that might have taken a year," I wrote, trying to get my arms around it. "The pace has been incredible. What took days or weeks before now takes hours, but the results are more creative, producing reusable patterns, concepts and tools."

The repositories tell one story. The spending tells another. The real one is the change in how my thinking works, the point where you notice you are not just using AI anymore. You are thinking through it.

"I've never lived through a revolution like this," I wrote. "This isn't just technology changing. This is the nature of work, life, and creativity being rewritten in real time."

It did not announce itself. It came in through a four-hour video, picked up speed across 13 repositories, and turned into a different way of working before I had the words for it.

![The Future at Commit Speed](/images/essays/2025/07/10-future-at-commit-speed.png)]]></content:encoded>
      <pubDate>Tue, 22 Jul 2025 16:00:00 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/07/22/the-multithreaded-mind-six-weeks-living-at-machine-speed/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/images/essays/2025/07/2-multithreaded-mind.png" type="image/jpeg"/>
    </item>
    <item>
      <title>Are Humans Natural or Alien? A Philosophical Exploration of Intelligence, Technology, and Evolution</title>
      <link>https://joshuaayson.com/2025/02/21/on-intelligence/</link>
      <description>View Original Handwritten Notes
[dflip id=&quot;19&quot;][/dflip]


It is still a dream to look into the eye of a great creature in the ocean, such as a whale of gigantic proportions. While their path has been so different from our own, both humans and whales are highly intelligent animals. In all corners of ...</description>
      <content:encoded><![CDATA[View Original Handwritten Notes
[dflip id="19"][/dflip]


It is still a dream to look into the eye of a great creature in the ocean, such as a whale of gigantic proportions. While their path has been so different from our own, both humans and whales are highly intelligent animals. In all corners of nature, one can look, and the difference lies with us, not our God or universe but rather with our code, our unnatural nature. Who is to say the machine did not pre-exist what we see as human intelligence? A technology much higher, much older. Intelligence which gives the universe its breath and drives all and everything and has always been, energy, matter, and quantum chance.


<div class="image-container center">
  <img src="https://joshuaayson.com/uploads/2025/02/intelligence-whale-art-2025-02-22-07-35-23.webp" alt="" class="content-image" loading="lazy" />
</div>


How unlikely it is that there is an explanation within nature for our differences from all other beings. We are alien, we are sentient, we are God. We are the God-alien and afraid of whatever gave truth to our intelligence. And somehow, we are heading towards an eventual merger with our very creations, with many of the most basic questions still unanswered, such as why we are here and what is our purpose.


And yet, with all our intelligence and sensitivity, an offensive smell can trigger our most natural tendencies. We have hearts and feelings and are not, could not, simply be the tin (hu)man. There is the heart of the lion, the memory of the elephant, one who eats like a bird. Our so-called evolution points to the closeness we share with animal nature.


Why only our species? What happened? That is a great story, which neither history nor science can yet answer. But if you look at what we are doing, have always done, word is we are blasting off this planet. Forlorn explorers. Persistent, unrestful, unruly. With idols no one can agree upon in definition, all the shadow of selves.


If no other being, in any of the biological kingdoms, displays the trait of consciousness and commands technology as mightily, then might one suppose the genesis for such had been introduced? While nature creates mutations, an anomaly of this order and so specific can only have come from a singularly unique event.


<div class="image-container left">
  <img src="https://joshuaayson.com/uploads/2025/02/intelligence-machine-art-2025-02-22-07-34-59.webp" alt="" class="content-image" loading="lazy" />
</div>


The squeeze is real, and life will squeeze hard. Hard as it takes. The universe is one merciless void of godliness. And of course, others have wondered this, though I was pondering yesterday on human intelligence and human being. On being, consciousness, and why we are so different. It seems unnatural.


Brain size and growth alone would not have chosen our species to evolve so much further in nature. Alien is an apt description. We are alien to much of the natural world. Even though our source and essence and communal spirit wish to return to what we once came from, our new wiring pulls us in another direction.


Why do no other living beings, even our closest so-called planetary primate ancestral cousin, share one ounce of our exogenic knowledge store? Very little is passed down beyond those things which are of the circle of life, from which we have somehow stepped outside.


That was the original sin, which occurred long enough ago to have erased any memories that writing and art could not yet upturn and instead became the love of our humanity. But just what was it? Could it have been technology? Technology itself has never changed another animal on this planet, but perhaps something latent, waiting for future possibility.


It is all so vast and oftentimes too much. As different as we are, as we continue to learn and grow into our cosmos, and as experience orders our understanding, on the surface, things make sense, or seem to. It all seems fairly well-ordered. Except that piece that doesn’t fit. That one thing, that animal we should be.


The one that won’t stop. The one that isn’t like the rest in its capacity to love, to destroy.


<div class="image-container center">
  <img src="https://joshuaayson.com/uploads/2025/02/intelligence-evolution-art-2025-02-22-07-35-05.webp" alt="" class="content-image" loading="lazy" />
</div>


We are the tapestry of all past DNA. And yet, we seem more like machines than human. Giving up the animal part of our being in favor of what we have created. An incubating virus, taking thousands of years to mature, which in the scale of the cosmos is nothing. It happened fast, between nature and Eden.


If we place all our senses and body within a machine, what is left of the human? Where does the soul hide? Is it the body or the mind that becomes fixed in reality? The soul drifts aimlessly.


On the biological level, we are machine. A chemical factory. But feelings! The spark of life. Inspiration, beauty, longing. These exist in wild creatures, yes, but in us, they take on something more, something abstract, something undeniable.


And as I write, as I let thought flow into the ink of the pen, it amazes me. This act, this simple act, is entirely unique to us. This ability to think, to communicate in this way. Surely, we have done this before.


<div class="image-container left">
  <img src="https://joshuaayson.com/uploads/2025/02/intelligence-existence-art-2025-02-22-07-34-42.webp" alt="" class="content-image" loading="lazy" />
</div>


But in all our good and perverse aberrations, in all our intelligence, we have never been able to bring another species to where we are.


How did it happen?


And why do we still not know?]]></content:encoded>
      <pubDate>Fri, 21 Feb 2025 10:09:31 GMT</pubDate>
      <guid isPermaLink="true">https://joshuaayson.com/2025/02/21/on-intelligence/</guid>
      <category>essays</category>
      <dc:creator>Joshua Ayson</dc:creator>
      <media:content url="https://joshuaayson.com/uploads/2025/03/Onintelligence.jpg" type="image/jpeg"/>
    </item>
  </channel>
</rss>