Long-form thought on AI-assisted development, agent mode, DevOps philosophy, and what changes when the human is three abstraction levels above the code. Some essays lean technical, some lean philosophical; they share the systems-engineering frame.
82 posts • Page 3 of 5
There is a 4.8 megabyte TypeScript file in my repository that I did not write. A script writes it, on every build, and I commit the result into git like it was mine. Most build advice would tell me th...
The em dash is the easy one. I can catch every em dash I will ever type with about nine lines of shell, and I do, on every commit. The script walks my published posts and the book chapters and fails ...
A strict Content-Security-Policy on a static site allowlists inline scripts by hash. Change one script, forget to update the hash, and every page renders blank. The incident that taught me, and the deploy guard that ends it.
Agent mode and autonomous mode get used interchangeably and they are not the same thing. The difference is who closes the loop: you, after every task, or the system, on a schedule. A working engineer's disambiguation.
Not a tools list. The tools changed three times this year; what changed underneath is where the hours go: specs in the morning, batch review in the afternoon, and the judgment work that never left.
The code got cheap. The review did not. Here is the review workflow I actually use when AI agents write most of the diff: three passes, an adversarial second agent, and the discipline of reading what ships.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
I use GitHub Copilot at work and the Claude Code CLI at home, every day. Here is the firsthand comparison for DevOps and infrastructure work, from someone who ships with both, in the context each one actually lives in.
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.
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.