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.
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.