Field notes, essays, and methodology from building software with AI daily. The practical application of making complexity visible in software systems.
AI-assisted engineering is not a trend or a shortcut. It is a fundamental change in how software gets made, and if you are building software right now, you are already in the middle of it whether you have chosen to be or not.
I started writing about this in earnest in mid-2025 after spending six weeks working almost exclusively in agent mode. What I found surprised me. The productivity gains were real, but they were secondary. The bigger story was cognitive: working alongside AI changes how you think about problems, how you scope work, how you evaluate what is worth doing yourself and what is worth delegating. These are not minor adjustments. They are architectural changes to the development process.
The essays collected here are field notes from that ongoing experiment. They cover the workflows that actually work, the failure modes no one warned me about, the cognitive side effects of working at machine speed, and what it looks like when you apply these patterns to real infrastructure, real content pipelines, and real business software, not demos and toy projects.
One consistent theme: AI-assisted development requires more engineering judgment, not less. The models can write code. They cannot decide what to build, catch the architectural mistake that compounds into a rewrite six months later, or know when good enough is actually good enough. That judgment remains human work. The goal is to free up time and cognitive load for it.
Start with the complete series overview if you want the full arc. Or pick any single essay if you have a specific question. They are written to stand alone as well as build on each other.
The full series in one place, from the first shock of working alongside AI to building autonomous agents, infrastructure, content pipelines, and business apps. If you read one thing, start here.
A clear-eyed look at what separates deliberate AI-assisted development from prompting-and-hoping. The distinction matters more as models get more capable, not less.
What happens to your thinking when you work alongside AI for six weeks straight. The cognitive changes are real, unexpected, and worth examining.
The moment everything changed, from using AI as a fancy autocomplete to treating it as a collaborator with its own strengths and failure modes.
The workflow patterns that actually stick. How to structure prompts, manage context, and build a feedback loop that makes AI collaboration sustainable.
AI doesn't just write application code. When you apply the same patterns to infrastructure, Dockerfiles, CDK stacks, CI pipelines, the leverage multiplies.
How AI changes the economics of content creation: OCR pipelines, automation scripts, publishing workflows, and keeping the human voice central.
From trading dashboards to membership platforms, applying AI-assisted development patterns to real business software with production requirements.
Where this is heading. The economic and professional implications of AI-assisted development at scale, for individual developers, teams, and the craft itself.
The techniques that emerge after months of practice: multi-agent orchestration, context management at scale, architectural decision-making with AI.
The current work, tightly themed: what agent mode and autonomous mode actually are, the workflow that holds up, and how the same patterns reshape DevOps and architecture.
AWS is sold as two hundred services. Underneath it is a handful of primitives, and every service is a frozen answer to a distributed-systems trade-off. The map I built studying for the SAA-C03, the patterns above it, and the two questions that decode any new AWS service.
A strict Content-Security-Policy on a static site allowlists inline scripts by hash. Change one script, forget to update the hash, and every page renders blank. The incident that taught me, and the deploy guard that ends it.
The mechanical AI tells you can catch with a script, the ones you cannot, and why detecting AI writing finally comes down to a voice you have to supply yourself.
Why I precompile every post on this Astro site into one committed TypeScript file instead of reading markdown at build time, what it buys, and the one cost you pay to keep it honest.
Traditional OCR cannot read cursive; a vision model can. The pipeline I built to transcribe years of handwritten journals, the human review it still requires, and the loop that makes it better every batch.
A static site has no server to check a password. How I gated staging with a CloudFront Function instead of Lambda@Edge, kept the credential out of git, and the day the wrong file 503'd the whole thing.
Multi-repo agent work is not a scale problem, it is a context-routing problem. How I scope an agent to one project at a time across thirty-three independent repositories, and why the instruction files do the real work.
I built a graph of every internal link on this site to see its real structure, not the one I imagined. What the map showed about hubs, orphans, and where authority actually flows.
A field report on rebuilding this blog with an agent driving, from the Astro content cache to the AWS deploy. What the work actually took, the failure modes, and what stayed human.
The right metaphor for agent mode is not autopilot, it is the suit. You are still the pilot; the suit makes you faster and stronger. Why that framing changes how you work.
Applying the operational discipline of software, observability, feedback loops, incident review, to the way I run a day. What transfers, and what does not.
Agent mode and autonomous mode get used as synonyms; they are not. In agent mode you close the loop after every task. In autonomous mode the system does, on a schedule or a trigger. A working engineer's disambiguation, and when to use each.
Not a tools list. The tools changed three times this year; what changed underneath is where the hours go: specs in the morning, batch review in the afternoon, and the judgment work that never left.
The code got cheap; the review did not. The workflow I actually use on agent-written diffs: three passes, an adversarial second agent that hunts for bugs, gates that earned their place, and the discipline of reading what ships.
A field report from inside sustained agent-mode work. Not the tools or the benchmarks: the heat behind the eyes, the way speed bends your sense of time, what it costs the body, and the practice that keeps speed from becoming drift.
A plain-spoken manual in the old Linux HOWTO style: workspace setup, the specify-delegate-verify-record loop, hard-won tips, and how to fix the common failure modes. The entry point if you want to actually do this.
AI did not replace software engineers. It moved the bottleneck. The cost of writing code fell to near zero; the cost of deciding what to build did not.
Agentic development is not chatting with a model about your code. It is giving an agent real access to your repository and directing it, with a working method for the loop.
Agent mode is when you stop typing code and start directing an AI that reads your codebase, writes the change, runs the tests, and reports back.
Autonomous mode is when the agent runs the whole loop without you in it: plan, act, check, repeat, until the task is done or it gets stuck.
A practical, repeatable workflow for building software with an AI agent: specify, delegate, verify, record. The loop I run every day.
Agent mode is not a faster way to type. It moves the unit of thought up from syntax to intent and turns you into a conductor of parallel work.
DevOps was always a feedback loop. The version worth building now runs the system back on itself, so every failure becomes information the system uses to harden.
AI took the typing, and the cost of software engineering did not disappear. It moved from the hands to the head and got heavier.
I used GitHub Copilot for a long time, always with Claude underneath, then moved most of my work to Claude Code. An honest comparison for DevOps work.
What DevOps means in 2026: the tool stack changed almost completely, and the actual work changed almost not at all.
Microservices used to be a tax a solo builder could not afford. AI agents change that math. Why I am drawn to the architecture for what I build next.
A Beginner's Companion to the AI Frontier
If you want these ideas in a single readable volume, AgentSpek is the book version. It covers the full arc, from first contact with AI tools to working in full agent mode, with personal stories, practical prompts, and a structure designed for developers who want to actually use this stuff, not just read about it.
Disclosure: As an Amazon Associate I earn from qualifying purchases.