We Fix The Mess
Straight talk about broken systems, failed vendors, and what actually works.
- Technical2 min
The Consulting Shift I Am Making In Year Two
After a year of writing and building, my consulting practice is changing shape. Shorter engagements. Sharper outcomes.
Read - Technical2 min
The Frontend Shift: Shipping Less JavaScript In Year Two
A year ago I reached for Next.js for everything. This year I often reach for nothing.
Read - Technical2 min
The Serverless Lesson I Would Write On A Sticky Note
After a year of shipping serverless projects, one rule explains most of the wins and all of the losses.
Read - Technical2 min
A Year Two Python Refactor: What I Changed In My Script Style
My Python style shifted over the year. Four small changes that made every script shorter and easier to read.
Read - Technical2 min
The Simpler Tools I Switched To This Year
A running list of tools I replaced with something simpler that did the job better. No regrets yet.
Read - Technical2 min
What Year One Taught Me I Was Wrong About
Three assumptions I held on day one that did not survive the year. Writing them down so I remember.
Read - Technical2 min
Cross Pollination In Practice: A Real Engagement
A story from week two of year two where four skills from the soup carried one engagement across the finish line.
Read - Technical2 min
The New Skill I Added To The Soup This Month
A skill soup has to grow. This month I added video. Here is why and how I am making it pass the bar.
Read - Technical2 min
What Breaks In Production Agents
After a year of shipping agents for clients, the same three things break. Here is the short list and how I guard against them.
Read - Technical2 min
The Agent I Built Last Week (Week Two Of Year Two)
First agent of year two. Small scope. Clear stop condition. One tool. Here is what it does.
Read - Technical2 min
The AI Workflow I Killed Last Week
Not every workflow deserves to survive. Here is one I shipped with pride and buried this month.
Read - Technical2 min
The Prompting Pattern That Stuck After A Year
Most prompt tricks age badly. One pattern has survived every model change and every project since June.
Read - Technical2 min
The One Tool I Adopted The Week After Day 365
The series ended and I immediately broke my own rule about not trying new tools. Here is what stuck.
Read - Technical4 min
Day 365: Your AI Supercharger
A year of daily articles on building with AI. The closing thesis ties first principles, skill soup, and the supercharger into one frame.
Read - Technical2 min
Simplicity Wins. Every Time.
After a year of daily writing the strongest first principle is the oldest one. Simple systems survive.
Read - Technical2 min
The Skill Soup Manifesto
Specialists sharpen one blade. Generalists stir a pot. In the AI era the pot is the moat.
Read - Technical2 min
Agents Are Not Magic. They Are Processes.
The word agent hides what is actually happening. It is a loop with a plan, a tool, and a stop condition.
Read - Technical2 min
The Tools That Changed How I Build
After a year of daily writing, a short list of AI tools became indispensable. Here is why they stuck.
Read - Technical2 min
The Penultimate Month: Writing Toward the Finish Line of a Year-Long Commitment
One month left in a year of daily writing. Here is what the finish line feels like and what I will take into year two.
Read - Technical2 min
The Content Pipeline, Eleven Months Later: What the Machine Looks Like Now
Eleven months of daily writing produced a pipeline. Not a habit. A system. Here is how the machine actually works now.
Read - Technical2 min
Newsletter Infrastructure: What 11 Months of SES Taught Me
I run a daily newsletter on SES. Not Substack. Not Mailchimp. Here is the infrastructure that earned its keep and the pain I learned from.
Read - Technical2 min
Technical SEO Wins I Can Attribute to Real Traffic
Everyone writes about SEO. Few can attribute a specific change to a specific traffic bump. Here are the ones I can.
Read - Technical2 min
SEO in 2026: What AI Search Actually Changed About Discovery
A year of daily content. A year of AI search rising. Here is what actually changed about how people find my articles.
Read - Technical2 min
The Client Retention Habits That Doubled My LTV
Winning clients is loud. Keeping them is quiet and worth more. Here are the unsexy habits that doubled my client LTV this year.
Read - Technical2 min
The Consulting Offer That Closed Most of My Business This Year
I tried many consulting offers this year. One closed far more than the rest. Here is the shape and why it worked.
Read - Technical2 min
WordPress Headless: When It Is Worth the Complexity and When It Is Not
Headless WordPress sounds modern. It also adds a full extra moving part. Here is when it earns the cost.
Read - Technical2 min
WordPress in the AI Era: Still the Right Answer for a Specific Client
I have spent a year shipping new platforms on serverless. I have also spent a year shipping WordPress. Here is when WordPress is still correct.
Read - Technical2 min
Frontend Performance Wins That Actually Showed Up in Lighthouse
Not every performance tip moves the needle. Here are the ones that actually improved my Lighthouse scores this year.
Read - Technical2 min
Frontend Architecture After a Year of Shipping: What I Keep Choosing
After eleven months of Next.js, Tailwind, and server components, these are the architectural choices I now default to.
Read - Technical2 min
When Serverless Stops Making Sense: The Threshold I Now Watch
I am a serverless advocate. I am also honest about when serverless costs more than a box. Here is the threshold.
Read - Technical2 min
Serverless Economics: What a Year of Free Tier Running Actually Costs
The AWS free tier sounds free. It is not. Here is the real cost breakdown after eleven months of running three platforms on it.
Read - Technical2 min
The Python Standard Library Tricks I Should Have Learned Sooner
Every time I reach for a dependency I check the standard library first. It has more than I thought.
Read - Technical2 min
Python Async: Where It Finally Earned Its Complexity for Me
I resisted async for years. This year a specific workload made the complexity worth it. Here is the shape.
Read - Technical2 min
Python Patterns That Earned Their Place After 11 Months of Daily Use
Eleven months of daily Python shipped code. These are the patterns that survived every refactor and now live in my muscle memory.
Read - Technical2 min
The Builder Mindset: Why It Beats the Engineer Mindset in 2026
Engineers optimize artifacts. Builders ship things that run. In 2026 the distinction matters more than ever.
Read - Technical2 min
Simplicity as a Daily Practice, Not a Slogan
Everyone says simplicity is good. Almost no one practices it daily. Here is what the daily practice looks like.
Read - Technical2 min
A Year of First Principles: What Survived and What Did Not
I tried to apply first principles thinking to every decision this year. Some principles held. Some broke under load.
Read - Technical2 min
The Generalist Advantage: Why Integrators Ship More in 2026
The historical rap on generalists was that they were slow at everything. In 2026 that rap is wrong. Here is what changed.
Read - Technical2 min
Skill Diversity Is the Moat AI Cannot Eat
AI can eat any single skill. It cannot eat the combination. Here is why diversity is the durable moat.
Read - Technical3 min
The Skill Soup Thesis, Crystallized After Eleven Months
I have been calling it skill soup for a year. After eleven months of data, I can finally write the thesis without hedging.
Read - Technical2 min
Agent Failure Recovery Patterns: Designing for When Agents Break
Agents fail. The question is whether your system recovers cleanly or leaves partial work everywhere.
Read - Technical2 min
Multi-Repo Agent Workflows: Moving Beyond Single-Project Agents
Real client work spans five repos, not one. Here is how I run agents across them without losing my mind.
Read - Technical2 min
Production Agent Patterns: What I Now Default To
After a year of running agents in production, these are the patterns I start with before anything else.
Read - Technical2 min
Orchestration Mastery: Coordinating Five Agents Without Losing the Plot
Most orchestration failures are not about the agents. They are about the coordinator. Here is the discipline I had to learn.
Read - Technical2 min
Using AI for System Design: Where It Helps, Where It Hurts
I tried using AI for every system design task this year. Some worked. Some wasted a week. Here is the honest breakdown.
Read - Technical2 min
Claude Code at the Senior Level: Patterns I Only Unlocked After Ten Months
The patterns that separated my first month of Claude Code from my eleventh. None of them are in the docs.
Read - Technical2 min
AI-Native Apps: What Separates Them From Apps With AI Bolted On
Most apps calling themselves AI-native are not. Here is the architectural test I use to tell the difference.
Read - Technical2 min
AI Tool Maturity Curves: Reading Where Each Tool Actually Is
Not all AI tools are at the same maturity stage. Here is how I read the curves before adopting one into a client stack.
Read - Technical3 min
Eleven Months In: What the AI Coding Landscape Actually Looks Like
After 11 months of daily writing and shipping, the map is finally legible. Here is the terrain as I actually see it.
Read - Technical3 min
February Retrospective: The Shape of Year Two So Far
Two months into year two, 59 articles deep, the shape is clear: depth beats breadth, opinionated beats explanatory, linear growth compounds. Not every category pulls its weight equally, and the data is starting to inform year-two slotting.
Read - Technical3 min
The Agent Loop That Replaced My Junior Developer Workflow
Year two the agent loop (task, execute, review, approve, ship) replaced my junior developer workflow on well-specified work. Ten-times throughput on the right tasks. Humans still win on ambiguous and relational work. Pricing should reflect real productivity.
Read - Technical3 min
The First Principles Question I Ask Before Any Feature
Before any feature I ask: what happens if we just do not build this? Half the time the answer is nothing. The question kills features in search of users, forces real defense, and saves clients weeks of unnecessary work.
Read - Technical3 min
The Three WordPress Plugins That Survived Two Years
Three WordPress plugins survived two years of audits: security, backups, and one SEO plugin. Page builders, contact forms, analytics, social sharing all got deleted and nothing broke. Less is more on WordPress.
Read - Technical3 min
The Shape of a Good Agent Task Description
Good agent task descriptions have five sections: goal, context, constraints, definition of done, escape hatch. Half a page is about right. Larger tasks get decomposed. The skill compounds and is the actual skill of the agent era.
Read - Technical3 min
Why I Stopped Building In Public
Year one I built in public daily. Year two I dialed it back and the business got better. Build-in-public fits solo creators selling to other builders. Consultants should build in private and ship in public. The incentive structures are different.
Read - Technical3 min
Testing in the Agent Era: What Actually Changed
Two years in, the testing bottleneck flipped: writing is free, deciding what matters is expensive. Tier tests by criticality, enforce red-first even on agent output, treat coverage as a floor. Intent is where thinking lives.
Read - Technical3 min
The Content Habit That Became My Best Sales Tool
Daily technical writing turned out to be my best sales tool. Trust transfer compounds across articles, send-a-link handles objections, and the library pre-qualifies prospects. Specific writing for one client beats broad content for imaginary readers.
Read - Technical3 min
The One DynamoDB Mistake That Keeps Costing Me
Three projects in, I keep making the same DynamoDB mistake: entity-first modeling that needs three GSIs six months later. Access-pattern-first is the cure. A checklist run before any schema draft fixes it.
Read - Technical3 min
Agent Prompts That Age Well Versus Agent Prompts That Decay
Prompts decay when they reference specific tools, versions, or project structures. Prompts age well when they describe outcomes and verification criteria. Treat the library as perishable. 24 percent of my two-year-old prompts survived unedited.
Read - Technical3 min
The Skill I Wish I Had Committed To Two Years Earlier
Two years in, the skill I wish I committed to two years earlier is writing. Every other skill has a shelf life. Writing compounds flat, flat, flat, up. The strategy emerges from the corpus, not the other way around.
Read - Technical3 min
The DevOps Minimum Viable Stack for a Solo Consultant
The minimum viable DevOps stack for a solo consultant has six items, each under an hour to set up, covering 90 percent of real risks. Kubernetes, custom CI, and dedicated monitoring get cut until scale justifies them.
Read - Technical3 min
The Debugging Ladder: How Deep to Go Before Calling For Help
A debugging ladder from reading the error to asking a human keeps me from escalating too fast. Most bugs die between steps one and four. Agents without full context produce average advice. Library source is the ground truth.
Read - Technical3 min
WordPress in Year Two: What I Still Use It For
Year two I still maintain three WordPress sites because WordPress is excellent at one thing: content sites the client edits weekly. The plugin budget, backup ritual, and handoff document are what make it last.
Read - Technical3 min
Running Two Agents in Parallel: The Exact Setup I Use
Two Claude Code agents in parallel works if only one owns the writable path. Git worktrees, human-as-channel, read-only investigation on one side, feature branch on the other. Overkill for small changes.
Read - Technical3 min
Why I Stopped Adding Features and Started Deleting Them
Year two I started running a deletion meeting before writing code. About 60 percent of wishlist features get cut. Projects ship in 30-40 percent of original estimates because the remaining work is focused. Cutting is the service.
Read - Technical3 min
The Python Script That Replaced My Weekly Status Report
A 50-line Python script replaced my 90-minute weekly status report. Three inputs (git log, Trello cards, freeform notes), one consistent output. The discipline lives in code, not in weekly willpower.
Read - Technical3 min
Consulting Pricing After Two Years: What Actually Moved the Needle
Four price raises in two years taught me pricing changes what you sell, not just what you charge. Every raise filtered clients, changed the conversation, and was overdue when I made it. Publishing a minimum moved the most.
Read - Technical3 min
The Two-Brain Rule: When to Trust the Agent and When to Check
Agent trust is a two-by-two: fast/slow to verify, low/high blast radius. Ship quadrants one through three. Stop and decompose before letting an agent touch quadrant four. The rule becomes reflex after a week.
Read - Technical3 min
Frontend Patterns That Survived Two Years of Agent Generation
After hundreds of agent-generated components, five patterns survived: server components by default, single styling source, typed API clients, props over global state, shadcn over custom. Agent output decays fastest where rules are implicit.
Read - Technical3 min
The Agent Memory Problem: What Persists and What Should Not
Persistent agent memory is useful only when recall is high. Most teams remember too much: bug fixes, workarounds, frustrations. Half-life thinking and a biweekly review prevent memory from becoming confidently wrong.
Read - Technical3 min
Mastery Is Boring: The Hidden Cost of the Skill Soup Era
The skill soup era rewards the appearance of breadth and punishes actual mastery. The path through still requires depth, but on a narrower target: the parts agents fail on and clients grill you about.
Read - Technical3 min
The Serverless Cost Audit Ritual I Run Every Month
A monthly 40-minute serverless cost audit with six checks has caught three cost leaks worth 600 dollars a year. Monthly beats quarterly for catching runaway functions before they burn thousands.
Read - Technical3 min
Python Patterns I Reach For Every Week in Year Two
Year two Python settled into six patterns I reach for weekly: dataclass config, pathlib, generators, typed exceptions, single-file scripts, and urllib.request. Most automation does not need heavier tools.
Read - Technical3 min
Prompt Libraries: My Personal Prompt Stack After Two Years
Two years in, my prompt library runs on three tiers, three-section prompt anatomy, and its own git history. Prompts I could not grade got deleted. Start the repo on day one.
Read - Technical3 min
The Compounding Hours: Why Year Two Feels Ten Times Faster
Year one every hour produced similar output. Year two the compounding kicked in, mostly through templates. The plateau breaks somewhere between month 15 and 24, and hourly billing punishes you for crossing it.
Read - Technical3 min
Advanced Claude Code: The Subagent Orchestration Pattern I Use Every Day
One Claude Code agent is fast until context fills. Three subagents with tight scopes (explorer, executor, reviewer) produce cleaner commits and avoid context bloat on non-trivial changes.
Read - Technical3 min
Year Two of Daily Writing: Why I Stopped Chasing New Topics
Year two of daily writing taught me breadth is the exploration phase and depth is the exploitation phase. Picking eight topics and going deep tripled referral traffic per topic.
Read - Technical3 min
What I Will Ship in February, Publicly Committed
The last day of January is for public commitments. Here are the four things I will ship in February 2026 with hard deadlines and how I will publish progress every Friday.
Read - Technical3 min
The WordPress Headless Pattern I Am Finally Shipping
I finally shipped a headless WordPress setup that survives real editorial workflows. Here is the stack, the revalidation flow, and what made this attempt work when previous ones broke.
Read - Technical3 min
First Principles: Why Documentation Is a Product
Most teams treat documentation as overhead. That framing is wrong. Docs are a product with users, features, and failure modes. Here is how that reframing changes the work.
Read - Technical3 min
The Claude Code Skill I Built for Client Research
I built a Claude Code skill that drops client research from an hour to ten minutes. Here is what the skill does, how it stays safe on public data, and the hours it saves every week.
Read - Technical2 min
Why I Stopped Writing Dockerfiles by Hand
I hand-wrote Dockerfiles for ten years and stopped in 2025. Quality went up because agents get the small set of correct patterns more consistently than I do. Here is the delegation pattern.
Read - Technical2 min
The Skill Soup Move of the Year: Learning Evals Properly
Every AI engineer talks about evals. Almost none run proper ones. Here is the small eval system I built and why specializing in this is the skill soup move of 2026.
Read - Technical2 min
The Next.js Pattern I Use for Every Landing Page
I ship three landing pages some weeks. Converging on the same Next.js structure cut build time in half. Here is the template and why all copy lives in one file.
Read - Technical2 min
The Serverless Database Choice I Keep Making
I evaluate my default serverless database every December. In 2026 Neon keeps winning because branching for preview environments is the feature I cannot live without.
Read - Technical3 min
How I Rank for Long-Tail Technical Queries Without Backlinks
Every SEO guide says you need backlinks. For long-tail technical queries, you mostly do not. Here is the Search Console loop that produced half my traffic growth.
Read - Technical2 min
The Email Deliverability Checklist I Run for Every Newsletter
Getting a newsletter into inboxes is harder than sending it. Here is the seven-point deliverability checklist I run before every send and the reputation rule that took me a painful month to learn.
Read - Technical2 min
The Python Typing Setup I Use for New Projects
Python without types is slow to scale. Here is the exact mypy, ruff, and Pydantic setup I configure on day one of every new project and why strict mode matters from the start.
Read - Technical3 min
First Principles: Why Boring Tech Still Wins Solo Work
Every month a new framework claims the future. For solo operators, boring tech usually wins the math. Here is the first principles reasoning I apply when shiny shows up.
Read - Technical3 min
Why I Pay for Anthropic Workbench Even When I Do Not Use the UI
I spend most of my agent time in the CLI but I pay for Anthropic Workbench every month. Here is what I actually use it for and why it is the easiest subscription to justify.
Read - Technical2 min
The Content System I Run on Thirty Minutes a Day
Daily publishing sounds expensive until you systematize it. Here is my four-step thirty-minute flow and why I still hand-outline every article before involving the agent.
Read - Technical2 min
Parallel Claude Code Sessions Without Losing Your Mind
Running three Claude Code sessions at once kills quality if you do not structure it. Here is the three-window layout that lets me parallelize without losing the plot.
Read - Technical3 min
The One-Page Consulting Proposal That Closes in Days
Long proposals signal uncertainty. I ship one-page proposals for every engagement under 30k and close faster. Here is the exact six-section structure.
Read - Technical2 min
The Prompt Versioning System I Wish I Had in 2025
Prompts in production are code. I spent 2025 editing inline and losing track. Here is the file-based prompt versioning system I built and why files beat strings.
Read - Technical2 min
Frontend Skill I Am Finally Taking Seriously: Accessibility
I am finally taking accessibility seriously in 2026 for a business reason: the clients I want demand it. Here is my learning plan and why it is now a sales lever.
Read - Technical2 min
The Agent Loop Pattern I Use for Document Processing
Document processing is the boring AI use case that makes money. I use the same five-step agent loop for every client and the retry step is the highest leverage part.
Read - Technical2 min
The WordPress Block I Ship With Every Client Site
I kept rebuilding the same callout block for every client. Packaging it once saved hours on every subsequent project. Here is what is in it.
Read - Technical2 min
Why I Replaced Cron With EventBridge Scheduler
I moved three cron servers to EventBridge Scheduler over the holidays. Here is the migration and why I recovered two hours a month for a small bill increase.
Read - Technical2 min
My Three Unpopular Opinions on AI-Assisted Consulting
Three unpopular opinions on running an AI-assisted consulting practice that cost me conversations and won me better clients.
Read - Technical3 min
Serverless Cold Starts Are Still Your Real Bottleneck
Every team I audit underestimates cold starts. They hide in the median. Here is how I find them and the lazy-init pattern that fixes most cases.
Read - Technical2 min
How I Test Agent Outputs Without Spending All Day Reviewing
Agent outputs look plausible even when wrong. I built a three-layer verification pipeline that catches most failures without reading every generation.
Read - Technical2 min
The Skill Soup Theory of 2026 Developers
The most valuable engineers in 2026 are generalists with one dense specialty. Here is the skill soup model I am using to structure my own learning this year.
Read - Technical2 min
Why Python Is Still My Default for Backend AI Work
I reconsidered my stack for 2026 and Python still wins for backend AI work. Here is why and where I reach for TypeScript or Rust instead.
Read - Technical3 min
First Principles: What Work Is Worth Automating
Most automation wish lists are net negative. Here is the three-question first principles test I run before building anything and a recent example where I chose not to.
Read - Technical2 min
The Agentic Project Template I Use for Every New Client
My client kickoffs shrunk from a week to two hours. The secret is an agent-first project template that encodes all the decisions I used to rethink every time.
Read - Technical2 min
Why I Moved Everything to Haiku 4.5 for Triage
I refactored every agent call to triage with Haiku 4.5 first. The bill dropped 62 percent and quality held. Here is the exact pattern.
Read - Technical3 min
The New Year Audit I Run on My Own Codebase
I start every January with a seven-point audit on every codebase I own. It retires zombie projects and reveals where the year should actually go.
Read - Technical3 min
My 2026 Thesis: Agents Become Infrastructure
My 2026 thesis is that agents stop being novelty and become infrastructure. Here is what changes when a tool crosses that line and what I am betting on.
Read - Technical3 min
2026 Predictions: The Year Solo Developers Win
2026 is the year solo developers start winning at things that used to need teams. The tools amplify one person more than they amplify coordination.
Read - Technical3 min
What I Would Do Differently If I Started This Year Over
Nine things I would do differently if I restarted 2025 from January. Most are about adopting good habits earlier, not adopting different habits.
Read - Technical3 min
The State of AI-Assisted Development: A Year-End Snapshot
AI-assisted development at end of 2025 feels like pair programming with a very fast collaborator. Cost dropped hard. Skill gap is real and worth closing.
Read - Technical3 min
Agent Predictions for 2026: What the Next Year Actually Looks Like
Seven specific predictions for agent development in 2026. Parallel work becomes normal, context prices collapse, verification becomes the bottleneck.
Read - Technical3 min
Error Handling Patterns That Survived Production Load
A year of production load validated five error handling patterns. Fail loud at boundaries, type your business exceptions, and never swallow silently.
Read - Technical3 min
WordPress Block Editor Maturity: A Year-End Assessment
The block editor matured enough in 2025 to recommend without caveats for most client sites. Core blocks are solid, block themes are usable, performance is strong.
Read - Technical3 min
What I Am Grateful For as a Builder
A year-end gratitude post that stays technical. The open source maintainers, the clients, the tools I did not have to build, and the readers who make writing worthwhile.
Read - Technical3 min
Lessons From Solo Consulting: A Year at the Helm Alone
A year of solo consulting taught me that capacity is real, pipeline never stops, and boundaries are the highest-leverage business skill.
Read - Technical3 min
When the Skills Compound: Recognizing the Soup in Action
Compounding is the skill soup in action. Three moments this year showed me combinations that produced outcomes no single skill could deliver alone.
Read - Technical3 min
Python Patterns I Discovered Writing Daily Code in 2025
Daily Python writing revealed seven patterns that consistently make code easier to read six months later. That is the only metric that matters.
Read - Technical3 min
Deployment Simplicity: Git Push Is Still the Gold Standard
A year of deployment experiments confirmed git push is still the gold standard for frontend. Step up only when requirements actually force it.
Read - Technical3 min
The Best Skill Combos I Found in 2025
Six skill combinations produced disproportionate results this year. Agent plus serverless, WordPress plus AI, writing plus building, and three more.
Read - Technical3 min
The Tools That Survived My Workflow in 2025
A full year showed me which tools actually survive. Single-purpose, predictable pricing, reliable API. Tools that fail one of those drop off.
Read - Technical3 min
SEO in the Age of AI Search: What Changed in 2025
AI search changed SEO in 2025. Structured data and direct answers help AI engines cite you. Humans still reward strong openings and concrete examples.
Read - Technical3 min
Content Pipeline Lessons: From One Article to 240
Going from one article a week to one a day forced a real pipeline. Artifact scripts, defined taxonomy, and git-backed content made 240 articles sustainable.
Read - Technical3 min
Pricing Lessons From Twelve Months of Technical Consulting
A year of pricing experiments showed fixed fee wins when scope is clear, hourly wins only for exploration, and retainers need strict caps to avoid scope drift.
Read - Technical3 min
React Server Components: Where They Earned Their Keep
Server Components earned their keep on content pages and data-heavy dashboards. They struggle in highly interactive UIs. Match the tool to the app shape.
Read - Technical3 min
Simplicity as a Competitive Advantage: A Year of Proof
A year of projects confirmed that the clever path costs more in production than the simple path. The demo is minutes. Production is years.
Read - Technical3 min
Newsletter Infrastructure Review: What Eight Months of Sends Taught Me
Eight months of serverless newsletter sends cost under $20 and taught me that deliverability basics beat tool choice and clicks beat opens.
Read - Technical3 min
WordPress in the AI Era: Still the Right Default
AI agents made custom WordPress development affordable again. Block themes matured. The client ownership story still has no headless equal.
Read - Technical3 min
Client Retrospective: What Went Right This Year
A good consulting year came from three repeatable project shapes, explicit scope exclusions, fixed-fee pricing, and a structured communication rhythm.
Read - Technical3 min
Next.js Evolution: What Changed and What Stuck in 2025
App Router and Server Actions stuck in my production code. Streaming UI and auth middleware did not. Next.js in 2025 was steady improvement, not drama.
Read - Technical3 min
DynamoDB Patterns That Held Up Under a Year of Production Load
A year of production DynamoDB traffic validated single-table design, access-pattern-first modeling, and DynamoDB Streams. Cost stayed predictable throughout.
Read - Technical3 min
The Skill Soup Thesis After Eight Months of Daily Practice
Eight months of daily practice turned the skill soup from a hypothesis into my operating model. The value scales with the permutations, not the skills.
Read - Technical3 min
Structured Logging Patterns I Adopted This Year
Structured logs with a fixed set of top-level fields and a request ID turned debugging from a thirty-minute task into a thirty-second one.
Read - Technical3 min
Agent Development in 2025: What Agents Can and Cannot Do Yet
Agents in 2025 are great at scaffolding and pattern replication. They still struggle with architectural judgment and long-horizon planning. The gap is orchestration.
Read - Technical3 min
Serverless Lessons from a Year of AWS Free Tier Production Apps
A year of production apps on AWS free tier cost under $20 total. Serverless with DynamoDB works. Cold starts were a non-issue.
Read - Technical3 min
Claude Code in Production: A Year of Orchestration Patterns
A year of production Claude Code work taught me four orchestration patterns. Fresh context beats long context and scoped tasks beat vague asks.
Read - Technical3 min
Why My Python Stack Stopped Changing in 2025
After a decade of annual stack changes, 2025 was the first year my Python dependencies did not change. Consolidation and boring choices won.
Read - Technical3 min
The 2025 AI Coding Tools Retrospective: What Worked and What Did Not
A year with every major AI coding tool taught me four stay in my daily workflow and most do not. The winners respected the developer as the orchestrator.
Read - Technical3 min
Eight Months of Daily Technical Writing: What I Actually Learned
Eight months of daily technical writing taught me that the real value is clarity of thought and sales assets, not SEO traffic. The order of habits matters more than duration.
Read - Technical3 min
Infrastructure as Code Patterns That Stay Legible
IaC stays legible when you keep templates under 400 lines, name every resource, parameterize only real environment differences, prune unused outputs, and review with a deploy dry-run.
Read - Technical3 min
AI Engine Optimization and Featured Snippets Side by Side
Direct-answer lede, depth behind it, clean headings, parallel lists. One writing pattern serves featured snippets and AI engine citations. Add schema, measure both surfaces monthly.
Read - Technical3 min
Value-Based Pricing Applied Honestly
Value-based pricing wins when outcome is measurable, client owns the outcome, and value is big enough to share. Base plus success structure, measurement in writing. Hourly for maintenance and exploration.
Read - Technical3 min
Year-End Client Reviews That Renew the Retainer
Year-end client reviews renew retainers when you ship three slides, listen twice as long as you talk, pre-read the deck, and follow with a targeted proposal within 48 hours.
Read - Technical3 min
Newsletter Analytics That Drive Real Decisions
Three newsletter metrics drive real decisions: per-edition unsubscribe rate, net growth, reply rate. Open rate and click-through are vanity after Apple Mail privacy. Track what changes next week.
Read - Technical3 min
SES Production Setup That Survives Real Newsletter Volume
SES survives real newsletter volume when you publish SPF, DKIM, DMARC, wire bounce and complaint handlers before your first send, use configuration sets, and warm up gradually.
Read - Technical3 min
Headless WordPress Without Regretting It Later
Headless WordPress trades editing cohesion for frontend freedom. Use WP as a JSON API, cache hard, own the preview path, and pick it only when the frontend needs justify the operational overhead.
Read - Technical3 min
Gutenberg Advanced Blocks Without Losing Your Mind
Ship production Gutenberg blocks with @wordpress/create-block, typed attributes with defaults, PHP dynamic rendering, and deprecation paths for every schema change.
Read - Technical3 min
Accessibility Basics That Earn Keep in Production
Four accessibility basics earn their keep on every production page: semantic HTML, visible focus, descriptive link text, alt text. Fifteen-minute audit catches the first ninety percent.
Read - Technical3 min
Next.js Caching Strategies I Trust in Production
Four Next.js caches, one mental model: static for stable content, ISR for mixed, dynamic for live. Explicit `revalidate` per route plus `revalidatePath` on publish beats clever mixing.
Read - Technical3 min
EventBridge Patterns That Keep Handlers Decoupled
EventBridge decouples handlers when you emit domain events, demand consumer idempotency, and use the schema registry. Not for synchronous request/response.
Read - Technical3 min
Tuning Lambda Memory Without Guessing
Lambda memory is CPU. More memory often means lower bills on CPU-bound code. Tune with real requests, not guesses. Real numbers from eight months of production stack.
Read - Technical3 min
DynamoDB Cost Optimization Without Giving Up the Free Tier
DynamoDB free tier covers real sites when you use on-demand, eventual consistency, split item bodies, and avoid speculative GSIs. Eight months at zero dollars on real traffic.
Read - Technical3 min
Simplicity Under Load: What Breaks and What Does Not
Eight months under real traffic: serverless handlers, DynamoDB on-demand, and Vercel ISR held without tuning. Email quotas, log volume, and admin concurrency strained. Simplicity scales until it hits an assumption, then the fix is local.
Read - Technical3 min
Revisiting Assumptions at the Eight-Month Mark
A quarterly assumptions review catches drift before it becomes outage. One-line ledger, one-line queries, thirty minutes every three months.
Read - Technical3 min
Testing Strategies That Hold Up in Production
Three-tier testing pyramid: pure functions, handler-with-fakes, one smoke per critical path. Every bug fix ships a test. Coverage grows where bugs happen, not uniformly.
Read - Technical3 min
Dataclasses or Pydantic: How I Actually Choose
Pydantic at trust boundaries, dataclasses inside your process. This single rule ends the 'which should I use' debate and cleans up most internal code.
Read - Technical3 min
Python Performance Wins That Actually Pay Off
Eight months of real production profiling: batch DB calls, cache boto3 clients, and upgrade to Pydantic v2. Ignore async-everywhere and micro-optimizations until the profile tells you otherwise.
Read - Technical3 min
Skill Depth Versus Breadth, Revisited With Agents
Agents made execution depth cheap. The new shape that wins is breadth in judgment plus depth in taste, measured by scoping and debugging skill.
Read - Technical3 min
When to Stop Adding Tools to the Stack
Every new tool has a hidden maintenance cost 5x the learning cost. Quarterly stack audits and a subtractive mindset beat chasing the next framework.
Read - Technical3 min
The Compound Effect of Skills, Eight Months In
Eight months in, skill boundaries have dissolved. New problems now resolve in tools I already own. That is the compound effect of an adjacent-skills practice, agent-amplified.
Read - Technical3 min
Maintaining WordPress Sites With Agents, Not Cron Jobs
WordPress maintenance is the boring work agents actually excel at. Playbook-driven weekly loops with reversible auto-fixes and propose-only risky changes keep client sites healthy.
Read - Technical3 min
Giving Agents Memory Without Giving Them Amnesia
Agent memory in three layers: decisions in DECISIONS.md, progress in STATE.md, scratch in the session window. Write back at the end of every session or re-explain tomorrow.
Read - Technical3 min
MCP Server Patterns I Actually Use in Production
Three MCP server patterns that survive production: read-only reporter, scoped writer, dry-run default. Generic SQL or filesystem servers are liabilities.
Read - Technical3 min
Teaching Junior Developers to Work With Agents, Not Against Them
Juniors trained with agents get faster, not worse, when I enforce the explain-before-accepting rule, weekly debugging drills, and prompt-writing practice.
Read - Technical3 min
Using AI to Write Documentation That Actually Gets Read
AI closed the documentation gap, but only after I gave it a two-step prompt: outline first from the reader's perspective, prose second. Generic prompts still produce unread docs.
Read - Technical3 min
Writing Code That Still Makes Sense After the Agent Moves On
Agent output has a smell six weeks later. A merge-time checklist turns generated code into code I would have written myself.
Read - Technical3 min
When AI Actually Slows You Down
AI slows me down on small mechanical edits, unfamiliar runtime debugging, and early architecture decisions. Knowing the bucket a task falls in is the real skill.
Read - Technical3 min
Orchestrating Multiple Agents Without the Coordination Tax
Multi-agent orchestration survives real projects when you enforce folder boundaries, freeze shared interfaces, and serialize through artifacts instead of chat.
Read - Technical3 min
How I Evaluate an AI Agent Before Letting It Touch Production
After eight months, I trust no agent without a three-gate evaluation: known-failure regression, behavior-preserving refactor, and explanation under pressure.
Read - Technical3 min
Content Pipeline Automation: From Idea to Published Post
The pipeline that made daily publishing sustainable: capture, triage, draft, publish, distribute. I automate everything except the actual writing.
Read - Technical2 min
Email Bounce Handling: The Part Everyone Skips
Hard bounces and complaints should trigger instant unsubscribes. Skip the handling and your sender reputation collapses. Here is the SES event flow I use.
Read - Technical3 min
Search Console Patterns That Reveal Real SEO Issues
Search Console signals that actually matter: dropping indexed count, pages with impressions but no clicks, sitemap vs indexed mismatch. What I ignore, and why.
Read - Technical3 min
Core Web Vitals in the Real World: What Actually Moves the Needle
What actually moved Core Web Vitals: preload the hero, use modern image formats, defer third-party scripts. What did not: code-splitting, DOM tuning, reducing JS.
Read - Technical3 min
Technical Due Diligence for Clients: The Checklist I Run
The technical due diligence checklist I run before taking over a codebase. Code quality, infra, security, docs. Every failure is either a priced risk or a reason to walk.
Read - Technical3 min
Retainer vs Project Pricing: How I Actually Choose
Match the pricing shape to the work shape. Projects for defined outcomes. Retainers for ongoing relationships. Never fixed-fee with fluid scope.
Read - Technical3 min
WordPress Multisite: When It Is Worth the Complexity
Multisite is a specialist tool. 10+ similar sites, centralized governance, shared functionality. Otherwise, separate installations beat it almost every time.
Read - Technical2 min
WooCommerce Integration Patterns for Serverless Backends
WooCommerce plus serverless: webhooks out, REST in, custom endpoints for the smart parts. Always use a queue. Always add idempotency keys.
Read - Technical2 min
React Error Boundaries: Where to Put Them and What to Show
Error boundaries at the route and widget level, never at the leaf. Useful fallback UI, not apologetic. Log the stack so you can actually fix it.
Read - Technical3 min
ISR in Production: Incremental Static Regeneration Without Surprises
ISR in production has traps: traffic-dependent revalidation, cache mismatches, stale aggregations. Here is how I actually use it after six months.
Read - Technical3 min
The Cost of Cool: When Chasing New Tools Backfires
Adopting cool tools has a tax: learning, docs, integration, churn, hiring, bugs. I add it up honestly now. Most new tools do not clear the bar.
Read - Technical3 min
Why Boring Infrastructure Wins in Production
My stack is boring on purpose. DynamoDB, SES, Lambda, Next.js. Boring means debuggable, hireable, predictable. The new shiny thing almost never survives six months of review.
Read - Technical3 min
Build vs Buy Revisited: Six Months of Choices
AI changed the math on build vs buy. Building is cheaper, SaaS is more expensive. Here is the framework I use now, and the concrete choices I made.
Read - Technical2 min
Python Plus AWS SDK: The Boto3 Patterns I Actually Use
Four boto3 patterns that survived six months of production: resources by default, single client per process, always paginate, branch on ClientError codes.
Read - Technical2 min
Logging in Production: What to Log, What to Skip
A logging strategy that survives production: structured JSON, request IDs everywhere, log decisions not steps, sample the noisy stuff, never log secrets.
Read - Technical2 min
Python Error Handling Patterns That Survive Production
Five error handling patterns that survive production: catch specific, structure errors, always include context, model retryability, fail loud at the boundary.
Read - Technical3 min
CloudWatch Monitoring for $0: The Free Tier Monitoring Stack
CloudWatch free tier is enough to monitor real production if you are disciplined. Five alarms, one dashboard, log-based metrics, strict retention.
Read - Technical2 min
API Gateway Auth: The Pattern That Did Not Leak
Six months of API Gateway auth without a leak. Use the built-in authorizers when you can. Here is the pattern and the Lambda authorizer trap to avoid.
Read - Technical2 min
Lambda Layers: When They Help and When They Hurt
Lambda layers are great for large shared dependencies. They are overhead for everything else. Here is the rule I use to decide.
Read - Technical2 min
When the Skill Soup Fails: Too Many Tools, Not Enough Glue
The skill soup thesis has a failure mode: too many tools without enough glue. Here is the friction budget rule I added to keep pipelines sane.
Read - Technical2 min
Backend Plus Frontend Plus AI: The Three-Stack Combo That Ships
FastAPI + Next.js + Claude. The division of labor that survived six months of production. Backend owns data, frontend owns UX, AI owns intent.
Read - Technical2 min
Three-Tool Pipeline Example: Scrape, Transcribe, Publish
A concrete three-tool pipeline: scrape, transcribe, publish. Each tool narrow, each step cacheable, the whole thing restartable.
Read - Technical2 min
Agent Observability: Seeing What Your Agents Actually Do
Four layers of observability for production agents: run logs, cost tracking, alerts, replay. Skip any of them and you are debugging blind.
Read - Technical2 min
Migrating a WordPress Site with AI: The Pattern That Worked
Three hundred posts migrated in two days. The pattern: analyze first, migrate in batches, review samples, let fixes propagate.
Read - Technical2 min
Error Boundaries for Agents: Containing Blast Radius
Error boundaries contain the blast radius when agents misbehave. Allowlists at the code level, not prompt instructions. Here is the pattern.
Read - Technical2 min
Production Agent Patterns: What Survives Real Traffic
Four patterns that separate demo agents from production ones: queue in front, tool timeouts, budget caps, full observability.
Read - Technical2 min
Model Selection Strategy: Picking the Right Brain for the Job
Routing tasks across model tiers is the biggest cost and quality win I have made all year. Flagship for architecture, mid-tier for code, small for lookups.
Read - Technical2 min
Prompt Caching in Production: Cutting Costs Without Cutting Quality
Prompt caching cut my AI bill by 60% on bursty workflows. Cache the preamble, not the conversation. Here is how I structure it.
Read - Technical2 min
AI-Assisted Debugging: Where It Shines and Where It Fails
AI debugging is great for code-visible bugs and framework gotchas. It struggles with production state and correlated failures. Here is when to lean in.
Read - Technical2 min
Claude Code Plus Git: The Workflow That Survived Six Months
The workflow I still use six months later: one branch per intent, commit after every verified step, human in charge of the git graph.
Read - Technical2 min
Codex for Async Tasks: Offloading the Background Work
Six months of serverless building taught me to split interactive and async work. Claude Code stays in the loop. Codex handles the background jobs.
Read - Technical2 min
September Retrospective: What Ships Next
End of September. Five months of shipping, teaching, and iterating. Here's the honest state of the system and what October needs to prove.
Read - Technical2 min
AI Code Review: Who Checks the Agent?
If an AI writes the code and an AI reviews the code, you're not catching bugs. You're catching agreements. Here's how I structure review to still work.
Read - Technical2 min
Prompt Patterns I Stopped Using
The prompting advice from 2023 was mostly noise. Here are the patterns I've dropped over five months and why.
Read - Technical2 min
Consulting: Scope Shaped by Verification, Not Features
Every scope creep I've suffered this year started the same way: I scoped what I'd build, not what I'd verify. AI-assisted work makes this mistake expensive fast.
Read - Technical2 min
The Deploy Script That Outlasts CI/CD
Every CI/CD pipeline I've set up has been replaced within two years. The shell script in deploy.sh has survived them all.
Read - Technical2 min
Content Pipeline: September State of the Machine
The content production system I've iterated on for five months has settled into a steady state. Here's what the pipeline looks like today.
Read - Technical2 min
SEO Structured Data: What Actually Shows in Search Results
After months of adding JSON-LD to client sites, here's which structured data actually affects what Google shows, and which is busywork.
Read - Technical2 min
WordPress REST API: Good Enough for Most Headless Clients
You don't need a headless CMS to have a headless site. WordPress ships with a REST API that covers 80% of use cases, and the client keeps their familiar admin.
Read - Technical2 min
WordPress Custom Post Types: The Content-Shaping Superpower
Most WordPress sites stop at posts and pages. Custom post types turn WordPress into a shape-aware CMS that fits whatever content you actually need.
Read - Technical2 min
React Suspense: After Five Months, It Finally Makes Sense
Suspense confused me for years. Using it daily for five months cleared the fog. Here's the mental model that finally stuck.
Read - Technical2 min
Next.js Server Actions: The Feature That Earned My Trust
I was skeptical of server actions in April. After months of shipping with them, they quietly solved my form-handling pain points.
Read - Technical2 min
DynamoDB Streams: The Quiet Superpower in My Stack
Streams turn DynamoDB from a key-value store into an event-driven backbone. I ignored this feature for months. I shouldn't have.
Read - Technical2 min
SQS Patterns That Held Up Under Real Traffic
Three SQS patterns I've leaned on for months of production traffic. Each one solved a concrete problem I first tried to solve another way.
Read - Technical2 min
Serverless: What Finally Broke at Scale
Five months of running client workloads on AWS free tier. Here's where the abstractions leaked and what I changed.
Read - Technical2 min
The Skill Soup: Integration Is the Hard Part, Not the Skills
Collecting skills is easy. Combining them under time pressure is the actual work, and almost nobody trains for it.
Read - Technical2 min
The Skill Soup: September Recipes That Worked
Four skill combinations I shipped with in September, plus the one that didn't work and why.
Read - Technical2 min
The Skill Soup: Why Specialists Plateau in the AI Era
Deep specialization used to compound. In an AI-assisted world, the returns flatten fast. The operators who combine skills are pulling ahead.
Read - Technical2 min
First Principles: Fewer Abstractions, Not More
The senior-engineer instinct to wrap everything in abstractions is the biggest cost multiplier I've seen in client codebases this year.
Read - Technical2 min
First Principles: Naming Is Design, Not Decoration
If you can't name something well, you don't understand it. After five months of agent-driven development, good names matter more than ever.
Read - Technical2 min
First Principles: When to Rewrite Instead of Refactor
Most rewrites fail because they start from the wrong question. Going back to first principles changes the decision.
Read - Technical1 min
The Python Logging Config I Stopped Changing
I spent years tweaking my Python logging config per project. Then I committed to one setup, and every service has used it for months without complaint.
Read - Technical2 min
FastAPI Dependency Injection: Patterns That Survive Refactors
FastAPI's Depends is the feature nobody teaches properly. Used well, it makes testing trivial. Used badly, it creates magic that nobody can follow.
Read - Technical2 min
Python Decorators I Actually Use in Production
Decorators are Python's most abused feature. After years of building backends, I use exactly four, and they earn their keep every day.
Read - Technical2 min
Testing Agents Like You Test Code
If your agent has no tests, you have no agent. You have a prompt and a prayer. Here's how I bring real testing discipline to non-deterministic systems.
Read - Technical2 min
Tool-Use Patterns: Closing the Loop on Autonomous Agents
After months of experimenting with tool-calling loops, the patterns that hold up in production all share one property: the agent knows when to stop.
Read - Technical2 min
MCP Protocol: Three Months of Production Use
The Model Context Protocol looked like a nice abstraction in June. After three months in production, it's the quiet backbone of every multi-tool workflow I run.
Read - Technical2 min
Agent-as-a-Folder: Five Months Later, The Pattern That Stuck
The agent-as-a-folder pattern I wrote about in spring has quietly become the only way I start new projects. Here's why it outlasted every other organizational approach.
Read - Technical2 min
AI Pair Programming: What Actually Helps and What's Theater
Pair programming with an AI is nothing like pair programming with a human. Stop pretending it is and the workflow gets faster.
Read - Technical2 min
Cursor vs Claude Code: The September Update After Daily Use
After running both tools daily for months, the verdict isn't about which is better. It's about which task shape each one fits.
Read - Technical2 min
Five Months In: What Actually Ships and What Gets Abandoned
After five months of daily AI-assisted building, here's the honest breakdown of which workflows survive contact with real projects and which quietly die.
Read - Technical3 min
Four Months In: What the Skill Soup Is Actually Teaching Me
The skill soup thesis has survived four months of daily practice. Here is what I have learned about which skills combine well and which do not.
Read - Technical2 min
Why I Prefer Lambda Destinations Over Dead Letter Queues
Both solve the failure-handling problem. Lambda destinations do it better for most use cases. Here is why I reach for them first.
Read - Technical3 min
Canonical URLs: The SEO Lever Most Sites Get Wrong
Canonical URLs are simple to understand and easy to get wrong. Here is what I see on real client sites and how I fix it.
Read - Technical2 min
Feature Flags Without a Vendor
Feature flag SaaS is often overkill. Here is the simple DIY feature flag system that handles 95 percent of cases at zero cost.
Read - Technical2 min
WordPress Security After Four Months of Production Sites
I manage multiple production WordPress sites for clients. These are the security practices that have caught real attacks and prevented real damage.
Read - Technical2 min
Choosing the Right Claude Model for the Job
Claude Opus, Sonnet, Haiku: each has a job. After four months of daily use, here is how I actually route work between them.
Read - Technical3 min
AI Agents and Git: A Marriage That Needed Rules
AI agents doing git operations is powerful and dangerous. Four months of near-misses and accidents later, these are the rules I now enforce.
Read - Technical2 min
Tailwind at Four Months: What Still Frustrates Me
I love Tailwind. I use it on every project. But I would be lying if I said it is perfect. Here are the four months of accumulated frustrations.
Read - Technical2 min
The Case for Single-File Services
Most of my small services live in a single Python file. This is not laziness. It is a deliberate architectural choice with real benefits.
Read - Technical3 min
Async Python for Real Workloads: When It Helps and When It Hurts
Async Python is not always faster. Four months of production use taught me where it shines and where it just adds complexity.
Read - Technical2 min
Consulting Pricing: Four Months of Moving Away From Hourly
I spent years billing by the hour. Four months into value-based and fixed-scope pricing, here is what I learned the hard way.
Read - Technical2 min
Structured Data for AI Search: What Actually Works in 2025
Search is splitting between humans and AI engines. Structured data is how you speak to both. Here is what is pulling real traffic in 2025.
Read - Technical2 min
WordPress Block Patterns: The Feature I Wish I Used Sooner
Block patterns are the most underrated feature in modern WordPress. Here is how they transformed how I hand off sites to clients.
Read - Technical2 min
When I Reach for Background Agents vs Interactive Ones
Codex-style background agents and Claude Code interactive agents solve different problems. Here is how I split work between them.
Read - Technical2 min
SQS vs EventBridge: How I Actually Decide
Both are AWS messaging services. Both look similar in diagrams. The decision between them is actually clean if you know the one question to ask.
Read - Technical2 min
The Skill Soup Thesis: What It Looks Like in Practice
I have been writing about the skill soup for months. Here is what it actually looks like on a live project, with the skills named.
Read - Technical2 min
Observability for Small Teams: What to Log, Metric, and Trace
Full observability stacks are overkill for small teams. Here is the minimal observability setup that has served me across every production app this year.
Read - Technical2 min
Idempotency Keys: The Distributed Systems Primitive Worth Learning
Idempotency keys are the simplest tool for building reliable distributed systems. Here is how I apply them across every API I ship now.
Read - Technical2 min
Cursor and Claude Code Together: A Real Two-Tool Workflow
I use Cursor and Claude Code the same day for different jobs. Here is how the tools split responsibilities in my actual workflow.
Read - Technical2 min
Python Typing Patterns I Use Daily
Python type hints went from nice-to-have to essential in my codebase. These are the patterns I use every day and could not live without.
Read - Technical2 min
Building a Full WordPress Site With AI Agents End to End
I now build complete WordPress sites with Claude Code driving the keyboard. Here is the actual workflow that ships sites in days, not weeks.
Read - Technical2 min
SES Deliverability: The Setup Checklist I Now Follow
After watching too many clients land in spam, here is the SES setup sequence I now run on every new domain before sending a single email.
Read - Technical2 min
MCP Servers in Production: What Actually Ships
The Model Context Protocol lets agents talk to tools reliably. Four months in, these are the patterns that actually hold up in production.
Read - Technical2 min
Why I Stopped Reaching for Microservices
The microservices impulse is the biggest cargo cult in software. Here is the first-principles reasoning I now apply before splitting anything.
Read - Technical2 min
Next.js Data Fetching Patterns That Outlived the Framework Churn
Next.js has changed data fetching APIs four times in three years. These three patterns survived every migration.
Read - Technical2 min
Prompt Engineering Is Context Engineering in Disguise
The best prompt engineering technique is to stop doing prompt engineering and start doing context engineering. Let me explain the difference.
Read - Technical2 min
FastAPI Dependency Injection for Real Projects
FastAPI's DI system is one of its best features. Four months of production use later, here are the patterns that held up.
Read - Technical2 min
The Agent-as-a-Folder Pattern, Four Months Later
I wrote about agent-as-a-folder early on. Four months of daily use later, here is what held up and what I would change.
Read - Technical2 min
DynamoDB Secondary Indexes: When They Save You and When They Cost You
GSIs and LSIs are powerful but not free. Here is the mental model I use to decide when a secondary index is worth the cost.
Read - Technical2 min
Claude Code in a Team of One: Workflows That Survived Four Months
Solo consulting means I wear every hat. Four months into daily Claude Code use, these are the workflows that stuck and the ones I dropped.
Read - Technical2 min
Production Lambda Cold Starts: What Actually Moves the Needle
Cold starts are real but fixable. After four months on AWS Lambda, these are the three changes that cut my p99 latency in half.
Read - Technical2 min
Six Months In: What Actually Changed In How I Build
Not a retrospective. A snapshot of the habits that moved. July is a good time to notice which ones stuck.
Read - Technical2 min
Agent Cost Tracking: Knowing Your Spend Before The Bill
AI API bills can surprise you. A thirty-line cost tracker showed me where the money goes and cut my spend by a third.
Read - Technical2 min
FastAPI Dependency Injection: Clean Handlers, Testable Code
FastAPI's DI system looked magical at first. Once I used it for real, it cleaned up every handler in the project.
Read - Technical2 min
Mid-Summer Philosophy: Keep Shipping Small
By July I was tempted to rewrite everything. I did not. Shipping small kept momentum and the codebase honest.
Read - Technical2 min
Cursor Multi-File Editing: Where It Still Beats Terminal Agents
I run Claude Code most days. But Cursor still wins one specific workflow, and I keep both in the toolkit.
Read - Technical2 min
Idempotency Keys: The Quiet Production Lifesaver
Every retry is a potential duplicate. Idempotency keys turn distributed system nightmares into boring HTTP.
Read - Technical2 min
CLAUDE.md Files: Teaching Agents Your Project In One Read
A good CLAUDE.md file cuts agent ramp time from a session to a few paragraphs. Here is what I put in mine.
Read - Technical2 min
Email List Segmentation: Simple Rules, Big Lift
One list to everyone is the fastest way to train subscribers to ignore you. Two or three simple segments and open rates jump.
Read - Technical2 min
Skill Soup In Practice: Building Without Specialists
The skill soup thesis says breadth plus AI beats narrow expertise. Three months in, here is the concrete evidence.
Read - Technical2 min
WordPress REST API: The Bridge To A Modern Frontend
Clients want the WordPress admin. Users want the fast frontend. The REST API bridges both worlds with less code than a full headless setup.
Read - Technical2 min
Tailwind Config Customization Without Losing Defaults
Custom brand colors in Tailwind sound easy until you accidentally wipe the entire palette. Here is the pattern that keeps both.
Read - Technical2 min
Agentic Workflows: State Files for Memory Between Runs
Agents forget between sessions. State files are the simplest way to give them continuity across days and weeks.
Read - Technical2 min
DevOps for Solo Builders: Just Enough Process
Solo builders do not need Kubernetes. But skipping DevOps entirely breaks you at deploy three. Here is the minimum.
Read - Technical2 min
Python Asyncio: When It Helps and When It Hurts
Asyncio is not a free speedup. It helps with IO, hurts with CPU, and trips everyone who thinks of it as threads.
Read - Technical2 min
SEO Internal Linking Patterns That Actually Move Rankings
External backlinks are hard. Internal links are free and underused. Three patterns that moved my rankings in a month.
Read - Technical2 min
Claude Code Parallel Agents: Measuring The Actual Speedup
Everyone says parallel agents are faster. I timed a real feature build with one agent vs four. The number surprised me.
Read - Technical2 min
Serverless Cost Audit: The Half-Year Check-In
Six months running a serverless stack. The AWS bill is still under $1. Here is what the audit actually shows.
Read - Technical2 min
Agent Guardrails: Why Boundaries Matter in Production
An agent with infinite tools is an agent that ships bad things to production. Explicit guardrails are how you sleep at night.
Read - Technical2 min
Python Typing Protocols: Structural Interfaces Without The Boilerplate
Protocols let me write 'anything that quacks like this' types. Less coupling, cleaner tests, no inheritance dance.
Read - Technical2 min
Summer Stack Audit: What Stayed and What Left
Three months into this platform I did a honest stack audit. Some tools earned their keep. Some did not. Here is what changed.
Read - Technical2 min
MCP Servers: Building Your First One in 30 Minutes
MCP sounded complex. Then I built one. It is a stdio process that speaks JSON-RPC. The rest is what you decide to expose.
Read - Technical2 min
WordPress Custom Blocks: Letting Clients Edit Without Breaking
Clients want to edit. Developers want things not to break. Custom blocks with constrained inputs is how both sides win.
Read - Technical2 min
Next.js Server Actions: Replacing Half My API Routes
Server Actions made half my /api/ routes disappear. Less code, fewer round trips, cleaner mental model.
Read - Technical2 min
Agent Handoffs: Structured Returns Beat Prose
When one agent hands work to another, free-form prose loses information. JSON returns let orchestrators actually orchestrate.
Read - Technical2 min
Lambda Cold Starts: What Actually Helps (And What's Theater)
Provisioned concurrency is the default advice. After benchmarking my own functions, simpler fixes cut cold starts more.
Read - Technical2 min
Claude Code Planning Mode: Spec Before Code Saves Hours
I stopped letting Claude Code write code on the first message. Planning mode forces a spec, and the code that follows is dramatically better.
Read - Technical2 min
Python Dataclasses vs Pydantic: Picking the Right Tool
Both look similar. One validates, one does not. I use both in the same codebase, and the split matters.
Read - Technical2 min
DynamoDB GSI Design: Design Your Queries Before Your Schema
Three GSIs in and I had to rebuild the table. DynamoDB punishes schema-first thinking. Start from queries.
Read - Technical2 min
Prompt Files: Versioning Instructions Like Code
Inline prompts rot. I moved every non-trivial prompt into a .md file, version-controlled it, and tripled my output consistency.
Read - Technical2 min
FastAPI Background Tasks vs SQS: When Each One Wins
Not every async job needs a queue. Three months of shipping told me when FastAPI BackgroundTasks is enough and when it breaks.
Read - Technical2 min
Claude Code Subagents: Spawning Specialists That Actually Help
After three months with Claude Code, I stopped asking one agent to do everything. Subagents with narrow scopes ship cleaner work.
Read - Technical3 min
The First Thirty Days of a Consulting Engagement
First thirty days of consulting: listen in week 1, assess in week 2, propose in week 3, ship something small in week 4. The pattern that gets engagements extended.
Read - Technical3 min
React Server Components Changed How I Build
React Server Components eliminated most of my data fetching boilerplate. Components are now async functions that return HTML. Interactivity stays on the client.
Read - Technical3 min
SEO Fundamentals That Still Work in 2025
SEO fundamentals that still work: content that answers real questions, fast accessible pages, semantic HTML, useful metadata, internal links, and sitemaps.
Read - Technical3 min
Testing FastAPI Endpoints Without a Database
Test FastAPI endpoints without a database by overriding dependencies with fakes. Millisecond test runs, no Docker, full route coverage.
Read - Technical3 min
Multi-Tool Workflows for Content Production
Content production pipeline across Obsidian, Claude Code, Grammarly, VS Code, and a Python script. Each tool best in class, glued with plain text.
Read - Technical3 min
Simplicity as an Architectural Principle
Simple systems outlast complex ones. Avoid abstractions with one implementation, configuration for constants, and microservices that could be functions. Add complexity only when forced.
Read - Technical3 min
Building a WordPress Site With Claude Code End to End
A full WordPress site in four hours: Claude Code writes theme, plugin, and forms. I handle brand judgment, content strategy, and quality assurance.
Read - Technical3 min
Event-Driven Architecture With SQS and Lambda
Event-driven architecture on AWS: API writes to SQS, Lambda processes asynchronously. The user gets a fast response while slow work happens in the background.
Read - Technical3 min
The Skill Soup Thesis: Why Narrow Specialization Fails
The Skill Soup thesis: generalists who combine ten skills outpace specialists who master one. AI closes the depth gap; real problems ignore domain boundaries.
Read - Technical3 min
Writing Prompts That Generate Consistent Output
Consistent AI output requires explicit format specs, examples, low temperature, validation, and tool calling when available. Treat prompts like function signatures.
Read - Technical3 min
Docker Compose for Local Development
Docker Compose gives every project a reproducible local environment in one file. Clone, run, code. No installing databases, no version mismatches.
Read - Technical3 min
Tailwind Utility Patterns for Maintainable CSS
Tailwind stays maintainable when you extract with components (not CSS classes), use config for design tokens, group classes by purpose, and avoid @apply.
Read - Technical3 min
Pydantic for API Contract Enforcement
Pydantic turns API contracts into enforceable models. Validation, type coercion, and response filtering all happen at the boundary before bad data reaches your logic.
Read - Technical2 min
WordPress Theme Development with the Block Editor
Block themes let WordPress clients edit layout from the admin. Four files, pure HTML and JSON, with AI scaffolding the structure and humans tuning the brand.
Read - Technical3 min
Combining Claude Code and the Browser DevTools
Debug faster by pairing DevTools (runtime view) with Claude Code (code view). The bug usually lives in the mismatch between them.
Read - Technical3 min
Lambda Functions for Scheduled Jobs
Scheduled jobs on Lambda and EventBridge cost nothing in the free tier. No servers, no cron daemon, no uptime to monitor. EventBridge handles reliability.
Read - Technical3 min
React State Management Without Redux
React state management in 2025: useState for local, Context for cross-tree, TanStack Query for server data, Zustand for global client state. Redux only when truly needed.
Read - Technical3 min
Why Agentic Development Is Not Vibe Coding
Vibe coding accepts whatever an AI produces. Agentic development constrains the agent with tests, tools, and guardrails. The second approach scales; the first does not.
Read - Technical3 min
Simple Python Scripting for Daily Automation
Daily automation scripts should be single files using only stdlib. Fail loudly, keep arguments simple, and let the OS handle scheduling.
Read - Technical3 min
The Discovery Call Framework That Saves Projects
Discovery calls prevent project failures. Six questions reveal the real problem, the real priorities, and whether the project is actually a good fit for both sides.
Read - Technical3 min
DynamoDB Single-Table Design for Beginners
DynamoDB single-table design: one table, generic pk and sk, entity types encoded in keys. Design around access patterns, not data structure.
Read - Technical2 min
Next.js App Router Patterns I Actually Use
Next.js App Router patterns: Server Components by default, client code at the leaves, data fetching per component, loading boundaries, and Server Actions for mutations.
Read - Technical3 min
Orchestrating Claude Code for Multi-File Refactors
Multi-file refactors are Claude Code's sweet spot. Describe the target state, ask for a plan first, rely on tests as the safety net, and review every diff.
Read - Technical3 min
When to Build Custom vs Buy Off the Shelf
Build vs buy: ask if it is core, if the vendor solves 80% of needs, and whether switching costs beat building. Buy first, build only when the vendor cannot.
Read - Technical3 min
Combining Python and AI for Automated Document Generation
Automated document generation combines Python for structured data and AI for narrative. Python renders numbers perfectly; AI writes the sentences around them.
Read - Technical3 min
Django Models for Multi-Tenant SaaS
Multi-tenant SaaS in Django: foreign-key tenancy, tenant-aware managers, composite indexes, and one test that proves tenants cannot see each other's data.
Read - Technical3 min
Prompt Engineering Patterns for Code Generation
Four prompt patterns that produce useful code on the first try: anchor to a file, constrain output, name failure modes, demand the smallest diff.
Read - Technical3 min
Building a WordPress Plugin with Claude Code
Clients need custom WordPress features. Claude Code scaffolds plugins that match WordPress conventions while I decide the data shape and validation rules.
Read - Technical3 min
My Cursor Setup for Full-Stack TypeScript Projects
Cursor for full-stack TypeScript is a different tool when you tune it. Use .cursorrules for style enforcement, learn Cmd-K vs Cmd-L, and keep the index fresh.
Read - Technical3 min
How I Use Claude Code to Build a FastAPI Endpoint in 10 Minutes
Add a production-quality FastAPI endpoint in ten minutes by giving Claude Code the file, the pattern to mirror, and the error behavior. Orchestration, not vibe coding.
Read - Technical3 min
One Month of Daily Technical Writing: What I Learned
After one month of daily technical writing: batch creation beats manual posting, category taxonomy keeps content organized, and the business-problem opening keeps writing grounded.
Read - Technical2 min
Vercel Deployment: From Git Push to Live in 60 Seconds
Vercel deploys Next.js apps from git push to global CDN in 60 seconds. Free tier includes unlimited projects, HTTPS, preview deployments, and 100GB bandwidth.
Read - Technical3 min
The Skill Soup in Action: Building a Full Platform Solo
Building a full platform solo requires the skill soup: Python + Next.js + AWS + SEO + AI agents. Breadth plus AI-assisted depth enables one person to deliver complete solutions.
Read - Technical3 min
Error Handling Patterns for Production APIs
Production APIs need consistent error handling: 4xx for client errors, 5xx for server bugs. Use Pydantic for validation, HTTPException for business logic, and catch-all handlers for the unexpected.
Read - Technical3 min
Building WordPress Plugins with Claude Code
Build custom WordPress plugins by directing Claude Code with clear intent. Review generated code for security escaping, nonces, and prepared SQL queries.
Read - Technical3 min
How AI Changes the Consulting Business Model
AI makes consultants faster, which breaks the hourly billing model. Switch to value-based pricing where speed increases margin instead of reducing income.
Read - Technical3 min
The DynamoDB Free Tier: What You Actually Get
DynamoDB's perpetual free tier gives you 64.8M writes/month, 129.6M reads/month, and 25GB storage. Use provisioned mode (not on-demand) to qualify.
Read - Technical3 min
Strapi vs Custom API: When to Use a Headless CMS
Strapi gives you a visual admin and auto-generated APIs. Custom APIs give you full control and $0 hosting. Choose based on who maintains the system after handoff.
Read - Technical3 min
Pricing Technical Projects: Value-Based vs Hourly
Value-based pricing charges for outcomes, not hours. AI tools make you faster, and under value pricing, speed increases your margin instead of reducing your income.
Read - Technical3 min
The Agent-as-a-Folder Pattern in Practice
A real-world example of the agent-as-a-folder pattern: CLAUDE.md for conventions, STATE.md for position tracking, SUMMARY.md for session memory. Zero re-explanation across sessions.
Read - Technical3 min
API Versioning: Why You Should Plan for It from Day One
API versioning lets you introduce breaking changes without breaking existing consumers. Use URL path versioning (/api/v1/) from day one to avoid painful migrations.
Read - Technical3 min
Building an AI Agent Workflow: From Intent to Deployment
The AI agent workflow has five phases: intent, planning, implementation, verification, and deployment. AI compresses implementation and frees time for planning and verification.
Read - Technical3 min
React Server Components: What Backend Developers Need to Know
React Server Components render HTML on the server with no JavaScript sent to the browser. Default to server components; add 'use client' only for interactivity.
Read - Technical3 min
Email Deliverability: Why Your Newsletters End Up in Spam
Email deliverability depends on SPF, DKIM, and DMARC authentication plus bounce rates, complaint rates, and engagement. Set these up before sending your first newsletter.
Read - Technical3 min
Simplicity as a Competitive Advantage
Simple systems cost less, break less, and ship faster. Remove unnecessary components, use boring technology, and solve today's problem instead of tomorrow's scale.
Read - Technical3 min
WordPress Blocks: The Modern Way to Build Page Layouts
WordPress blocks let clients build their own page layouts with drag-and-drop. Create custom block patterns for common layouts and custom blocks for unique needs.
Read - Technical3 min
Custom CLAUDE.md Files: Teaching AI Agents Your Conventions
CLAUDE.md teaches AI agents your project conventions once. Include tech stack, code standards, architecture patterns, and things to avoid. Every session starts with full context.
Read - Technical3 min
Why I Chose DynamoDB Over PostgreSQL for This Project
DynamoDB costs $0/month forever with simple access patterns. PostgreSQL wins for complex queries and relationships. Choose based on requirements, not familiarity.
Read - Technical3 min
Structured Data and JSON-LD: Making Your Content Machine-Readable
JSON-LD structured data tells search engines and AI engines what your content means. Implement Article, Organization, and FAQ schemas for rich results and AI citations.
Read - Technical3 min
The Orchestrator Mindset: Why Directing Beats Doing
Shift from writing code to directing agents. The orchestrator mindset focuses on intent, context, and review while delegating implementation to AI tools.
Read - Technical3 min
Lambda Functions: Your First Serverless Deployment
Deploy your first AWS Lambda function in 20 minutes with SAM. A Python handler, a YAML template, and two commands give you a free serverless API endpoint.
Read - Technical3 min
Prompt Engineering Is Just Clear Communication
Prompt engineering is clear communication: provide context, constraints, and success criteria. Remove ambiguity because AI takes you literally.
Read - Technical2 min
Docker for Developers Who Just Want It to Work
Docker solves 'works on my machine' with three commands: docker compose up, down, and logs. Skip the theory and use official images in docker-compose.yml.
Read - Technical3 min
Multi-Tool Workflows: Combining AI Agents for Complex Projects
Combine Claude Code (project scope), Cursor (file scope), Copilot (line scope), and Codex (background) for faster development than any single tool alone.
Read - Technical3 min
Pydantic Models: The Best Python Feature You Are Not Using Enough
Pydantic turns Python type hints into runtime validation. Centralize all data validation in model definitions instead of scattering if-statements across your codebase.
Read - Technical3 min
How to Hand Off a WordPress Site to a Client
Handing off a WordPress site requires admin access, a simple editing guide, plugin documentation, backup strategy, and a recorded walkthrough. Define support terms clearly.
Read - Technical3 min
Copilot, Cursor, Claude Code, Codex: Which AI Tool for What
Copilot for line-level autocomplete, Cursor for file-level editing, Claude Code for project-level scaffolding, Codex for background tasks. Layer all four.
Read - Technical3 min
Mental Models for Software Decisions
Five mental models for better software decisions: the reversibility test, boring technology principle, complexity budget, two-way doors, and the 80/20 rule.
Read - Technical3 min
Building a Content Pipeline with Python Scripts
Build content pipelines with Python scripts instead of manual entry. Use urllib for zero dependencies, handle 409s for idempotency, and version control your content.
Read - Technical3 min
The AI Supercharger Philosophy: Tools, Not Magic
AI tools are superchargers, not magic. They amplify your existing skills but cannot replace judgment, domain knowledge, or the decision to ship.
Read - Technical3 min
How to Structure a FastAPI Project That Scales
Single-file FastAPI apps do not scale. Use APIRouter to split routes by resource, keep models separate, and follow the rule of one responsibility per file.
Read - Technical3 min
Headless CMS Basics: Decoupling Content from Presentation
A headless CMS separates content management from presentation. It enables multi-channel publishing, frontend freedom, and better performance through API-driven content delivery.
Read - Technical3 min
Why Every Newsletter Needs a Plain Text Version
Every newsletter needs both HTML and plain text versions. Many email clients strip HTML, and CAN-SPAM requires your content to be readable for all recipients.
Read - Technical3 min
Building Your First WordPress Theme with AI Agents
Build a production-ready WordPress theme in hours using Claude Code. The agent handles boilerplate, responsive CSS, and WordPress standards while you focus on design decisions.
Read - Technical3 min
The MCP Protocol: Connecting AI Agents to Your Tools
MCP (Model Context Protocol) is the universal connector for AI agents. It gives agents access to databases, APIs, and external services through a standard protocol.
Read - Technical3 min
Why SEO Matters Before You Have Traffic
SEO is infrastructure, not marketing. Build structured data, sitemaps, and meta tags into your foundation before you have traffic, not after.
Read - Technical3 min
Git for the AI Era: What Changes When Agents Write Code
When AI agents write code, your git workflow needs atomic commits, file-level staging after review, and commit messages that track how code was generated.
Read - Technical3 min
Scoping Client Projects: How to Avoid Scope Creep
Scope creep happens when projects lack clear boundaries. Use a four-section scoping document (in scope, out of scope, assumptions, change process) to prevent it.
Read - Technical3 min
Tailwind CSS: Why I Stopped Writing Custom CSS
Tailwind CSS replaces custom stylesheets with utility classes that compose directly in HTML. It eliminates naming, specificity, and dead CSS problems.
Read - Technical3 min
Directing AI Agents: The Art of Intent Over Instructions
Share intent, not instructions, with AI agents. When you explain the problem instead of dictating the solution, agents make better implementation decisions.
Read - Technical3 min
What Is Serverless and Why I Build Everything on It
Serverless means no idle costs, auto-scaling, and no ops. With AWS free tier, you can run a blog platform for $0/month with Lambda, DynamoDB, and SES.
Read - Technical3 min
How I Use Claude Code for Multi-File Refactoring
Claude Code handles multi-file refactoring by finding every reference, updating imports, renaming files, and running tests. Clear instructions and review are key.
Read - Technical3 min
Next.js for Backend Developers: What You Need to Know
Next.js gives backend developers SSR, static generation, API routes, and file-based routing in one framework. Start with one page that fetches from your existing API.
Read - Technical3 min
Why Simple Beats Clever: Lessons from Production Systems
Clever code feels good to write but costs more to maintain. Simple code passes the intern test, the 3am test, and the handoff test.
Read - Technical3 min
Your First AI Agent Project: A Step-by-Step Guide
A practical step-by-step guide to building your first project with an AI agent, from setup through iteration and testing.
Read - Technical3 min
FastAPI vs Django: Choosing the Right Python Framework
FastAPI wins for API-first projects serving a frontend. Django wins when you need a built-in admin panel. Start from requirements, not technology preferences.
Read - Technical3 min
Writing Effective Prompts for Code Generation
Effective prompts for code generation follow the WHAT-HOW-VERIFY pattern. Specificity beats cleverness, and constraints prevent ambiguous output.
Read - Technical3 min
Why WordPress Still Matters in 2025
WordPress powers 43% of the web for good reason. For content-heavy sites with non-technical editors, it beats custom React apps on cost, speed, and maintainability.
Read - Technical3 min
Agent-as-a-Folder: Organizing AI Agents for Real Projects
The best agent architecture is a folder with the right files. CLAUDE.md for conventions, .planning/ for memory, and version control for consistency.
Read - Technical3 min
Cursor vs Claude Code: When to Use Which
Claude Code is a terminal-based project manager for multi-file tasks. Cursor is an IDE pair programmer for inline editing. Use both for different workflows.
Read - Technical3 min
Python in the AI Era: What Actually Matters
In the AI era, Python skills that matter most are data modeling, API design, and scripting. Let AI write the boilerplate while you focus on architecture.
Read - Technical3 min
The Skill Soup: Why Combining Skills Beats Specializing
The skill soup philosophy: maintain a broad collection of skills and combine them as needed, using AI to bridge gaps. Combinations beat narrow specialization.
Read - Technical3 min
What Is Agentic Development and Why Should You Care
Agentic development means directing AI agents to build production systems, not just asking for code snippets. It is orchestration, not autocomplete.
Read - Technical3 min
Getting Started with Claude Code: Your First AI Coding Session
A practical walkthrough of your first Claude Code session, from installation to your first productive prompt and the feedback loop that makes it powerful.
Read - Technical3 min
First Principles Thinking for Software Architecture
Strip away assumptions and start from what your system actually needs. First principles thinking leads to simpler, cheaper, and more maintainable architecture.
Read - Technical3 min
Why I Use AI as a Force Multiplier, Not a Replacement
AI tools are force multipliers, not replacements. The real advantage comes from knowing what to build and using AI to build it faster.
Read