<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Tim Butterfield&#39;s Eclectic Blather</title>
    <link>https://timbutterfield.com/</link>
    <description>Recent content on Tim Butterfield&#39;s Eclectic Blather</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>en-US</language>
    <managingEditor>tim@timbutterfield.com (Tim Butterfield)</managingEditor>
    <webMaster>tim@timbutterfield.com (Tim Butterfield)</webMaster>
    <lastBuildDate>Mon, 07 Sep 2026 00:00:00 +0000</lastBuildDate>
    
        <atom:link href="https://timbutterfield.com/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>I Started as the Orchestration Layer</title>
      <link>https://timbutterfield.com/post/how-my-cross-ai-workflow-became-aimesh/</link>
      <pubDate>Mon, 07 Sep 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/how-my-cross-ai-workflow-became-aimesh/</guid>
      
        <description>&lt;p&gt;I made the aimesh repository public this weekend. Looking at it afterward, what struck me was how little the current workflow resembles where it started.&lt;/p&gt;
&lt;p&gt;The first version was me copying files.&lt;/p&gt;
&lt;h2 id=&#34;it-started-with-manual-review&#34;&gt;It Started With Manual Review&lt;/h2&gt;
&lt;p&gt;I had already been using Claude heavily for software work, but I did not want the model that created an artifact to be the only model deciding whether the artifact was correct. The simplest way to get another perspective was to take what Claude produced and give it to ChatGPT. Initially that could be an individual source file. Later it included implementation plans, architecture documents, prompts, and other artifacts. Sometimes I would ask multiple systems the same question simply to see where their interpretations differed.&lt;/p&gt;
&lt;p&gt;The process was useful because the models did not fail in the same way. One model could work on an artifact through several iterations and reach something that looked stable, only for another model to find a different class of problem. I wrote about that earlier in &lt;a href=&#34;https://timbutterfield.com/post/why-ai-review-needs-more-than-one-model/&#34;&gt;Why AI Review Needs More Than One Model&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;At that stage, however, the mechanism was still mostly conversational. I was the orchestration layer, and there was quite a bit of hidden state in me. I knew what Claude was trying to accomplish, which files ChatGPT needed to see, which instructions needed to travel with them, and what useful feedback needed to go back to Claude. That was manageable when the workflow was occasional. It became less attractive when it turned into the normal way of working.&lt;/p&gt;
&lt;h2 id=&#34;the-handoff-became-a-protocol&#34;&gt;The Handoff Became a Protocol&lt;/h2&gt;
&lt;p&gt;The next step was not a new application. It was a handoff protocol. Instead of treating each cross-model review as a new conversation that I had to reconstruct manually, the process became more explicit. Claude could receive a batch of instructions, perform the work, and leave a defined review artifact. ChatGPT could review that artifact in the context of the ongoing conversation and produce the next batch for Claude. The files and names changed as the workflow evolved, but the important change was that the handoff itself had become part of the engineering process.&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/Tim-Butterfield/aikit&#34;&gt;aikit&lt;/a&gt;, my CLI for deterministic repository mechanics, was already involved in this workflow. The instructions given to Claude began by having it use aikit to establish an anchor before making changes. After the work was complete, aikit could use that anchor to determine which files had been created or modified during the session and assemble the review bundle from the actual change set. Claude did not have to remember which files it had touched or decide what belonged in the review. It did the development work, while aikit handled the mechanical question of what had changed since the session began.&lt;/p&gt;
&lt;p&gt;That solved more than the inconvenience of copying files around. It reduced the amount of interpretation required each time through the loop and moved one class of repository bookkeeping out of the model entirely. The models had clearer roles, the artifact being handed off was known, and the expected response was known. I could still intervene, but I did not have to reconstruct the process on every iteration.&lt;/p&gt;
&lt;p&gt;Using the protocol regularly made another problem much more visible: review can continue long after it stops being useful. Early review passes tend to find real issues. Later passes can become increasingly marginal, speculative, or contradictory, and fixing a legitimate finding can introduce a regression somewhere else. A process that simply says &amp;ldquo;review this again&amp;rdquo; has no natural reason to converge, which led to structured findings, severity rules, verify passes, and explicit stop conditions. I wrote about that problem in &lt;a href=&#34;https://timbutterfield.com/post/why-ai-review-needs-stop-conditions/&#34;&gt;Why AI Review Needs Stop Conditions&lt;/a&gt;. At the time, I was mostly thinking about how to keep a review loop bounded, but in retrospect those rules were also part of a broader shift toward moving deterministic parts of the workflow out of the conversation.&lt;/p&gt;
&lt;h2 id=&#34;automation-did-not-replace-the-handoff&#34;&gt;Automation Did Not Replace the Handoff&lt;/h2&gt;
&lt;p&gt;Eventually I created &lt;a href=&#34;https://github.com/Tim-Butterfield/cross-ai-review&#34;&gt;&lt;code&gt;/cross-ai-review&lt;/code&gt;&lt;/a&gt; for Claude Code and made it public. The command formalized another part of the process: Claude could use independent Codex and Gemini reviews, judge their findings, and apply the accepted changes after the artifact was settled. It made cross-provider review much easier to invoke and much more repeatable, but it did not make the older handoff protocol immediately disappear. I continued using both because they overlapped without solving exactly the same problem.&lt;/p&gt;
&lt;p&gt;That was useful feedback in itself. &lt;code&gt;/cross-ai-review&lt;/code&gt; solved a real problem, but it did not represent the entire workflow I had accumulated. Some work still benefited from the broader ChatGPT conversation, particularly when the review was part of a longer sequence of architectural decisions or when I wanted the independent model to retain the context of how the work had evolved.&lt;/p&gt;
&lt;p&gt;Over time, the limitations became easier to see. The question was no longer just how to get another model to review Claude&amp;rsquo;s work. I wanted the review process itself to have rules that did not depend on whichever model happened to be running it.&lt;/p&gt;
&lt;p&gt;That was the beginning of ReviewMesh.&lt;/p&gt;
&lt;h2 id=&#34;review-became-its-own-system&#34;&gt;Review Became Its Own System&lt;/h2&gt;
&lt;p&gt;ReviewMesh moved the orchestration out of a collection of conventions and into software.&lt;/p&gt;
&lt;p&gt;The distinction mattered more than I expected.&lt;/p&gt;
&lt;p&gt;Once multiple model providers were being used as part of a repeatable engineering workflow, there were questions that prompts alone did not answer very well. Which model actually ran? What happens if the requested model cannot be verified? What is a reviewer allowed to modify? What happens when an adapter fails? Who decides whether a finding is accepted? What happens if a model writes somewhere it was not supposed to write? What does agreement between reviewers actually mean?&lt;/p&gt;
&lt;p&gt;The answers gradually became explicit parts of the system. Reviewers operate against isolated, read-only copies of the workspace while the host retains write authority. The system records model identity according to the evidence available rather than pretending that an unverifiable model has been verified. Failures map into a defined halt taxonomy instead of silently falling through to some other behavior, and agreement is computed by the host instead of being asserted by a model. None of those ideas are especially exciting when considered individually; most came from some version of, &amp;ldquo;I don&amp;rsquo;t want the model deciding that.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;That has become one of the recurring patterns in my AI work. Models are useful for the parts of a problem that require interpretation, reasoning, criticism, or exploration. They are much less interesting for facts the surrounding software can determine directly. If the host can count findings, it should count them. If it can determine which model identity evidence exists, the model should not invent the answer. If only one participant should be able to modify the real workspace, the filesystem should enforce that instead of relying on a sentence in a prompt.&lt;/p&gt;
&lt;h2 id=&#34;review-was-only-one-use-case&#34;&gt;Review Was Only One Use Case&lt;/h2&gt;
&lt;p&gt;For a while, ReviewMesh was an accurate name because review was the problem I was solving. Then I started using the same general idea for exploration, which exposed that the useful abstraction underneath the review workflow was broader than review itself.&lt;/p&gt;
&lt;p&gt;Architecture work had already shown me that independent model disagreement could be useful before there was anything to review. Giving several models the same problem independently could expose different interpretations, different candidate designs, and different assumptions. The useful result was not necessarily consensus. Sometimes the disagreement was the thing I needed to see.&lt;/p&gt;
&lt;p&gt;That created a different orchestration problem.&lt;/p&gt;
&lt;p&gt;A review workflow starts with an artifact and asks models to find problems with it. Exploration starts with a question and asks independent models to investigate it without being influenced by the other answers. A collator, the model responsible for synthesizing the independent responses, can then preserve meaningful disagreement and produce a comparison, shortlist, forecast, or other result appropriate to the task.&lt;/p&gt;
&lt;p&gt;The two workflows had enough in common that duplicating the underlying machinery did not make sense. They needed the same provider adapters, identity handling, containment, configuration, failure behavior, and audit plumbing. They did not need the same domain model.&lt;/p&gt;
&lt;p&gt;That distinction eventually produced the current structure. Review and exploration remain separate domains, while meshcore, a separate Go module, provides the common governance machinery underneath them.&lt;/p&gt;
&lt;p&gt;At that point, ReviewMesh was no longer a very good name.&lt;/p&gt;
&lt;p&gt;It became aimesh.&lt;/p&gt;
&lt;h2 id=&#34;the-interface-changed-again&#34;&gt;The Interface Changed Again&lt;/h2&gt;
&lt;p&gt;The first versions of this entire workflow assumed that I was the caller, and that assumption is becoming less true. aimesh has a CLI, but it also exposes Model Context Protocol (MCP) and Agent Client Protocol (ACP) interfaces. More importantly, much of my current usage does not require me to maintain one permanent model configuration and invoke it manually every time. An agent can decide what kind of panel, meaning the models and roles assigned to a particular run, makes sense for the work in front of it. It can compose that panel, price or validate it with a dry run, and then invoke aimesh through the CLI or MCP.&lt;/p&gt;
&lt;p&gt;This is a fairly strange place to have ended up considering where the process started. I no longer decide every individual model call myself, and I am comfortable letting an agent decide that a particular problem would benefit from two independent reviewers and a stronger host model. That does not mean I want the governance to move farther away with the mechanics. I am less interested in letting the same agent redefine filesystem containment, silently substitute models, invent agreement, or expand its write authority because doing so would be convenient.&lt;/p&gt;
&lt;p&gt;The orchestration can become more dynamic while the boundaries around it become more explicit. Once an agent is deciding which other agents to use, the distinction between model judgment and deterministic authority matters at least as much as it did when I was manually carrying files between systems.&lt;/p&gt;
&lt;h2 id=&#34;i-did-not-plan-this-architecture&#34;&gt;I Did Not Plan This Architecture&lt;/h2&gt;
&lt;p&gt;It would make a cleaner story if I had started with a design for governed multi-model orchestration and gradually implemented it.&lt;/p&gt;
&lt;p&gt;That is not what happened.&lt;/p&gt;
&lt;p&gt;I wanted another model to look at a file.&lt;/p&gt;
&lt;p&gt;The next step happened because doing that repeatedly was awkward. The handoff protocol happened because context and roles needed to be repeatable. Stop conditions happened because review loops did not naturally converge. &lt;code&gt;/cross-ai-review&lt;/code&gt; happened because cross-provider review had become common enough to deserve automation. ReviewMesh happened because the rules around review were becoming more important than the prompts performing it. Exploration expanded the problem enough that the review-specific name stopped fitting. MCP and ACP became useful because the caller increasingly was not a person sitting at a shell.&lt;/p&gt;
&lt;p&gt;Even some of the things that seemed temporary lasted longer than I expected. The handoff protocol continued after &lt;code&gt;/cross-ai-review&lt;/code&gt; existed because the new mechanism had not actually replaced everything the older workflow was doing.&lt;/p&gt;
&lt;p&gt;I think that is probably healthier than having found the current abstraction immediately.&lt;/p&gt;
&lt;p&gt;There is a temptation, particularly with AI tooling, to build a platform before there is enough experience to know what the platform should guarantee. The number of possible abstractions is enormous. Agents can call agents, models can review models, tools can dynamically discover other tools, and almost any part of the process can be turned into another layer.&lt;/p&gt;
&lt;p&gt;The difficult part is deciding which layers have earned their existence.&lt;/p&gt;
&lt;p&gt;Most of the parts of aimesh that I care about now exist because I had already encountered the problem they address in an earlier version of the workflow. That does not prove that the current abstractions are correct, but it gives me more confidence in them than if I had started by designing a general multi-agent framework on a blank page.&lt;/p&gt;
&lt;h2 id=&#34;making-it-public-changes-the-experiment&#34;&gt;Making It Public Changes the Experiment&lt;/h2&gt;
&lt;p&gt;Until now, most of this has been a personal engineering workflow.&lt;/p&gt;
&lt;p&gt;I built it because I wanted it. I am also its primary user, which creates an obvious weakness in evaluating the design. The person who understands why every rule exists is also the person most capable of unconsciously working around anything that is awkward.&lt;/p&gt;
&lt;p&gt;Making aimesh public changes that a little.&lt;/p&gt;
&lt;p&gt;The repository includes the implementation, documentation, releases, and the limitations I know about. Windows support, for example, is coded for but has not been exercised against real Windows filesystems and provider CLIs, and some containment guarantees are weaker there. meshcore lives inside the repository, but I am not publishing it independently until there is a real external consumer that gives me a reason to stabilize that API.&lt;/p&gt;
&lt;p&gt;Those limitations seem worth stating rather than smoothing over. One of the ideas behind aimesh is that evidence should be reported at the strength it actually has. It would be odd to apply a different standard to the project itself.&lt;/p&gt;
&lt;p&gt;I do not know whether anyone else will find the tool useful, and that is part of what making it public can answer. The repository is at:&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/Tim-Butterfield/aimesh&#34;&gt;github.com/Tim-Butterfield/aimesh&lt;/a&gt;&lt;/p&gt;
&lt;h2 id=&#34;where-this-leaves-me&#34;&gt;Where This Leaves Me&lt;/h2&gt;
&lt;p&gt;I previously wrote in &lt;a href=&#34;https://timbutterfield.com/post/why-ai-review-needs-more-than-one-model/&#34;&gt;Why AI Review Needs More Than One Model&lt;/a&gt; that the long-term problem in AI-assisted development probably was not finding the single best model. I thought the more interesting problem was creating trustworthy workflows where multiple models, deterministic tooling, structured verification, and human judgment could work together. aimesh is where following that idea has taken me so far, although I would be surprised if this were the final form of the workflow. aimesh is a long way from uploading a Claude-generated file to ChatGPT and asking what it thought, but the underlying reason for using more than one model has not changed very much.&lt;/p&gt;
&lt;p&gt;I made the repository public this weekend, but I do not really consider that the end of the experiment. I am still changing how I use it, and if the history is any indication, some part of the current workflow will eventually become awkward enough to force another change. At this point, I am mostly curious which part that will be.&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>Stronger Models Help Most After the Problem Has Been Shaped</title>
      <link>https://timbutterfield.com/post/stronger-models-help-most-after-problem-has-been-shaped/</link>
      <pubDate>Wed, 01 Jul 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/stronger-models-help-most-after-problem-has-been-shaped/</guid>
      
        <description>&lt;p&gt;One of the more subtle failures in AI-assisted development is not that the model gives a bad answer. It is that the model gives a good-looking answer before the team has found the right question. That failure is especially easy to miss in architecture work, where a polished decomposition can make unresolved boundaries feel settled, a confident recommendation can make tradeoffs look evaluated, and a clean diagram can make a design look real before its responsibilities have survived allocation.&lt;/p&gt;
&lt;p&gt;The risk is not simply that AI might be wrong. The more interesting risk is that its output can resemble judgment while quietly skipping the work that judgment requires. In earlier posts I wrote about stop conditions, multi-model review, and the way AI makes missing judgment more expensive. This article continues that thread by looking at a related pattern: stronger models can be extremely useful, but their usefulness depends heavily on when they enter the workflow and what role they are allowed to play.&lt;/p&gt;
&lt;p&gt;That is why I am increasingly skeptical of automatically reaching for the strongest and most expensive AI model first for complex software design work. Model capability matters, but capability applied too early can produce persuasive structure around an under-shaped problem. Cost also matters, although not in the simplistic sense of always preferring the cheaper option. If a model is substantially more expensive to use, it should be brought in where its additional reasoning capacity is likely to change the outcome, not merely where it can produce the first plausible draft. At the same time, underinvesting in reasoning for decisions that will shape a long-lived system can be far more expensive than the model cost being avoided. In design work, the better question is how to match model capability, model cost, workflow maturity, and decision consequence.&lt;/p&gt;
&lt;h2 id=&#34;the-real-problem-was-not-model-choice&#34;&gt;The Real Problem Was Not Model Choice&lt;/h2&gt;
&lt;p&gt;The case involved the architecture of a SaaS product with significant long-term variation. Different deployments would need different rules, terminology, configuration, workflows, and reporting behavior, while the core platform needed to remain stable. The system also had to support auditability and AI-assisted work without hardcoding those variations into the core design.&lt;/p&gt;
&lt;p&gt;That makes the architecture problem larger than a simple decomposition exercise. The question was not merely where to put a few services or classes. The system needed stable boundaries that could survive future variation. It needed to distinguish between product concepts that would change frequently and operational mechanisms that should remain stable. It also needed to avoid turning every business concept into a central dependency.&lt;/p&gt;
&lt;p&gt;The early architecture had concrete problems. Some parts of the system reached across boundaries in ways that would have created hidden coupling. Some responsibilities were mutually dependent. Some boundaries looked reasonable at the diagram level but broke down when tested against actual component ownership. I used a multi-model workflow to apply and test the design against Righting Software / IDesign-style standards. In this context, that meant evaluating the architecture against principles such as identifying volatility, assigning responsibilities carefully, respecting explicit boundaries, treating subsystems as cohesive vertical slices, distinguishing business behavior from supporting mechanisms, and validating the design through interaction analysis.&lt;/p&gt;
&lt;p&gt;This was exactly the kind of problem where AI can be useful and risky at the same time. A model can generate plausible architectures quickly. It can name subsystems, propose flows, identify patterns, and produce diagrams. But plausible architecture is not the same thing as durable architecture. A design can sound correct while hiding boundary violations, ownership confusion, or infrastructure choices that compensate for unclear business seams.&lt;/p&gt;
&lt;p&gt;The important question was not which model could produce the most impressive answer. The important question was how to use different model capabilities without letting any model prematurely become the architect of record.&lt;/p&gt;
&lt;h2 id=&#34;the-first-need-was-breadth-not-closure&#34;&gt;The First Need Was Breadth, Not Closure&lt;/h2&gt;
&lt;p&gt;The initial workflow used multiple agents to explore alternatives independently. That mattered because the early goal was breadth rather than convergence. Different models and harnesses surfaced different interpretations of the same architectural problem. Some emphasized subsystem topology. Some focused on volatility seams. Some were more sensitive to command and query ownership. Others were better at identifying cross-boundary communication risks. None of those perspectives was sufficient by itself, but together they created a wider map of the problem.&lt;/p&gt;
&lt;p&gt;That is an important distinction in AI-assisted design. The first useful output from a model is not always an answer. Sometimes it is a disagreement worth preserving. A weak workflow would have forced the early results into an average, taken the apparent consensus, smoothed over the conflicts, and moved forward with a design that looked settled. That would have been easier, but it would also have destroyed useful information. In this case, the disagreement was not noise. It was evidence that the architecture problem still contained an unresolved seam.&lt;/p&gt;
&lt;p&gt;The early passes narrowed the candidate space, but they did not settle the design. They helped expose the shape of the uncertainty. The work eventually narrowed from a broad question, “Which architecture is best?” to a more specific question: whether a central part of the domain represented one volatility area or two. That smaller question was far more useful because it had context, competing candidates, known defects, design standards, and prior critiques attached to it. By the time the stronger model entered, the problem had changed from a blank-page architecture request into a bounded decision problem.&lt;/p&gt;
&lt;h2 id=&#34;a-stronger-model-needs-a-job-not-a-blank-page&#34;&gt;A Stronger Model Needs a Job, Not a Blank Page&lt;/h2&gt;
&lt;p&gt;Fable 5 entered the workflow later, after other passes had already explored the space and after the unresolved issue had become more explicit. In this case, that timing was not a controlled experiment in deliberately withholding the strongest model from the first pass. Fable 5 became available to me later in the workflow. Even if it had been available earlier, however, its substantially higher cost would have made it difficult to justify as the default tool for broad initial exploration. That does not mean the cheaper path is always the prudent path. For architecture decisions with long-lived consequences, the apparent savings from using a less capable model can disappear quickly if the result is avoidable coupling, unclear ownership, or expensive rework. The practical question was not whether the stronger model was useful, or whether cost should be minimized. It was where the additional capability was likely to justify its cost by reducing meaningful design risk.&lt;/p&gt;
&lt;p&gt;It was not asked to solve the architecture from scratch. That distinction matters because a powerful model used too early can become another generator of plausible structure, while a powerful model used later can become a reviewer of concrete alternatives.&lt;/p&gt;
&lt;p&gt;The model was given the original constraints, the design standards being applied, prior candidates, validation findings, known coupling defects, and specific questions about boundary ownership, interaction classification, and subsystem responsibility. It was asked to perform senior-architect diagnosis, adversarial review, component decomposition, and dependency analysis. That is a very different role from free-form generation.&lt;/p&gt;
&lt;p&gt;The value of the stronger model showed up because it had something concrete to attack. It did not merely choose which previous answer it liked. It found that the apparent leading candidate could not survive component-level allocation. A proposed split between policy-like behavior and operational state looked plausible at a higher level, but became unstable once real responsibilities had to be assigned to real components.&lt;/p&gt;
&lt;p&gt;That finding was valuable because it challenged the prior direction rather than simply reinforcing it. The earlier multi-agent exploration had favored one candidate. The later stronger-model pass found that a repaired variant of another direction was more consistent within the constrained analysis. This did not mean the earlier agents were wrong or useless. They had performed a different role. They created the candidate space, exposed disagreement, and helped identify where the real uncertainty lived. Without that earlier work, the stronger model would have had less to inspect and fewer constraints to obey.&lt;/p&gt;
&lt;p&gt;This is the central distinction. The stronger model was useful because the workflow gave it evidence, constraints, candidates, and open questions. It was acting less like an oracle and more like a senior reviewer entering a design review after the team had already done serious preparation.&lt;/p&gt;
&lt;h2 id=&#34;what-changed-after-the-problem-was-shaped&#34;&gt;What Changed After the Problem Was Shaped&lt;/h2&gt;
&lt;p&gt;Once the problem had been narrowed, the workflow could ask more useful questions. It was no longer asking AI to invent a plausible architecture. It was asking whether the remaining candidates survived concrete tests. That changed the value of the output. The useful findings were not new names, broader possibilities, or a more polished diagram. The useful findings were defects, dependencies, ripple effects, and proof obligations.&lt;/p&gt;
&lt;p&gt;One of the more practical lessons was that diagrams should not come too early. Diagrams are persuasive. Boxes and arrows create visual authority. Once an architecture is drawn cleanly, it becomes easier to believe that the design is more settled than it really is. A diagram can hide unresolved ownership problems because a box can contain almost anything. The hard question is not whether a box can be drawn. The hard question is whether the responsibilities inside that box can survive allocation.&lt;/p&gt;
&lt;p&gt;For that reason, the next pass forced the candidates into a text-first component decomposition before producing visual diagrams. Each part of the system had to justify what it owned: orchestration, business rules, access to external resources, supporting utilities, public boundaries, use cases, command surfaces, query surfaces, event surfaces, and cross-boundary communication. That textual discipline exposed defects before the diagrams could make them look real.&lt;/p&gt;
&lt;p&gt;One candidate could not allocate its seam cleanly without splitting real components. Another candidate had the right topology but incomplete ownership details. The refined candidate was stronger, but some proposed refinements still required dependency analysis. Some capabilities that looked like generic support mechanisms turned out to own enough business behavior to justify thin subsystem boundaries. Others really were supporting utilities. An explicit event-dispatch mechanism had to be named as a supporting utility instead of being left as an implicit assumption. Several supporting mechanisms still needed analysis because placing them incorrectly would have changed the ownership model.&lt;/p&gt;
&lt;p&gt;The lesson is broadly applicable. Before asking AI to draw the architecture, make it prove the architecture can be described in concrete ownership terms. If the design cannot survive a text decomposition, a diagram will not fix it. It will only make the unresolved design look finished.&lt;/p&gt;
&lt;h2 id=&#34;the-hard-part-was-the-ripple-effects&#34;&gt;The Hard Part Was the Ripple Effects&lt;/h2&gt;
&lt;p&gt;The stronger model was most useful not when it generated new names or more options, but when it found ripple effects. At one stage, the architecture had a list of proposed refinements. It would have been tempting to treat those refinements as independent toggles: accept this one, reject that one, keep the next one open for later. That would have been a mistake.&lt;/p&gt;
&lt;p&gt;Some architectural decisions are not independent. One move changes the legal and useful moves available later. A refinement that looks harmless by itself can recreate a boundary problem when combined with another decision. A proposed split can solve one ownership issue while introducing a new coupling path somewhere else.&lt;/p&gt;
&lt;p&gt;The dependency analysis found that some refinements were mandatory, some were conditional, and some had to move together. Some as originally stated created conflicts. Within the constrained set of alternatives under review, the later pass produced one preferred variant and one legal but weaker fallback. The outcome was a smaller, clearer decision space rather than a larger menu of possibilities.&lt;/p&gt;
&lt;p&gt;That is a high-value use of a stronger model in a governed workflow. The useful output was not more imagination, but the removal of bad possibilities. The model helped identify which combinations were internally inconsistent, which ones violated the design rules being applied, and which ones looked valid in isolation but created future coupling or ownership debt. That kind of analysis is difficult to get from a single early prompt because the prompt usually has not yet exposed enough structure for the model to reason against.&lt;/p&gt;
&lt;h2 id=&#34;do-not-confuse-architecture-seams-with-infrastructure&#34;&gt;Do Not Confuse Architecture Seams With Infrastructure&lt;/h2&gt;
&lt;p&gt;Another practical issue surfaced repeatedly: AI architecture proposals can jump too quickly from business boundaries to infrastructure. That is not surprising. Many architecture discussions are full of brokers, workflow engines, CQRS frameworks, event buses, distributed services, and other infrastructure-heavy patterns. Those tools can be useful. They can also distract from the actual architectural question.&lt;/p&gt;
&lt;p&gt;The principle that emerged was to avoid confusing architectural truth with infrastructure heaviness. The architecture should know whether something is a command, query, or event. It should know which part of the system owns a business decision. It should know whether message delivery is a supporting mechanism or a subsystem-level responsibility. It should know whether a component owns a use case or merely supports one. Those are architectural decisions, and they should not be postponed just because the first implementation will be simple.&lt;/p&gt;
&lt;p&gt;At the same time, the first implementation does not need to start with a full external broker, distributed services, a workflow engine, or a heavy CQRS framework. The architecture can model the event boundary explicitly while the first implementation remains simple behind that boundary. That distinction is easy to lose when AI is allowed to produce architecture freely. A model may solve a boundary problem by adding infrastructure, which can look sophisticated while avoiding the harder question of ownership. A governed workflow should force the distinction: first decide the seam, then decide how much infrastructure the current implementation actually needs.&lt;/p&gt;
&lt;h2 id=&#34;utility-or-subsystem-is-not-a-cosmetic-choice&#34;&gt;Utility or Subsystem Is Not a Cosmetic Choice&lt;/h2&gt;
&lt;p&gt;A surprisingly useful test was whether a thing owned a use case or merely supported one. That question helped classify several ambiguous parts of the architecture.&lt;/p&gt;
&lt;p&gt;In one case, an AI-related capability owned enough business policy to be treated as a thin business subsystem rather than a generic utility. Its responsibilities were not just mechanical invocation. It had to govern lifecycle, usage, provenance, and constraints around how AI-assisted work could be used. The low-level mechanics of provider calls still belonged elsewhere, but the business policy could not be treated as a generic helper.&lt;/p&gt;
&lt;p&gt;In another case, a context-resolution capability was not merely data access, but also should not become a behavior-heavy subsystem. It needed to answer governed business questions about effective context. It should not initiate workflows or become a catch-all configuration owner.&lt;/p&gt;
&lt;p&gt;A third case went the other direction. Delivery mechanics were better treated as a utility because the business decisions belonged to the subsystems that triggered them. The supporting mechanism did not own the reason something should happen. It only handled the mechanics after the owning part of the system made the decision.&lt;/p&gt;
&lt;p&gt;These classifications matter because the wrong label becomes long-term semantic debt. If a business-governance concept is demoted to a utility, ownership becomes vague. If a supporting mechanism is promoted to a subsystem, it can start attracting behavior it should not own. If a context authority becomes a catch-all configuration owner, it can quietly become a dependency magnet. AI can help with these classifications, but only if the workflow asks the right question. “Where should this thing go?” is too vague. “Does this own a business use case, or does it support use cases owned elsewhere?” is a better architectural question.&lt;/p&gt;
&lt;h2 id=&#34;review-has-to-mature-with-the-artifact&#34;&gt;Review Has to Mature With the Artifact&lt;/h2&gt;
&lt;p&gt;The workflow also reinforced that “AI review” is not one activity. Early review checked whether exploration was broad and fair. Later review checked whether reasoning was grounded in the actual constraints. Then it checked whether component allocation was coherent. For the diagram stage, the review target changed again: whether the rendered diagrams actually reflected the intended architecture and visual grammar rather than merely looking polished.&lt;/p&gt;
&lt;p&gt;A review process that asks the same question at every stage will eventually miss the point. The review criteria for exploration are not the same as the review criteria for synthesis. The review criteria for textual architecture are not the same as the review criteria for rendered diagrams. The review criteria for diagrams are not the same as the review criteria for implementation.&lt;/p&gt;
&lt;p&gt;This is one reason simple “ask another model to review it” workflows can disappoint. They treat review as a generic afterthought. The reviewing model may find something useful, but the process is not grounded enough to know what kind of review is needed. A more mature workflow changes the review question as the artifact changes. At the exploration stage, disagreement may be the desired output. At the synthesis stage, contradiction may be the target. At the decomposition stage, ownership and communication surfaces become central. At the diagram stage, the rendered artifact has to be checked, not just the source text that generated it. The review has to match the artifact’s maturity.&lt;/p&gt;
&lt;h2 id=&#34;tools-models-and-roles-are-different-things&#34;&gt;Tools, Models, and Roles Are Different Things&lt;/h2&gt;
&lt;p&gt;This workflow also made it important to separate models from the harnesses that run them. Codex and agy were not models. They were CLIs, adapters, or harnesses. Codex CLI used GPT-5.5 High for independent review and analysis. agy CLI used Gemini 3.1 Pro High for another independent perspective. Claude Code was the harness I used with Opus 4.8 as the normal Claude baseline for many architecture batches, and later with Fable 5 for bounded synthesis, pressure testing, component decomposition, and dependency analysis.&lt;/p&gt;
&lt;p&gt;The model supplies reasoning behavior. The CLI or harness supplies execution shape, file access, prompts, repeatability, capture, and review protocol. That distinction is not pedantic. The same model in a loose chat does not play the same role as a model running in a repeatable harness with captured artifacts, explicit constraints, and defined stop conditions. The model may be the same, but the workflow is not.&lt;/p&gt;
&lt;p&gt;This is why model comparison alone is a weak way to think about AI-assisted development. A model’s capability matters, but the role assigned to it matters too. Exploration, critique, synthesis, dependency analysis, diagram validation, and implementation support are different jobs. A strong model can do several of them, but it should not be allowed to blur them together without process boundaries.&lt;/p&gt;
&lt;h2 id=&#34;the-model-still-did-not-decide&#34;&gt;The Model Still Did Not Decide&lt;/h2&gt;
&lt;p&gt;The most important governance rule remained in place even after the strongest pass produced a stronger recommendation within the bounded analysis. The model did not choose the architecture. No durable architecture files were changed automatically. No diagrams were treated as approved before review. Implementation remained unauthorized. The model produced decision support, not a decision.&lt;/p&gt;
&lt;p&gt;This distinction matters because a stronger model can make a stronger argument. That makes the output more useful, but also more dangerous if the process treats persuasiveness as authority. In this workflow, the model’s output was still only decision support. It reduced ambiguity and exposed consequences. It did not own the decision.&lt;/p&gt;
&lt;p&gt;That boundary becomes more important as models improve. A more capable model can produce a more coherent story, explain tradeoffs better, and make its recommendation sound more complete. That is useful, but it is also dangerous because persuasive output can create the feeling that judgment has already happened. In this workflow, the stronger model’s job was to reduce ambiguity, expose consequences, identify proof obligations, and challenge shallow consensus. It helped make the decision better formed, but it did not remove the need for validation, rendered diagrams, cross-review, and human ownership of the final decision.&lt;/p&gt;
&lt;h2 id=&#34;a-more-mature-pattern&#34;&gt;A More Mature Pattern&lt;/h2&gt;
&lt;p&gt;The larger pattern was not that every design problem needs this many passes, this many models, or this much ceremony. Most do not. The useful lesson is that model power should be assigned a role.&lt;/p&gt;
&lt;p&gt;In this case, the workflow moved through independent breadth, preserved disagreement, collation, bounded senior-model synthesis, text-first decomposition, dependency analysis, rendered diagram validation, and human decision. That sequence was appropriate because the architecture problem had real variation, coupling, and long-term ownership consequences. For a smaller problem, the workflow could be lighter. But the roles still matter.&lt;/p&gt;
&lt;p&gt;Sometimes the right use of AI is exploration. Sometimes it is criticism. Sometimes it is synthesis. Sometimes it is checking whether a proposed refinement creates a downstream contradiction. Sometimes it is validating that a diagram or implementation actually matches a previously approved design. Treating all model calls as equivalent “answers” misses most of the value.&lt;/p&gt;
&lt;p&gt;The economic version of the same pattern is not “use cheaper models first” and not “use the strongest model everywhere.” Both can be poor defaults. The right balance depends on the consequence of the decision. A low-consequence exploratory pass may not justify the most expensive reasoning available. A high-consequence architectural decision may justify it easily if the workflow has narrowed the problem enough for that reasoning to matter.&lt;/p&gt;
&lt;p&gt;The better question is not only, “Which model is strongest?” The better question is, “What uncertainty exists at this point in the workflow, what would it cost to apply more model capability here, what long-term cost might remain if that uncertainty is not resolved, and what role should a model be allowed to play in reducing it?” That question leads to better AI use than simply reaching for the most powerful model first or trying to minimize model cost in isolation.&lt;/p&gt;
&lt;h2 id=&#34;closing-thoughts&#34;&gt;Closing Thoughts&lt;/h2&gt;
&lt;p&gt;This experience did not convince me that the strongest model should never be used first. It made me more skeptical that “use the strongest model first” is a good default for complex engineering judgment. For this kind of work, the stronger model may be most valuable after the weaker parts of the problem have already been made explicit. Earlier passes create breadth, preserve disagreement, expose uncertainty, and generate candidates. Validation turns vague disagreement into sharper questions. Only then does a stronger model have a bounded, evidence-rich decision problem to work against.&lt;/p&gt;
&lt;p&gt;That does not make model capability irrelevant. Model power matters, but the timing, role, cost, and consequence of that power matter as well. A stronger model can make a better argument, which is useful, but it also makes process discipline more important. For long-lived systems, the cost of reasoning should be considered alongside the cost of being wrong. Saving money on early model calls is not useful if it produces an architecture that carries years of avoidable complexity. Spending the most expensive reasoning on every stage is not useful either if the problem is still too vague for that reasoning to be well directed.&lt;/p&gt;
&lt;p&gt;The goal is to create a workflow where each model is used in the role where it can reduce meaningful uncertainty without taking ownership of the decision. In that sense, the stronger model helped because it came after the workflow had found the real question and because the remaining problem was important enough to justify using it.&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>AI Makes Missing Judgment More Expensive</title>
      <link>https://timbutterfield.com/post/ai-makes-missing-judgment-more-expensive/</link>
      <pubDate>Mon, 01 Jun 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/ai-makes-missing-judgment-more-expensive/</guid>
      
        <description>&lt;p&gt;AI has made it cheaper to produce work that looks complete. It has not made judgment cheaper. That difference explains much of the disappointment, cost, and confusion now appearing around AI in software development.&lt;/p&gt;
&lt;p&gt;The problem is not that AI cannot produce useful work. I use it heavily, and it can be extremely valuable when it is constrained by a strong engineering process. The problem starts when generated output is treated as evidence that the engineering work has been completed. A system can now accumulate code, tests, documentation, plans, reviews, and diagrams faster than the organization can reliably evaluate them.&lt;/p&gt;
&lt;p&gt;That is the larger pattern behind several of my recent posts on deterministic execution, browser verification, stop conditions, and review workflows using more than one model. Those posts described specific techniques. The broader reason those techniques matter is that AI has moved the bottleneck. The limiting factor is increasingly less about producing artifacts and more about knowing whether those artifacts are correct, coherent, maintainable, and worth keeping.&lt;/p&gt;
&lt;h2 id=&#34;generation-is-not-completion&#34;&gt;Generation Is Not Completion&lt;/h2&gt;
&lt;p&gt;AI is strongest when producing artifacts. It can generate code, tests, summaries, documents, diagrams, implementation plans, and review findings. In many cases, the first version appears quickly and has enough structure and polish to feel like real progress. That speed is useful, but it also makes one assumption easier to miss. Producing an artifact is not the same as owning the outcome.&lt;/p&gt;
&lt;p&gt;Software development includes artifact production, but it is not reducible to artifact production. Someone still has to decide what should exist, why it should exist, where it belongs, how it fits with the rest of the system, how it should change over time, and how its correctness will be established. AI can assist with many of those activities, but it does not automatically assume responsibility for them. The responsibility remains with the people and the process around the model.&lt;/p&gt;
&lt;p&gt;A service class can be generated quickly, but someone still has to know whether that service belongs there. A database migration can be written quickly, but someone still has to know whether it preserves data safely. A test file can be produced quickly, but someone still has to know whether the test proves the behavior that matters. The generated artifact may be useful, but it is only one part of the work.&lt;/p&gt;
&lt;h2 id=&#34;the-bottleneck-has-moved&#34;&gt;The Bottleneck Has Moved&lt;/h2&gt;
&lt;p&gt;Before AI, lack of understanding often showed up early. A person could not write the code, structure the document, or get past the blank page. The friction was visible because production itself was blocked. AI removes much of that early friction, which is one of the reasons it feels so powerful.&lt;/p&gt;
&lt;p&gt;The missing understanding does not always disappear. It often moves later in the process. The first version compiles, but does not fit the architecture. The page renders, but the state model is wrong. The tests pass, but they assert implementation details rather than behavior. The documentation reads well, but it describes what was generated instead of what was intended.&lt;/p&gt;
&lt;p&gt;This is one of the more subtle failures of AI assisted work. It can convert an early production problem into a later evaluation problem. The work appears to move faster, but the cost reappears during integration, review, maintenance, debugging, or architectural cleanup. The organization may not have reduced the work so much as delayed where the hard part becomes visible.&lt;/p&gt;
&lt;h2 id=&#34;the-evaluation-gap&#34;&gt;The Evaluation Gap&lt;/h2&gt;
&lt;p&gt;The central issue is an evaluation gap. AI can increase generation capacity almost immediately. It can produce more code, more text, more options, more tests, more reviews, and more plans. Evaluation capacity does not scale as easily because it depends on domain knowledge, architectural judgment, operational awareness, and an understanding of the desired outcome.&lt;/p&gt;
&lt;p&gt;When generation capacity grows faster than evaluation capacity, the organization does not automatically become more productive. It can become more saturated with plausible work. That is an uncomfortable failure mode because it does not look like failure at first. It looks like activity, progress, and a faster moving backlog. Only later does the bill arrive.&lt;/p&gt;
&lt;p&gt;The bill may appear as duplicate implementations, local fixes that weaken the larger design, tests that provide false confidence, documentation that drifts from intent, or review cycles that never quite converge. These are not always model failures in isolation. They are workflow failures caused by allowing production to outrun judgment.&lt;/p&gt;
&lt;h2 id=&#34;overconfidence-is-only-one-symptom&#34;&gt;Overconfidence Is Only One Symptom&lt;/h2&gt;
&lt;p&gt;This problem is related to the Dunning Kruger effect, but that framing is too narrow by itself. The issue is not only that inexperienced people overestimate their ability. The deeper issue is that AI can make incomplete understanding operational. A person can now produce work that looks more advanced than their current ability to evaluate it.&lt;/p&gt;
&lt;p&gt;That problem does not only affect beginners. A senior developer may be strong in one area and too trusting in an adjacent area. A manager may see generated output and mistake it for reduced delivery cost. An executive may see faster production and assume responsibility has been delegated. The calibration problem moves through the organization.&lt;/p&gt;
&lt;p&gt;At the individual level, the result may be overconfidence. At the team level, it may be review overload. At the architecture level, it may be inconsistency and drift. At the business level, it may become loss of predictability around time, cost, and quality. The same underlying issue appears at different scales because output is being created faster than it can be understood.&lt;/p&gt;
&lt;h2 id=&#34;architecture-matters-more-not-less&#34;&gt;Architecture Matters More, Not Less&lt;/h2&gt;
&lt;p&gt;A common mistake is assuming that AI reduces the need for architecture. I think the opposite is closer to the truth. AI makes architecture more important because it can produce implementation faster than a weak architecture can absorb it. If the boundaries are unclear, the model will fill the gaps. If responsibilities are vague, the model will make local decisions that may look reasonable while weakening the system as a whole.&lt;/p&gt;
&lt;p&gt;This is why decomposition matters. Smaller and clearer problems give AI less room to invent structure that does not belong. Explicit boundaries, stable responsibilities, and concrete acceptance criteria reduce the amount of judgment the model must infer. The goal is not to make every task trivial. The goal is to shape complex work so that AI can contribute inside a controlled context.&lt;/p&gt;
&lt;p&gt;A well structured problem lets AI accelerate useful work. A poorly structured problem asks AI to supply missing design. That is where many workflows go wrong. The model may still produce something impressive, but the impressiveness of the output can hide the fact that the system has absorbed decisions no one deliberately made.&lt;/p&gt;
&lt;h2 id=&#34;review-also-needs-structure&#34;&gt;Review Also Needs Structure&lt;/h2&gt;
&lt;p&gt;The same issue appears during review. If review is unstructured, AI can produce endless feedback. Some of that feedback may be useful, some may be speculative, and some may contradict earlier findings. A review loop can appear rigorous while gradually turning into churn.&lt;/p&gt;
&lt;p&gt;That is why structure matters around review, not only around implementation. Manifest driven execution reduces interpretation during execution. Browser checks produce runtime evidence. Stop conditions prevent review from continuing after the signal has declined. Cross model review helps expose blind spots, but only when the process has rules for convergence.&lt;/p&gt;
&lt;p&gt;These techniques are not process decoration. They are ways to keep AI speed attached to evidence. Without that structure, AI assisted development can generate more work than the team can verify. With it, the model becomes part of an engineering process rather than a substitute for one.&lt;/p&gt;
&lt;h2 id=&#34;ai-amplifies-the-system-around-it&#34;&gt;AI Amplifies The System Around It&lt;/h2&gt;
&lt;p&gt;AI is not useless, and it is not magic. It is an accelerator. Accelerators amplify the system they are attached to. If the system has clear intent, good architecture, deterministic execution, structured review, and explicit stop conditions, AI can amplify useful work. If the system lacks those things, AI can amplify ambiguity, duplication, inconsistency, and cost.&lt;/p&gt;
&lt;p&gt;This is why model capability should not be evaluated in isolation. A stronger model helps, but a stronger model does not remove the need for judgment. In some cases, it may make the absence of judgment harder to notice because the output becomes more polished. The more convincing the generated work becomes, the more important the surrounding workflow becomes.&lt;/p&gt;
&lt;p&gt;The better question is not only whether the model can generate a plausible answer. The better question is whether the organization can constrain, evaluate, integrate, and correct that answer. That is where the real engineering discipline still lives.&lt;/p&gt;
&lt;h2 id=&#34;judgment-is-still-the-constraint&#34;&gt;Judgment Is Still The Constraint&lt;/h2&gt;
&lt;p&gt;AI lowers the cost of producing a first version. It does not automatically lower the cost of knowing whether that version is right. That is the expectation gap behind many AI disappointments. People expect AI to absorb responsibility, while in practice AI often accelerates production and leaves judgment, ownership, and verification where they were before.&lt;/p&gt;
&lt;p&gt;Used well, that is still extremely valuable. AI can help explore options, generate scaffolding, accelerate implementation, improve review, and support documentation. The value appears when the work is constrained by intent, decomposition, evidence, and human judgment. Without those constraints, the same speed that makes AI useful can also make mistakes more expensive.&lt;/p&gt;
&lt;p&gt;AI does not remove the need for engineering discipline. It raises the penalty for not having it.&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>Why AI Review Needs More Than One Model</title>
      <link>https://timbutterfield.com/post/why-ai-review-needs-more-than-one-model/</link>
      <pubDate>Mon, 04 May 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/why-ai-review-needs-more-than-one-model/</guid>
      
        <description>&lt;p&gt;In earlier posts, I wrote about deterministic execution, browser verification, and stop conditions for AI driven workflows. Those addressed specific failure modes around execution and validation. Over time, another category of problems started to appear during review.&lt;/p&gt;
&lt;p&gt;Using one AI to review the output of another was not a recent change in my workflow. Before cross-ai-review became a released workflow, I was already routinely having one model review implementation plans, prompts, architecture notes, and generated artifacts produced by another model before execution continued. In many cases, I would send the same instructions through multiple systems first to see where the interpretations diverged.&lt;/p&gt;
&lt;p&gt;What changed was the degree of structure around it. The workflows moved from ad hoc experimentation into something more repeatable and governed. Different models surfaced different classes of issues, fixes introduced regressions, and ambiguity propagated downstream into later artifacts. The released cross-ai-review workflow was simply a formalization of patterns that had emerged through repeated use.&lt;/p&gt;
&lt;h2 id=&#34;different-models-miss-different-things&#34;&gt;Different Models Miss Different Things&lt;/h2&gt;
&lt;p&gt;One of the first patterns that became impossible to ignore was that different models consistently caught different categories of issues. A document or implementation could pass several review cycles with one model and still produce entirely new findings when reviewed by another.&lt;/p&gt;
&lt;p&gt;In one case, Codex iterated through multiple review passes on an artifact and the output appeared stable. Gemini then identified additional downstream integration inconsistencies and documentation drift that had not been surfaced earlier. After those fixes were applied, a later verify pass caught regressions introduced during the remediation process itself.&lt;/p&gt;
&lt;p&gt;The interesting observation was not that one model was better. The interesting observation was that they behaved more like reviewers with different blind spots. That changes the engineering question. The question stops being &amp;ldquo;Which model is best?&amp;rdquo; and becomes &amp;ldquo;What kind of workflow emerges when models review each other?&amp;rdquo;&lt;/p&gt;
&lt;h2 id=&#34;execution-was-easier-to-structure-than-review&#34;&gt;Execution Was Easier To Structure Than Review&lt;/h2&gt;
&lt;p&gt;Execution became fairly deterministic. Commands could be declared in manifests, browser checks could produce structured evidence, and stop conditions could terminate invalid execution paths mechanically instead of conversationally. Review behaved differently. Review drifted.&lt;/p&gt;
&lt;p&gt;One pass would identify architectural inconsistencies. Another would identify documentation gaps. A third would introduce a change that accidentally created a downstream mismatch elsewhere in the system. Semantically correct fixes could still produce integration inconsistencies.&lt;/p&gt;
&lt;p&gt;That was the point where prompting alone stopped being sufficient. The problem was no longer generating reviews. The problem became structuring review so that the process itself could converge instead of endlessly cycling between incomplete corrections.&lt;/p&gt;
&lt;h2 id=&#34;clarification-and-verification-are-different-problems&#34;&gt;Clarification And Verification Are Different Problems&lt;/h2&gt;
&lt;p&gt;One of the more important discoveries was realizing that clarification and verification are not the same activity. Early on, the workflows blended together. The model would review an artifact, identify concerns, and sometimes silently invent missing assumptions in order to continue. That became dangerous quickly.&lt;/p&gt;
&lt;p&gt;A vague requirement like &amp;ldquo;support offline mode&amp;rdquo; can expand into completely different architectural implementations depending on intent. Does offline mode mean cached reads only, queued writes, full synchronization, conflict resolution, temporary local sessions, or peer to peer replication? The phrase sounds simple until implementation begins.&lt;/p&gt;
&lt;p&gt;This led to separating the workflows into two different stages. The first stage focuses on clarification. The purpose is not implementation. It is ambiguity reduction. The model asks questions, presents options, explains tradeoffs, and recommends approaches while leaving final decisions to the human.&lt;/p&gt;
&lt;p&gt;Only after intent becomes sufficiently clear does verification begin. Cross model verification of unresolved ambiguity only amplifies the ambiguity.&lt;/p&gt;
&lt;h2 id=&#34;verify-passes-became-necessary&#34;&gt;Verify Passes Became Necessary&lt;/h2&gt;
&lt;p&gt;Another unexpected discovery was that review fixes themselves often introduced regressions. A reviewer could correctly identify a problem while still introducing new inconsistencies elsewhere in the system during remediation. That forced the introduction of verify passes.&lt;/p&gt;
&lt;p&gt;A verify pass is not simply another review iteration. Its purpose is narrower. It validates that prior fixes did not create downstream inconsistencies, related artifacts remain aligned, terminology did not drift, governance rules are still satisfied, and execution instructions remain valid. Without verify passes, the system could repeatedly reintroduce inconsistencies while appearing locally correct.&lt;/p&gt;
&lt;p&gt;This also reinforced another lesson. Review without convergence rules eventually degrades into churn.&lt;/p&gt;
&lt;h2 id=&#34;audit-trails-matter-more-than-chat-history&#34;&gt;Audit Trails Matter More Than Chat History&lt;/h2&gt;
&lt;p&gt;Another major shift was moving away from conversational memory as the primary source of truth. Chat history is useful while actively working, but it becomes difficult to inspect later. Important reasoning disappears into long conversational chains that are hard to replay or verify independently.&lt;/p&gt;
&lt;p&gt;The workflows evolved toward durable review artifacts instead. Structured findings and disposition tracking became more important than preserving raw conversational context. In several cases, older findings had to be revisited later after regressions appeared downstream. Having structured review artifacts made it possible to trace where the inconsistency entered the system and how the reasoning changed across iterations.&lt;/p&gt;
&lt;p&gt;The review history became an engineering artifact rather than a temporary conversation.&lt;/p&gt;
&lt;h2 id=&#34;the-workflow-became-more-important-than-the-prompt&#34;&gt;The Workflow Became More Important Than The Prompt&lt;/h2&gt;
&lt;p&gt;This was probably the largest overall shift. At the beginning, most of the effort focused on improving prompts. Over time, the prompts mattered less than the structure around them.&lt;/p&gt;
&lt;p&gt;The important pieces became role separation, structured findings, verify passes, convergence rules, deterministic validation, ambiguity reduction, auditability, and governance boundaries. The orchestration layer mattered more than any individual model because it defined how findings propagated, how regressions were verified, and how convergence was measured across iterations.&lt;/p&gt;
&lt;p&gt;That does not make the models interchangeable. Different systems still have different strengths. What changed was the realization that the workflow around the models often determines the quality and stability of the final result more than any single prompt does.&lt;/p&gt;
&lt;p&gt;There is also a practical limit to how much rigor makes sense. Running multi model verification loops for trivial edits, typo fixes, or simple mechanical changes can quickly become counterproductive. The governance overhead only becomes worthwhile once the complexity and ambiguity reach a level where review drift and regression risk become meaningful.&lt;/p&gt;
&lt;h2 id=&#34;closing-thoughts&#34;&gt;Closing Thoughts&lt;/h2&gt;
&lt;p&gt;AI assisted development is still evolving rapidly, and I do not think these workflows are finished or solved. But one thing has become increasingly clear through experimentation.&lt;/p&gt;
&lt;p&gt;The long term problem is probably not discovering the single best model. The more important problem is designing trustworthy workflows where multiple models, deterministic tooling, structured verification, and human judgment work together inside governed engineering processes.&lt;/p&gt;
&lt;p&gt;Generation is only one layer of the system. The workflow around the generation matters just as much.&lt;/p&gt;
&lt;h2 id=&#34;addendum&#34;&gt;Addendum&lt;/h2&gt;
&lt;p&gt;The released workflow discussed in this post grew out of these review patterns and experiments:&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/Tim-Butterfield/cross-ai-review&#34;&gt;https://github.com/Tim-Butterfield/cross-ai-review&lt;/a&gt;&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>Running AI Where It Doesn’t Exist</title>
      <link>https://timbutterfield.com/post/running-ai-where-it-does-not-exist/</link>
      <pubDate>Wed, 15 Apr 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/running-ai-where-it-does-not-exist/</guid>
      
        <description>&lt;h2 id=&#34;the-problem&#34;&gt;The Problem&lt;/h2&gt;
&lt;p&gt;I was working on a Windows target where Claude simply would not run. This was not a degraded experience or a partial failure. It would not start at all due to a dependency issue. At the same time, the code I was building had to run in that environment, so avoiding the platform was not an option.&lt;/p&gt;
&lt;p&gt;The obvious next step was to try to fix Claude on that system. I spent some time going down that path, but it quickly became clear that this was not going to be a quick fix. Even if I managed to get it working once, there was no guarantee it would continue working across updates or configuration changes. At that point, the problem started to look different.&lt;/p&gt;
&lt;h2 id=&#34;the-wrong-assumption&#34;&gt;The Wrong Assumption&lt;/h2&gt;
&lt;p&gt;The mistake was assuming that the AI needed to run in the same place as the code. That assumption feels natural, especially when working across operating systems, but it is not actually required.&lt;/p&gt;
&lt;p&gt;What the AI really needs is a way to execute work and a way to observe the results of that work.&lt;/p&gt;
&lt;p&gt;Once I started looking at it that way, the solution became much simpler.&lt;/p&gt;
&lt;h2 id=&#34;the-approach&#34;&gt;The Approach&lt;/h2&gt;
&lt;p&gt;Instead of trying to run Claude on the Windows environment, I kept Claude on macOS where it worked reliably. The Windows environment became an execution surface.&lt;/p&gt;
&lt;p&gt;Claude would generate commands or scripts, those would be executed on Windows, and the results would be captured and sent back.&lt;/p&gt;
&lt;p&gt;The implementation itself was intentionally simple. A shared directory was used as the communication layer. Claude would write a job into that directory, a runner process on Windows would pick it up and execute it, and the results would be written back out for Claude to read.&lt;/p&gt;
&lt;p&gt;This avoided the need for any kind of network service or complex protocol. It also made the entire system easy to inspect and debug.&lt;/p&gt;
&lt;h2 id=&#34;why-this-works&#34;&gt;Why This Works&lt;/h2&gt;
&lt;p&gt;A few design choices made this work reliably.&lt;/p&gt;
&lt;p&gt;Each job runs in its own process. If something crashes, it does not affect the runner itself. That separation turned out to be important when experimenting with different commands and scripts.&lt;/p&gt;
&lt;p&gt;All output is captured, including standard output, standard error, and exit codes. That gives Claude complete visibility into what actually happened, instead of trying to infer results from partial information.&lt;/p&gt;
&lt;p&gt;Jobs are processed in a predictable order. There is no reliance on timing or race conditions, which makes the behavior easier to reason about.&lt;/p&gt;
&lt;p&gt;There is also a simple timeout mechanism. If a job hangs, it is terminated and the system moves on. This keeps the overall workflow from getting stuck.&lt;/p&gt;
&lt;h2 id=&#34;where-safety-lives&#34;&gt;Where Safety Lives&lt;/h2&gt;
&lt;p&gt;One detail that is worth calling out is where safety is enforced.&lt;/p&gt;
&lt;p&gt;The runner itself does not attempt to restrict what can be executed. It will run whatever is placed into the queue. The responsibility for safety sits with how the AI is used.&lt;/p&gt;
&lt;p&gt;That includes scoping what it is allowed to modify, avoiding destructive operations without explicit approval, and applying the same kinds of constraints discussed in earlier posts about stop conditions.&lt;/p&gt;
&lt;p&gt;Control does not come from the execution layer. It comes from the process around it.&lt;/p&gt;
&lt;h2 id=&#34;what-this-unlocks&#34;&gt;What This Unlocks&lt;/h2&gt;
&lt;p&gt;Once this pattern is in place, it applies to more than just this specific setup.&lt;/p&gt;
&lt;p&gt;Any environment that is difficult or impossible to run AI in can still be used as an execution target. That includes restricted corporate machines, different operating systems, or remote build environments.&lt;/p&gt;
&lt;p&gt;The AI can stay in a stable environment while interacting with those targets through a controlled interface.&lt;/p&gt;
&lt;h2 id=&#34;this-is-not-new&#34;&gt;This Is Not New&lt;/h2&gt;
&lt;p&gt;There is nothing particularly new about the underlying idea. This is similar to how job queues and remote execution systems have worked for a long time.&lt;/p&gt;
&lt;p&gt;The difference is applying that same pattern to AI driven development. Instead of a developer manually issuing commands, the AI generates them, observes the results, and iterates.&lt;/p&gt;
&lt;h2 id=&#34;connection-to-earlier-posts&#34;&gt;Connection to Earlier Posts&lt;/h2&gt;
&lt;p&gt;This connects directly to the earlier posts about structuring AI interactions and enforcing limits.&lt;/p&gt;
&lt;p&gt;The execution is still controlled. The workflow is still bounded. The difference is that the execution no longer has to occur in the same environment as the AI.&lt;/p&gt;
&lt;h2 id=&#34;closing-thoughts&#34;&gt;Closing Thoughts&lt;/h2&gt;
&lt;p&gt;If you find yourself trying to get an AI tool running in an environment where it does not fit, it is worth stepping back and reconsidering the assumption.&lt;/p&gt;
&lt;p&gt;It is often easier to let the AI stay where it works well and provide a controlled way for it to interact with the environment you actually care about.&lt;/p&gt;
&lt;h2 id=&#34;addendum&#34;&gt;Addendum&lt;/h2&gt;
&lt;p&gt;After publishing this post, I generalized this approach into an open source project written in Go:&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/Tim-Butterfield/outpost&#34;&gt;https://github.com/Tim-Butterfield/outpost&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;The core functionality is implemented as a library that other applications can use. The 1.0.0 release includes builds for multiple platforms:&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/Tim-Butterfield/outpost/releases/tag/v1.0.0&#34;&gt;https://github.com/Tim-Butterfield/outpost/releases/tag/v1.0.0&lt;/a&gt;&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Why AI Review Needs Stop Conditions</title>
      <link>https://timbutterfield.com/post/why-ai-review-needs-stop-conditions/</link>
      <pubDate>Wed, 18 Feb 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/why-ai-review-needs-stop-conditions/</guid>
      
        <description>&lt;p&gt;In the previous post, I described how structured manifests and browser verification make execution deterministic.&lt;/p&gt;
&lt;p&gt;That solves execution. It does not solve review.&lt;/p&gt;
&lt;p&gt;Deterministic execution without deterministic review is incomplete.&lt;/p&gt;
&lt;h2 id=&#34;the-review-loop-problem&#34;&gt;The Review Loop Problem&lt;/h2&gt;
&lt;p&gt;Before formalizing and automating the review protocol, the process was iterative but informal. At different stages, one model generated or updated step documents and another reviewed them. Revisions were applied and resubmitted manually.&lt;/p&gt;
&lt;p&gt;Role separation existed. Governance was not yet formalized.&lt;/p&gt;
&lt;p&gt;The pattern was predictable. Early passes found real issues. Later passes produced smaller findings, speculative concerns, or contradictions.&lt;/p&gt;
&lt;p&gt;There was no convergence guarantee. The document grew. Cost grew. Signal declined.&lt;/p&gt;
&lt;h2 id=&#34;structured-findings&#34;&gt;Structured Findings&lt;/h2&gt;
&lt;p&gt;The first change was requiring structured output.&lt;/p&gt;
&lt;p&gt;Instead of prose feedback, the reviewer must return JSON with stable finding IDs, explicit severity, and a gate justification describing a concrete failure scenario.&lt;/p&gt;
&lt;p&gt;Blocking and warning findings require a falsifiable claim about what would break during execution.&lt;/p&gt;
&lt;p&gt;If the justification is wrong, it can be disproven. If correct, the fix is clear.&lt;/p&gt;
&lt;p&gt;Review shifts from opinion to evidence.&lt;/p&gt;
&lt;h2 id=&#34;severity-as-a-gate&#34;&gt;Severity as a Gate&lt;/h2&gt;
&lt;p&gt;Findings are classified into three tiers.&lt;/p&gt;
&lt;p&gt;Blocking findings must violate governance, break executability, and require a document change.&lt;/p&gt;
&lt;p&gt;Warning findings must describe a concrete failure scenario for this specific step.&lt;/p&gt;
&lt;p&gt;Suggestions never fail the gate.&lt;/p&gt;
&lt;p&gt;Without strict definitions, severity escalates. With defined criteria, the model cannot fail the gate without committing to a verifiable breakage.&lt;/p&gt;
&lt;h2 id=&#34;delta-mode&#34;&gt;Delta Mode&lt;/h2&gt;
&lt;p&gt;Fresh reviews send the full evidence bundle. Subsequent passes send only the document, a diff, and the prior review JSON.&lt;/p&gt;
&lt;p&gt;The reviewer must produce dispositions for prior findings and report only net new issues.&lt;/p&gt;
&lt;p&gt;Cost drops. Focus improves. Convergence accelerates.&lt;/p&gt;
&lt;h2 id=&#34;when-review-stops&#34;&gt;When Review Stops&lt;/h2&gt;
&lt;p&gt;Review does not end when it feels complete. It ends when objective conditions are satisfied.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Fresh review returns PASS with zero blocking and zero warning findings&lt;/li&gt;
&lt;li&gt;Executability review confirms governance compliance&lt;/li&gt;
&lt;li&gt;Suggestions have been evaluated for structural impact&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Each cycle either improves the document or confirms stability.&lt;/p&gt;
&lt;h2 id=&#34;escape-hatch&#34;&gt;Escape Hatch&lt;/h2&gt;
&lt;p&gt;Models misread evidence and occasionally contradict prior guidance.&lt;/p&gt;
&lt;p&gt;If two consecutive fresh reviews produce only factually incorrect or marginal blocking findings, and the document remains executable and compliant, the gate passes.&lt;/p&gt;
&lt;p&gt;Evidence is required. Dismissal without proof is not allowed.&lt;/p&gt;
&lt;p&gt;This prevents infinite loops while preserving rigor.&lt;/p&gt;
&lt;h2 id=&#34;mechanical-enforcement&#34;&gt;Mechanical Enforcement&lt;/h2&gt;
&lt;p&gt;The review script validates the reviewer&amp;rsquo;s output.&lt;/p&gt;
&lt;p&gt;Inconsistent structural assessments, missing justifications, or nonconverging severity counts trigger warnings.&lt;/p&gt;
&lt;p&gt;Structured review defines the rules. Mechanical checks enforce them.&lt;/p&gt;
&lt;p&gt;The final boundary is role separation.&lt;/p&gt;
&lt;h2 id=&#34;separation-of-roles&#34;&gt;Separation of Roles&lt;/h2&gt;
&lt;p&gt;In the current implementation, Claude Code performs execution and OpenAI performs review.&lt;/p&gt;
&lt;p&gt;The providers are interchangeable. The boundary is not.&lt;/p&gt;
&lt;p&gt;Both roles review, but they review for different reasons.&lt;/p&gt;
&lt;p&gt;The reviewer evaluates the document cold against explicit criteria and produces structured findings.&lt;/p&gt;
&lt;p&gt;After the reviewer driven passes converge, the executor performs an executability review. That review is not a second opinion on style. It is a compatibility check that the step can still be executed exactly as written after the reviewer driven edits.&lt;/p&gt;
&lt;p&gt;Different roles. Different failure classes. Reduced bias.&lt;/p&gt;
&lt;h2 id=&#34;the-principle&#34;&gt;The Principle&lt;/h2&gt;
&lt;p&gt;Unstructured AI review is nondeterministic. It has no convergence guarantee and no principled stop condition.&lt;/p&gt;
&lt;p&gt;Structured review with explicit criteria, severity gates, delta mode, convergence rules, and mechanical enforcement transforms review into a bounded verification process.&lt;/p&gt;
&lt;p&gt;The same principle that applies to execution applies to review.&lt;/p&gt;
&lt;p&gt;Declare the criteria.&lt;br&gt;
Declare the failure conditions.&lt;br&gt;
Evaluate mechanically.&lt;br&gt;
Decide based on evidence.&lt;/p&gt;
&lt;p&gt;Governance matters more than model selection.&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>Teaching Claude Code to Run Scripts and Check Browsers</title>
      <link>https://timbutterfield.com/post/teaching-claude-code-to-run-scripts-and-check-browsers/</link>
      <pubDate>Sun, 15 Feb 2026 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/teaching-claude-code-to-run-scripts-and-check-browsers/</guid>
      
        <description>&lt;p&gt;In earlier posts, I described how I used ChatGPT for architectural reasoning and Claude Code for implementation. That workflow continues to evolve.&lt;/p&gt;
&lt;p&gt;Recently I ran into two friction points that exposed a larger issue.&lt;/p&gt;
&lt;p&gt;The problem was not capability. It was structure.&lt;/p&gt;
&lt;h2 id=&#34;fast-is-not-deterministic&#34;&gt;Fast Is Not Deterministic&lt;/h2&gt;
&lt;p&gt;Claude Code is very good at reading files, writing code, and running shell commands. The issue appears when the task becomes procedural.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Install dependencies&lt;/li&gt;
&lt;li&gt;Run a build&lt;/li&gt;
&lt;li&gt;Execute a gate script&lt;/li&gt;
&lt;li&gt;Validate output&lt;/li&gt;
&lt;li&gt;Capture evidence&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Claude runs commands sequentially, interprets results, and decides what to do next. That works. But it is interpretive.&lt;/p&gt;
&lt;p&gt;If there are twenty commands with specific stop conditions, there are twenty opportunities for divergence.&lt;/p&gt;
&lt;p&gt;Run the same step twice and you may not get the same execution path.&lt;/p&gt;
&lt;p&gt;The second issue was visibility. Claude can start a development server, but it cannot see what renders in a browser. When UI validation is required, a human becomes the bridge.&lt;/p&gt;
&lt;p&gt;Both issues share the same root cause. The workflow lacked structure that encoded intent.&lt;/p&gt;
&lt;h2 id=&#34;manifest-driven-execution&#34;&gt;Manifest Driven Execution&lt;/h2&gt;
&lt;p&gt;The first solution was a structured step runner.&lt;/p&gt;
&lt;p&gt;Instead of asking Claude to read a document and improvise commands, I define the execution plan explicitly in a JSONL manifest. Each line declares a command and its failure conditions.&lt;/p&gt;
&lt;p&gt;Example:&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;div class=&#34;highlight&#34;&gt;&lt;div style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;
&lt;table style=&#34;border-spacing:0;padding:0;margin:0;border:0;&#34;&gt;&lt;tr&gt;&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-0-1&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-0-1&#34;&gt;1&lt;/a&gt;
&lt;/span&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-0-2&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-0-2&#34;&gt;2&lt;/a&gt;
&lt;/span&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-0-3&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-0-3&#34;&gt;3&lt;/a&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;;width:100%&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-json&#34; data-lang=&#34;json&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;type&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;id&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;check-node&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;label&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;Verify Node.js version&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;node --version&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;stop&amp;#34;&lt;/span&gt;: [{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;on&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;version_lt&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;version&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;18.0.0&amp;#34;&lt;/span&gt;}]}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;type&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;id&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;install-deps&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;label&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;Install dependencies&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;npm ci&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;stop&amp;#34;&lt;/span&gt;: [{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;on&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;exit_nonzero&amp;#34;&lt;/span&gt;}]}
&lt;/span&gt;&lt;/span&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;type&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;id&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;run-build&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;label&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;Build project&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;cmd&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;npm run build&amp;#34;&lt;/span&gt;, &lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;stop&amp;#34;&lt;/span&gt;: [{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;on&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;exit_nonzero&amp;#34;&lt;/span&gt;}]}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;Claude executes the entire step with a single command.&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;div class=&#34;highlight&#34;&gt;&lt;div style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;
&lt;table style=&#34;border-spacing:0;padding:0;margin:0;border:0;&#34;&gt;&lt;tr&gt;&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-1-1&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-1-1&#34;&gt;1&lt;/a&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;;width:100%&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-sh&#34; data-lang=&#34;sh&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;node dev/scripts/run-step.mjs tmp/STEP_020_execution_manifest.jsonl --step &lt;span style=&#34;color:#40a070&#34;&gt;020&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;Failure conditions are declared, not inferred.&lt;/p&gt;
&lt;p&gt;The runner evaluates exit codes, output patterns, and version checks mechanically. Claude does not need to interpret error text.&lt;/p&gt;
&lt;p&gt;There is also a dry run mode to validate manifests before execution.&lt;/p&gt;
&lt;p&gt;This shifts execution from interpretive to deterministic.&lt;/p&gt;
&lt;h2 id=&#34;runtime-verification-requires-a-browser&#34;&gt;Runtime Verification Requires a Browser&lt;/h2&gt;
&lt;p&gt;A terminal tool such as curl can fetch raw HTML. It cannot execute client side JavaScript.&lt;/p&gt;
&lt;p&gt;Modern applications construct the user visible DOM at runtime. Hydration, routing, and asynchronous data loading occur after JavaScript executes.&lt;/p&gt;
&lt;p&gt;If you only inspect the initial response, you are not verifying the actual system state.&lt;/p&gt;
&lt;p&gt;To close that gap, I built a headless browser verification tool using Python and Selenium. It launches Chrome, executes JavaScript, waits for declared conditions, and captures evidence.&lt;/p&gt;
&lt;p&gt;Example:&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;div class=&#34;highlight&#34;&gt;&lt;div style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;
&lt;table style=&#34;border-spacing:0;padding:0;margin:0;border:0;&#34;&gt;&lt;tr&gt;&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-2-1&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-2-1&#34;&gt;1&lt;/a&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;;width:100%&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-sh&#34; data-lang=&#34;sh&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;./dev/scripts/browser-check.sh --url http://localhost:5173/projects --out tmp/browser_check&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;Each check produces:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Screenshot&lt;/li&gt;
&lt;li&gt;Page source&lt;/li&gt;
&lt;li&gt;Console log capture&lt;/li&gt;
&lt;li&gt;JSON report&lt;/li&gt;
&lt;li&gt;Markdown report&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Wait conditions are composable.&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;div class=&#34;highlight&#34;&gt;&lt;div style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;
&lt;table style=&#34;border-spacing:0;padding:0;margin:0;border:0;&#34;&gt;&lt;tr&gt;&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code&gt;&lt;span style=&#34;white-space:pre;-webkit-user-select:none;user-select:none;margin-right:0.4em;padding:0 0.4em 0 0.4em;color:#7f7f7f&#34; id=&#34;hl-3-1&#34;&gt;&lt;a style=&#34;outline:none;text-decoration:none;color:inherit&#34; href=&#34;#hl-3-1&#34;&gt;1&lt;/a&gt;
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td style=&#34;vertical-align:top;padding:0;margin:0;border:0;;width:100%&#34;&gt;
&lt;pre tabindex=&#34;0&#34; style=&#34;background-color:#f0f0f0;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-text-size-adjust:none;&#34;&gt;&lt;code class=&#34;language-json&#34; data-lang=&#34;json&#34;&gt;&lt;span style=&#34;display:flex;&#34;&gt;&lt;span&gt;{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;any&amp;#34;&lt;/span&gt;: [{&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;visible&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;#project-list&amp;#34;&lt;/span&gt;}, {&lt;span style=&#34;color:#062873;font-weight:bold&#34;&gt;&amp;#34;visible&amp;#34;&lt;/span&gt;: &lt;span style=&#34;color:#4070a0&#34;&gt;&amp;#34;.error-banner&amp;#34;&lt;/span&gt;}]}&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;/div&gt;
&lt;p&gt;The result is structured runtime evidence that Claude can evaluate directly.&lt;/p&gt;
&lt;p&gt;Execution becomes:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Start the server&lt;/li&gt;
&lt;li&gt;Run browser checks&lt;/li&gt;
&lt;li&gt;Read structured results&lt;/li&gt;
&lt;li&gt;Continue based on evidence&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;No manual bridge required.&lt;/p&gt;
&lt;h2 id=&#34;the-pattern&#34;&gt;The Pattern&lt;/h2&gt;
&lt;p&gt;Both tools implement the same principle.&lt;/p&gt;
&lt;p&gt;Move decisions out of real time AI interpretation and into declared structure.&lt;/p&gt;
&lt;p&gt;Instead of asking the model to infer success, define what success means.&lt;/p&gt;
&lt;p&gt;Instead of describing what a browser rendered, declare the assertions and capture the output.&lt;/p&gt;
&lt;p&gt;The boundary often matters more than the prompt.&lt;/p&gt;
&lt;h2 id=&#34;what-comes-next&#34;&gt;What Comes Next&lt;/h2&gt;
&lt;p&gt;Deterministic execution is necessary. It is not sufficient.&lt;/p&gt;
&lt;p&gt;The next layer is deterministic review.&lt;/p&gt;
&lt;p&gt;Execution can be declared. Verification can be structured. Review must be governed.&lt;/p&gt;
&lt;p&gt;That is the subject of the next post.&lt;/p&gt;</description>
      
    </item>
    
    <item>
      <title>A Better Way to Use AI in Software Development</title>
      <link>https://timbutterfield.com/post/improve-software-development-with-ai/</link>
      <pubDate>Sun, 30 Mar 2025 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/improve-software-development-with-ai/</guid>
      
        <description>&lt;p&gt;There’s a lot of hype right now around using AI in software development. And to be fair, the hype isn’t entirely misplaced. AI &lt;em&gt;can&lt;/em&gt; write code. It can summarize, generate, and even refactor. But there’s a major problem with the way most people use it. The problem is guessing.&lt;/p&gt;
&lt;h3 id=&#34;when-ai-has-to-guess&#34;&gt;When AI Has to Guess&lt;/h3&gt;
&lt;p&gt;If your prompt is not sufficiently clear, the AI has no choice but to guess what you meant. And this guessing introduces subtle, and sometimes major, errors. It might guess wrong about your naming conventions, your error-handling preferences, your architectural style, or your end goals. Even if you think the prompt is clear, the AI may read it differently than you do.&lt;/p&gt;
&lt;p&gt;This is where most of the breakdown in AI-assisted development happens. The AI’s assumptions diverge from your intent and it confidently generates code that doesn&amp;rsquo;t do what you wanted. And unlike a junior developer who might ask for clarification, the AI just barrels forward, filling in gaps however it sees fit.&lt;/p&gt;
&lt;p&gt;There’s a better way.&lt;/p&gt;
&lt;h3 id=&#34;let-the-ai-ask-not-guess&#34;&gt;Let the AI Ask, Not Guess&lt;/h3&gt;
&lt;p&gt;Instead of relying on the AI to fill in the blanks, flip the script. Ask it to analyze your prompt and &lt;em&gt;ask you&lt;/em&gt; about any gaps or assumptions it would otherwise make. This changes the nature of the interaction. It becomes a back-and-forth, like pair programming with someone who’s not afraid to admit when something isn’t clear.&lt;/p&gt;
&lt;p&gt;For example, tell the AI:&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;Analyze the prompt delimited by the triple backticks. If there is anything that is not clear and executable, ask questions about any gaps where you may have to guess. For each question, provide three to five choices along with pros and cons for each choice. Then, give a recommendation and explain your reasoning.&lt;/p&gt;
&lt;/blockquote&gt;
&lt;p&gt;That’s the starting point. You give the prompt and the AI gives you a list of questions about things it’s not sure about.&lt;/p&gt;
&lt;h3 id=&#34;making-choices-and-adding-clarity&#34;&gt;Making Choices and Adding Clarity&lt;/h3&gt;
&lt;p&gt;Once you get the list of questions, you walk through them. Make your choice. But you’re not limited to the choices the AI provides. You can write your own answer, clarify things further, or reframe the question entirely. You’re still the one steering the conversation.&lt;/p&gt;
&lt;p&gt;The AI’s recommendations can help guide you, but you’re not handing over the wheel. You’re treating the AI like a helpful assistant who brings up options and tradeoffs, but who still looks to you for the final decision.&lt;/p&gt;
&lt;h3 id=&#34;iterate-until-its-clear&#34;&gt;Iterate Until It’s Clear&lt;/h3&gt;
&lt;p&gt;This process is not one-and-done. One round of clarification is rarely enough. After you respond to the first round of questions, the AI should reanalyze your updated prompt. If anything is still unclear, it should ask again. New questions will surface as others get resolved.&lt;/p&gt;
&lt;p&gt;You keep going until the AI says, “There is nothing unclear or ambiguous in your prompt.” At that point, you’re ready to move forward. You now have a prompt that is clear, unambiguous, and executable, one that a wide range of AI models can interpret in the same way you intended.&lt;/p&gt;
&lt;h3 id=&#34;clarity-over-guessing&#34;&gt;Clarity Over Guessing&lt;/h3&gt;
&lt;p&gt;This iterative method avoids the most common source of error in AI development: misinterpretation. Instead of letting the AI jump to conclusions, you walk it through the reasoning. You help it see what you’re trying to build. You clarify, step by step, until there’s no room left for guessing.&lt;/p&gt;
&lt;p&gt;And the AI itself becomes the tool to help you reach that clarity.&lt;/p&gt;
&lt;h3 id=&#34;try-multiple-models&#34;&gt;Try Multiple Models&lt;/h3&gt;
&lt;p&gt;One additional tip: don’t rely on just one AI. Different models behave differently. They’ve been trained on different datasets and reflect different patterns of thought. One model might ask excellent questions about architecture. Another might catch nuances in naming conventions. Some might miss key gaps that others catch.&lt;/p&gt;
&lt;p&gt;Just like getting advice from different consultants, trying a few different models can reveal blind spots in your prompt and help you refine it further. Even if you prefer one model for the final implementation, it doesn’t hurt to bounce ideas off another before you get there.&lt;/p&gt;
&lt;h3 id=&#34;final-thoughts&#34;&gt;Final Thoughts&lt;/h3&gt;
&lt;p&gt;If you want to get the most out of AI in software development, stop treating it like a mind reader. It’s not. And it doesn’t need to be. What it needs is a clear, detailed, and executable prompt. You can get there through an iterative process of questions, choices, clarification, and feedback.&lt;/p&gt;
&lt;p&gt;Don’t let the AI guess. Teach it to ask.&lt;/p&gt;
&lt;p&gt;Then answer.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Developing with AI: How ChatGPT and Claude Accelerated My Latest Project</title>
      <link>https://timbutterfield.com/post/developing-with-ai/</link>
      <pubDate>Sun, 23 Mar 2025 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/developing-with-ai/</guid>
      
        <description>&lt;p&gt;In a recent software project, I took a new approach by using AI tools as collaborators in the development process. I didn’t use them for everything—but I did use them extensively in the areas where they shine: architecture reasoning, rapid prototyping, code refinement, and automated testing.&lt;/p&gt;
&lt;p&gt;Rather than working full-time through the process, I engaged with ChatGPT in part-time conversations to shape the initial system architecture. Once the structure was clear, I used Claude Code to generate, refine, and test the implementation.  It’s the first time I’ve worked this closely with two different LLMs across a single workflow, and the results were impressive.  - &lt;em&gt;The mentinon of Claude in this article is specifically about Claude Code and not Claude in general.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id=&#34;architectural-reasoning-with-chatgpt&#34;&gt;Architectural Reasoning with ChatGPT&lt;/h2&gt;
&lt;p&gt;ChatGPT served as a sounding board to shape the architecture of the project. The ability to pause and return to conversations made it ideal for reflecting on design decisions without committing immediately to code. I found this back-and-forth especially useful for exploring trade-offs, naming patterns, and layering strategies.&lt;/p&gt;
&lt;p&gt;The fixed monthly cost also made it a natural choice for exploratory thinking. I could spend hours breaking down a design without worrying about token consumption or runtime constraints.&lt;/p&gt;
&lt;h2 id=&#34;implementation-acceleration-with-claude&#34;&gt;Implementation Acceleration with Claude&lt;/h2&gt;
&lt;p&gt;Once the architecture was in place, I brought Claude into the workflow. Claude’s strength is in context-rich implementation. It can take a directory structure and start to fill in files based on that plan. More importantly, it can catch compilation issues, run tests, and suggest fixes automatically once given permission to proceed.&lt;/p&gt;
&lt;p&gt;The speed boost here was substantial. What would typically take weeks of solo development was compressed into a few days, thanks to Claude’s ability to iterate quickly and automate repetitive tasks.&lt;/p&gt;
&lt;h2 id=&#34;prompt-engineering-as-a-skill&#34;&gt;Prompt Engineering as a Skill&lt;/h2&gt;
&lt;p&gt;There’s a lot of talk about prompt engineering, and for good reason: it matters. I had already developed a good sense of how to direct LLMs effectively, but I still found value in formal resources like the course from DeepLearning.ai.&lt;/p&gt;
&lt;p&gt;Prompt engineering, like recipe writing, requires knowing not just what’s possible—but when and why. You may know what an API call is, or what a database does, but that doesn’t tell you &lt;em&gt;when&lt;/em&gt; to use it or &lt;em&gt;how&lt;/em&gt; it fits into a broader architecture. That’s where software design experience makes a real difference. The better you understand what you want to build, the better instructions you can give the AI to help build it.&lt;/p&gt;
&lt;h2 id=&#34;choosing-between-chatgpt-and-claude&#34;&gt;Choosing Between ChatGPT and Claude&lt;/h2&gt;
&lt;p&gt;Each model has its place in the workflow. ChatGPT is ideal for upfront reasoning and documentation-heavy planning because it has a fixed cost and works well across asynchronous sessions. Claude, on the other hand, excels at grounded implementation. It can interact with file structures, analyze diffs, and even reason about terminal output when things break.&lt;/p&gt;
&lt;p&gt;Using them together let me take advantage of the strengths of both without being locked into the limitations of either.&lt;/p&gt;
&lt;h2 id=&#34;testing-and-quality-with-ai&#34;&gt;Testing and Quality with AI&lt;/h2&gt;
&lt;p&gt;Claude’s integration of linters, style checkers, and test generation made it easier to maintain a high standard of code quality throughout the project. It could run a test suite with a single command and use the results to suggest fixes automatically.&lt;/p&gt;
&lt;p&gt;This helped not just with correctness, but with consistency across the codebase. Claude could even generate scripts to refactor groups of files when a widespread issue was discovered.&lt;/p&gt;
&lt;h2 id=&#34;context-management-and-versioning&#34;&gt;Context Management and Versioning&lt;/h2&gt;
&lt;p&gt;One challenge with LLMs is keeping context between sessions. Claude addresses this by allowing you to export session context, which you can re-import the next time you pick up the project. Combined with Git for code versioning, this created a feedback loop: Claude could see what changed, compare it to prior outputs, and suggest fixes based on the diff.&lt;/p&gt;
&lt;p&gt;That context continuity kept progress moving forward, even across multiple days and sessions.&lt;/p&gt;
&lt;h2 id=&#34;productivity-reflections&#34;&gt;Productivity Reflections&lt;/h2&gt;
&lt;p&gt;In raw output, Claude delivered a multi-week implementation in a matter of days. It wasn’t just faster—it also offloaded the mental load of compilation, linting, and basic test writing. I could stay focused on higher-order decisions while the AI handled the routine.&lt;/p&gt;
&lt;p&gt;The result: more time spent on thinking, less time spent on syntax.&lt;/p&gt;
&lt;h2 id=&#34;the-future-ai-as-a-pair-programming-partner&#34;&gt;The Future: AI as a Pair Programming Partner&lt;/h2&gt;
&lt;p&gt;We often talk about pair programming as a best practice—but not everyone enjoys or benefits from the social dynamic. For introverts like myself, AI fills a unique niche: a tireless partner who’s always ready to suggest, refactor, or debug—but only when asked.&lt;/p&gt;
&lt;p&gt;That said, AI isn’t magic. The quality of output still depends on the quality of input. If your prompts are vague, the results will be too. Experience still matters, and the more you know about the design and development process, the more effective your collaboration with AI will be.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;This workflow isn’t one-size-fits-all, but it worked well for this project. In a future post, I’ll share more about the specific SaaS application that came out of this process. For now, I hope this glimpse into a human+AI development loop helps others explore new ways to build.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Chatting with LLMs: Exploring Local AI with Ollama</title>
      <link>https://timbutterfield.com/post/chatting-with-llms/</link>
      <pubDate>Sun, 02 Mar 2025 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/chatting-with-llms/</guid>
      
        <description>&lt;p&gt;AI-powered large language models (LLMs) have become a big deal. They can generate text, assist with coding, and handle all sorts of conversational tasks. With local AI models becoming more accessible, developers no longer have to rely on cloud-based services to experiment with LLMs. One of the preferred ways to run these models locally is with &lt;a href=&#34;https://ollama.com&#34;&gt;Ollama&lt;/a&gt;, a tool designed to simplify working with AI on your own machine.&lt;/p&gt;
&lt;h2 id=&#34;running-llms-locally-with-ollama&#34;&gt;Running LLMs Locally with Ollama&lt;/h2&gt;
&lt;p&gt;Ollama makes it easy to download and run different LLMs without needing cloud access. This is great for privacy, performance, and flexibility. With a capable machine, you can run AI models just as easily as you would any local application.&lt;/p&gt;
&lt;p&gt;Right now, my local Ollama setup includes several well-known models:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;deepseek-r1:8b&lt;/li&gt;
&lt;li&gt;deepseek-r1:7b&lt;/li&gt;
&lt;li&gt;llama3.1:8b&lt;/li&gt;
&lt;li&gt;qwen2.5-coder:7b&lt;/li&gt;
&lt;li&gt;qwen2.5-coder:14b&lt;/li&gt;
&lt;li&gt;codegemma:latest&lt;/li&gt;
&lt;li&gt;llama3.2:latest&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;A search on the Ollama site allows for pulling many others.  Available models are constantly being added and/or updated.&lt;/p&gt;
&lt;h2 id=&#34;some-of-the-more-popular-models&#34;&gt;Some of the More Popular Models&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;DeepSeek R1 (7B and 8B) is a general-purpose LLM that balances speed and performance.&lt;/li&gt;
&lt;li&gt;Llama 3.1 (8B) is Meta’s open-source model, optimized for chat.&lt;/li&gt;
&lt;li&gt;Qwen 2.5 Coder (7B and 14B) is built for code generation and AI-assisted development.&lt;/li&gt;
&lt;li&gt;CodeGemma is another code-focused model with solid capabilities.&lt;/li&gt;
&lt;li&gt;Llama 3.2 (latest) is a newer version of the Llama model, designed for efficiency.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;deepseek-r1-7b-vs-8b&#34;&gt;DeepSeek R1: 7B vs. 8B&lt;/h2&gt;
&lt;p&gt;The DeepSeek R1 models I have loaded are in two variations: 7B and 8B. The main difference is that the 8B model has an extra billion parameters, making it slightly better at complex reasoning. The tradeoff is increased memory usage and a different base model family.&lt;/p&gt;
&lt;p&gt;The 7B model is built on the Transformer-XL architecture, optimized for efficiency with fewer parameters while maintaining strong language understanding. The 8B model is based on the GPT-style dense Transformer architecture, incorporating additional parameters that improve reasoning and generation capabilities.&lt;/p&gt;
&lt;p&gt;For most tasks, the 7B model is fast and efficient, making it a good choice when resources are limited. If extra processing power is available, the 8B model can provide more refined responses with improved context understanding.&lt;/p&gt;
&lt;h2 id=&#34;experimenting-with-llms-using-ollama-chat-tauri&#34;&gt;Experimenting with LLMs Using Ollama Chat Tauri&lt;/h2&gt;
&lt;p&gt;To better understand how different LLMs respond to the same prompts, I created a simple cross-platform desktop app called Ollama Chat Tauri.&lt;/p&gt;
&lt;p&gt;This app lets me generate responses from different models so I can compare their responses to identical inputs. The goal is to see how each LLM handles the same request and identify where certain models excel.&lt;/p&gt;
&lt;h3 id=&#34;tech-stack&#34;&gt;Tech Stack&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;Rust and Tauri for the backend and app framework.&lt;/li&gt;
&lt;li&gt;React for the frontend UI.&lt;/li&gt;
&lt;li&gt;SQLite for local storage of interactions.&lt;/li&gt;
&lt;li&gt;Ollama API to handle communication with local AI models.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;This setup makes it easy to experiment with different LLMs, all from a single interface.&lt;/p&gt;
&lt;p&gt;The project is open-source, and the code is available here:
&lt;a href=&#34;https://github.com/Tim-Butterfield/ollama-chat-tauri&#34;&gt;Ollama Chat Tauri&lt;/a&gt;&lt;/p&gt;
&lt;h2 id=&#34;where-this-is-going&#34;&gt;Where This Is Going&lt;/h2&gt;
&lt;p&gt;I plan to continue experimenting with AI and LLMs in future projects. Comparing AI-generated code, improving structured problem-solving, and optimizing local AI workflows are all areas I’ll be exploring.&lt;/p&gt;
&lt;p&gt;Local AI is a big deal. Running models on your own hardware provides better privacy, lower latency, and more control over the AI’s behavior. With tools like Ollama and frameworks like Tauri, it is easier than ever to build AI-powered applications that run entirely offline.&lt;/p&gt;
&lt;p&gt;If you&amp;rsquo;re curious about LLMs and want to experiment with them locally, Ollama is a great place to start. And if you want to see how different models compare, check out Ollama Chat Tauri.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Hello Again, Hugo</title>
      <link>https://timbutterfield.com/post/hello-again-hugo/</link>
      <pubDate>Sat, 01 Mar 2025 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/hello-again-hugo/</guid>
      
        <description>&lt;p&gt;During the Covid years, I let my blog lapse and eventually deactivated the site. At the time, I wasn’t sure whether I would bring it back, but I kept a backup of the WordPress SQL database just in case. That decision proved useful when I recently decided to restore the blog.&lt;/p&gt;
&lt;h2 id=&#34;restoring-the-old-content&#34;&gt;Restoring the Old Content&lt;/h2&gt;
&lt;p&gt;With the original WordPress database backup in hand, the next step was getting access to the posts. Rather than setting up a full WordPress environment, I used a Docker-hosted MySQL database to load the backup. Once restored, I extracted the pages and posts and converted them into Markdown files for use with &lt;a href=&#34;https://gohugo.io/&#34;&gt;Hugo&lt;/a&gt;.  I had played with Hugo long ago, but had not used it for my blog until now.&lt;/p&gt;
&lt;p&gt;Hugo is a static site generator that takes Markdown content and builds a fast, static website. Unlike WordPress, which dynamically generates pages from a database, Hugo pre-renders everything into static files, making it lightweight, secure, and easy to deploy.&lt;/p&gt;
&lt;h2 id=&#34;a-new-look-with-hugo&#34;&gt;A New Look with Hugo&lt;/h2&gt;
&lt;p&gt;For the site’s design, I selected the &lt;a href=&#34;https://github.com/xianmin/hugo-theme-jane&#34;&gt;Jane theme&lt;/a&gt; as a starting point. It provides a clean and simple layout that works well for technical content.&lt;/p&gt;
&lt;h2 id=&#34;deployment-with-netlify-and-squarespace&#34;&gt;Deployment with Netlify and SquareSpace&lt;/h2&gt;
&lt;p&gt;To make the new blog live, I deployed it to &lt;a href=&#34;https://www.netlify.com/&#34;&gt;Netlify&lt;/a&gt;, which offers seamless hosting for static sites. Netlify provides a smooth Git-based workflow, so updates are as simple as pushing changes to the repository.&lt;/p&gt;
&lt;p&gt;After Google retired its domain registration service, I transferred my domain to &lt;a href=&#34;https://www.squarespace.com/domains&#34;&gt;SquareSpace&lt;/a&gt;. The transition was straightforward, and SquareSpace’s domain management tools integrate well with Netlify’s DNS settings, making deployment relatively hassle-free. My domain uses email forwarding, with SquareSpace managing the mail servers. As a result, I had to manually configure my DNS records in SquareSpace instead of switching to Netlify’s name servers.&lt;/p&gt;
&lt;p&gt;While my posting history has never been particularly prolific, this new Hugo-based blog provides a fresh starting point. The simplicity of Hugo makes it easy to maintain, so hopefully, that translates into more frequent updates moving forward.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Python/Selenium: Waiting for combinations</title>
      <link>https://timbutterfield.com/post/python-selenium-waiting-for-combinations/</link>
      <pubDate>Fri, 03 Aug 2018 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/python-selenium-waiting-for-combinations/</guid>
      
        <description>&lt;p&gt;Selenium has a feature where you can wait for a condition. Documentation for that is &lt;a href=&#34;https://selenium-python.readthedocs.io/waits.html&#34;&gt;here&lt;/a&gt;. The expected conditions of an explicit wait offer a limited set to check. In some cases, it is beneficial to wait for a combination of conditions. For example, after submitting a form, you might get an error or you might get a success message. It is better to not have to wait for a timeout for one element if you instead receive the other.
Here are a couple of expected condition classes that allow this.&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import StaleElementReferenceException

class wait_for_any(object):
    def __init__(self, methods):
        self.methods = methods

    def __call__(self, driver):
        try:
            for method in self.methods:
                if method(driver):
                    return True
            return False
        except StaleElementReferenceException:
            return False


class wait_for_all(object):
    def __init__(self, methods):
        self.methods = methods

    def __call__(self, driver):
        try:
            for method in self.methods:
                if not method(driver):
                    return False
            return True
        except StaleElementReferenceException:
            return False&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;Here is an example of waiting until the first of two different elements is visible. (Example lines split for clarity.)&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
methods = []
methods.append(EC.visibility_of_element_located(BY.ID, &amp;#34;idSuccess&amp;#34;))
methods.append(EC.visibility_of_element_located(BY.ID, &amp;#34;idError&amp;#34;))
method = wait_for_any(methods)
WebDriverWait(driver, 5).until(method)&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;Because &lt;code&gt;wait_for_all&lt;/code&gt; and &lt;code&gt;wait_for_any&lt;/code&gt; are themselves wait conditions, you can combine and nest them. You can have a condition combination like this: &lt;code&gt;((A and B and C) or (X and Y and Z))&lt;/code&gt; The outer &lt;code&gt;wait_for_any&lt;/code&gt; condition checks two inner &lt;code&gt;wait_for_all&lt;/code&gt; conditions, each with their own combination of conditions.
Here is an example of using a combination to wait for an element to appear within a frame inside of the main document. (Example lines split for clarity.)&lt;/p&gt;
&lt;div class=&#34;highlight-container&#34;&gt;

  &lt;button class=&#34;copy-code-btn outline&#34;&gt;Copy&lt;/button&gt;

  
  &lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;
methods = []
methods.append(EC.frame_to_be_available_and_switch_to_it(None))
methods.append(EC.frame_to_be_available_and_switch_to_it(BY.ID, &amp;#34;newFrame&amp;#34;))
methods.append(EC.visibility_of_element_located(BY.ID, &amp;#34;childElement&amp;#34;))
method = wait_for_all(methods)
WebDriverWait(driver, 5).until(method)&lt;/code&gt;&lt;/pre&gt;
&lt;/div&gt;
&lt;p&gt;In this example, the &lt;code&gt;None&lt;/code&gt; argument to the first wait switches to the &lt;code&gt;defaultContent&lt;/code&gt; frame. Once the &lt;code&gt;newFrame&lt;/code&gt; exists, switch to it. Once within the &lt;code&gt;newFrame&lt;/code&gt;, check the visibility of the child element. If the child element is not yet visible, start the next cycle by switching to the &lt;code&gt;defaultContent&lt;/code&gt; frame again.
Element Locator: I only used the &lt;code&gt;By.ID&lt;/code&gt; element locator as an example. Since each expected condition is created separately, each can use a locator value appropriate for that element. One can use &lt;code&gt;By.ID&lt;/code&gt;. Another may use &lt;code&gt;By.XPATH&lt;/code&gt;, &lt;code&gt;By.NAME&lt;/code&gt;, &lt;code&gt;By.CLASS_NAME&lt;/code&gt;, &lt;code&gt;By.TAG_NAME&lt;/code&gt;, &lt;code&gt;By.CSS_SELECTOR&lt;/code&gt;, etc.
Frame Switch Caveat: A &lt;code&gt;TimeoutException&lt;/code&gt; may occur after any of the condition checks. If this happens, you do not know which frame is current. Thus, if that happens, it would be safest to reset the frame before continuing.
Element Caveat: The combined conditions can reference many different target elements. Because of this, it is not safe to rely on the element returned from &lt;code&gt;WebDriverWait&lt;/code&gt;. You may not know which target element it points to.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Vivobarefoot Evo II review</title>
      <link>https://timbutterfield.com/post/vivobarefoot-evo-ii-review/</link>
      <pubDate>Wed, 02 Mar 2011 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/vivobarefoot-evo-ii-review/</guid>
      
        <description>&lt;p&gt;I won a pair of &lt;a href=&#34;http://www.vivobarefoot.com/us/mens/evo-ii-mens-20.html/&#34;&gt;Terra Plana&amp;rsquo;s Vivobarefoot Evo II&lt;/a&gt; in &lt;a href=&#34;http://www.runningandrambling.com/2010/11/vivobarefoot-evo-ii-review-and-giveaway.html&#34;&gt;Running &amp;amp; Rambling&amp;rsquo;s EVO II review and giveaway&lt;/a&gt;.  After coordinating my name and address with the Terra Plana representative, my Evo II were shipped.  I received them some weeks ago but, as I had stopped running due to an upper respiratory infection, was not able to test them right away.  I recently started my workouts again and, after a mix of those on an indoor track and on sidewalks, I have now formed an opinion of the Evo II I will endeavor to impart.&lt;/p&gt;
&lt;p&gt;Like the current, updated Evo, the Evo II is a well constructed shoe.  The II variant adds some additional liner material inside of the TPU cage to make it better suited to colder weather.  I was able to wear it with and without the insole and with and without socks.  Without the insole, the liner material was comfortable on my bare feet.&lt;/p&gt;
&lt;p&gt;I had first tried the original Evo about a year ago.  While the construction was excellent, they caused bloody toe blisters on my big and second toes.  Even the use of tape and extra sock layers was an insufficient deterrent.  I have not tried the updated Evo.  With the Evo II, that issue has been corrected  for me.  However, there is another issue that did occur.  It is the achilles rubbing that can lead to blisters.  Some people had experienced this issue on the original Evo also.  After some experimentation, I was able to determine a set of conditions that led to this issue in my usage.&lt;/p&gt;
&lt;p&gt;In the majority of normal running usage, the Evo II worked well for me with no issues that I noticed.  But, unfortunately for me, I do not yet have the aerobic capacity for my workouts to consist of 100% running.  There is still some walking involved, especially during warm ups and cool downs.  That is where the achilles rubbing can cause problems for me.  Even then, it can be controlled if I maintain an awareness of and control how I am walking.&lt;/p&gt;
&lt;p&gt;I put a strip of Hypafix tape along my achilles to provide a surface to mark on.  In the left image, I placed a mark at the top of the achilles collar.  In the center image, I plantar flexed a moderate amount and put a mark where the bend above the heel begins closer to where the achilles attaches.  In the right image, the tape shows the approximately half an inch difference between the bend location and the top of the achilles collar.  The left image was also taken with the insole in.  If the insole was removed, the difference would be greater by that amount.&lt;/p&gt;
&lt;p&gt;When there is some plantar flexion, the achilles bend just above my heel is well below the top of the achilles collar on the Evo II.  Normal running with a landing under my COG does not bend my achilles against the achilles collar of the shoe.  Fortunately, that is how I usually land when running.  Landing when over-striding with some plantar flexion could cause the achilles to bend against the achilles collar leading to the rubbing and the blisters.  This is where it bit me.  When I walk, I often over-stride with my foot landing slightly in front of my COG.  Just before landing or on lift-off, I have some plantar flexion.  When this happens, my achilles bends above the heel and levers my achilles against the achilles collar of the shoe.  This levering action also lifts the heel slightly within the shoe.  The landing of the foot then presses the heel back into the shoe.  This action causes rubbing in both the up and down directions.  A mile and half of this is sufficient to cause blisters on my achilles.  The use of tape may help with this, but it would not eliminate the pressure of the levering action, which may be sufficient to loosen and move the tape as the original Evo did with the tape on my toes. Besides, we should not have to protect ourselves from our footwear.  They are supposed to protect us.&lt;/p&gt;
&lt;p&gt;This does not have to be all bad, though.  It could be used as a training aid to encourage landing more under COG even when walking.  If I become aware of it and am able to do this, the rubbing and blisters would be eliminated.  Unfortunately, this means a slower walking pace for me if I walk without the over-striding I normally do.  Of course, if I am in a hurry, it could be worse.  The more over-striding that is done, the worse the achilles rubbing will be.  This is a trade off I have yet to decide if I can live with.  Some lowering of the achilles collar might make this a non-issue for me.&lt;/p&gt;
&lt;p&gt;Given this caveat and a possible ability to work around this issue, I find the Evo II to be an otherwise excellent shoe.  Compared with some of the other minimalist running shoes coming onto the market, the price is still high, though there are occasional coupon codes to reduce that price if you look for them.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>R&amp;R Reviews the Neo</title>
      <link>https://timbutterfield.com/post/rr-reviews-the-neo/</link>
      <pubDate>Wed, 29 Dec 2010 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/rr-reviews-the-neo/</guid>
      
        <description>&lt;p&gt;Donald at Running and Rambling has &lt;a href=&#34;http://www.runningandrambling.com/2010/12/vivobarefoot-neo-running-shoe-review.html&#34;&gt;reviewed&lt;/a&gt; the Terra Plana/VivoBarefoot Neo.  While similar to the EVO, it has a more traditional mesh fabric upper, though with the tradeoffs of slightly greater weight and a lower price. I like that last part. It does make them a more attractive buy than the EVO and EVO II, especially if the BARE30 (30%) or BARERUNUNI (25%) coupon codes work with them.  (I haven&amp;rsquo;t tried.)  Of the four colors available, though, only the green and white is in my size. Hmmm.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>R&amp;R Reviews the EVO II</title>
      <link>https://timbutterfield.com/post/rr-reviews-the-evo-ii/</link>
      <pubDate>Tue, 30 Nov 2010 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/rr-reviews-the-evo-ii/</guid>
      
        <description>&lt;p&gt;Donald at Running and Rambling has &lt;a href=&#34;http://www.runningandrambling.com/2010/11/vivobarefoot-evo-ii-review-and-giveaway.html&#34;&gt;reviewed&lt;/a&gt; the Terra Plana/VivoBarefoot EVO II.  Instead of an update to the EVO, this II model is a new, additional variant designed more for cold weather use.  Read Donald&amp;rsquo;s review for more details and a 20% off discount code.
I like the idea of the EVO and EVO II, though as much as I would like to try it, I am reluctant.  If they work, they would be worth buying with a discount code.  But, at $160 retail, an unsuccessful test can be quite expensive.  After the original EVO created and then tore off blisters on my toes, I am quite gun shy about spending that kind of money again just to see if the problems I experienced have been fixed.  I hope they have, but will let others pay to test them first.  If the consensus is good, I might try them again.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>Back to basics</title>
      <link>https://timbutterfield.com/post/back-to-basics/</link>
      <pubDate>Thu, 04 Mar 2010 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/back-to-basics/</guid>
      
        <description>&lt;p&gt;It has been a quite while since I completed the Couch to 5K running plan. This post will provide some pre-C25K history, where I started, and some post-C25K history, what I have been doing since.
I have never really been a runner. As a teenager, I walked a lot. I would think nothing of walking the thirteen miles to the county fairground to help out with the harness racing horses. If I was out on a job site with my Dad doing construction and wanted to go home early, walking sixteen miles home was not a strain. At 135 pounds, I was thin for my 5&#39;10&amp;quot; height. Though I did run just for fun sometimes, I had never raced, not even in school. That was twenty-five years ago.
Then, I grew up, got a regular job, got married, and stopped walking. Time was more precious. Instead of walking from one end of the mall to the other, we drove. My level of exercise decreased and then disappeared altogether. I was eating better, too. You can guess the result. I quickly gained weight. My highest weight was last spring, before the switch. I weighed 237 pounds.
I have also had back problems for a long time. A chiropractor visit, sometime around 1990, resulted in a diagnosis of mild scoliosis. That was the first of what would turn out to be regular visits to many chiropractors over the years since. The now sedentary lifestyle, long hours at a desk as a software developer hardly moving from my chair, the extra weight cantilevered over my belt, and the entire lack of exercise, all resulted in a deteriorating back. My visits to the chiropractor occurred at least once every six months, usually every couple of months and, sometimes, several times a week. The low point began the summer of 2007. I needed to use a cane to get around.
The cane was insurance. I didn&amp;rsquo;t always need it. I just needed it often enough that I couldn&amp;rsquo;t leave it behind. I had developed a hyper-mobile lumbar disc. At any time, it could move out of place and lock, pinching a nerve. This usually occurred when transitioning between sitting and standing or when standing too long. Any movement that moved the vertebrae in the wrong direction could trigger it. When that happened, my knees would give and I would fall or, more usually, catch myself on something. The cane gave me the confidence to move around and was useful for climbing back up when I fell. Physical therapy helped some, but did not eliminate the condition. I even saw a couple of orthopedic surgeons, but I was too young for surgery. I was stuck with the cane for life or, as it turned out, until I switched.
That switch is what has allowed everything since. I came across an article on the internet. I don&amp;rsquo;t remember specifically which one, though it may have been one by Dr. Rossi. It might have been &lt;a href=&#34;http://nwfootankle.com/files/rossiWhyShoesMakeNormalGaitImpossible.pdf&#34;&gt;this one&lt;/a&gt;. The article has an image, a diagram, that I have seen several times. The diagram compares human figures in profile, wearing shoes with heels and without heels. The lines through the human figures illustrate the effect wearing shoes with heels has on posture, how the skeletal structure needs to compensate for the heels throwing the feet, legs, and back out of alignment. When heels are not worn, this compensation is not needed. The metaphorical lightbulb was shining brightly. I needed to find some flat shoes. The New York Magazine article, &lt;a href=&#34;http://nymag.com/health/features/46213/&#34;&gt;You Walk Wrong&lt;/a&gt;, provide more information. From that point on, my normal shoes would not have heels. I had switched.
What I had found was Vibram FiveFingers. I bought a pair of black KSOs at &lt;a href=&#34;http://www.hanigs.com/&#34;&gt;Hanig&amp;rsquo;s&lt;/a&gt; in late spring of 2009. I loved them. Either barefoot or combined with some Injinji or Feelmax toe socks, I wore them for everything, for business casual work and for even dressier occasions. Using a Sharpie marker, I blacked out the yellow logo for a &lt;a href=&#34;http://www.flickr.com/photos/timbutterfield/sets/72157619219690538/&#34;&gt;dress mode VFF&lt;/a&gt;. A couple of weeks later, I bought some blue camo Classics for my casual pair. The benefits of wearing a minimal shoe were immediate. Without the raised heel throwing off my posture, my back was beginning to realign. I no longer needed a cane.
I did have a brief setback, though. Shortly after the switch, I attended a three day convention. Though I was not using a cane at that time, those three days were spent sitting in hard plastic stadium seats. It was enough to trigger an episode with my back that took several visits to the chiropractor to resolve. Since then, I have not needed another visit to the chiropractor. If I stay working bent over for a long time, like working on a bike or at the bottom of a cedar closet I was lining, then my back will still weaken. But, as my core muscled have strengthened and continue to strengthen, it now recovers quickly without external manipulation. I also learned to lay on my side, relax, and tilt my pelvis forward and backward. When I put my finger on it, it&amp;rsquo;s weird to feel that vertebrae pop in and out of place. It is no longer a debilitating issue.
Once the surrounding back muscles got used to the new position, I could move freely and did. I was very appreciative of my regained ability and did not want to waste it. That&amp;rsquo;s when I started the Couch to 5K running program and started dreaming of running longer distances. The C25K journey was begun &lt;a href=&#34;http://www.timbutterfield.com/blog/2009/06/10/beginning-c25k/&#34;&gt;here&lt;/a&gt; on June 10, 2009 and finally summarized &lt;a href=&#34;http://www.timbutterfield.com/blog/2009/09/10/c25k-summary/&#34;&gt;here&lt;/a&gt; on September 10, 2009. I had successfully completed the Couch to 5K running plan. I was now a runner.
But, was I really a runner yet? There were some aspects of my C25K performance that troubled me. Though I was going through a running motion, I was quite slow. But, for all of my slowness, my heart rate was quite high. I was using a heart rate monitor to keep an eye on it. The highest recorded was 191 bpm. My normal HR at the end of a workout was in the 160-170 bpm range. The prior year, I had had a stress test done as a check up. My max HR in that test was only 145 bpm. With the C25K workouts, I was regularly exceeding the max HR recorded by a cardiologist. True. I wasn&amp;rsquo;t exercising at the time of that test and was now. Still, it was quite worrisome. The announcements of deaths occurring during marathons did nothing to improve my outlook. It was a risk I could not continue taking. Something had to change.
So, not long after completing the C25K, I started over. I discovered the &lt;a href=&#34;http://www.runningahead.com/groups/LOWHRTR/forum&#34;&gt;Low HR Training&lt;/a&gt; group at &lt;a href=&#34;http://www.runningahead.com/&#34;&gt;RunningAhead&lt;/a&gt;. That led me to Dr. Phil Maffetone and the Maffetone Method of training. Stu Mittleman&amp;rsquo;s Slow Burn book is similar. The theory is that, by doing aerobic base building that does not exceed a calculated heart rate number, you can get faster while maintaining the same heart rate. Once that aerobic base is built, anaerobic training can be added to increase speed. But, that meant a big change for me. I needed to completely rebuild my aerobic system. My starting over needed to be from scratch.
The formula is 180-age plus or minus for various levels of health and fitness or lack thereof. Calculations put my maximum aerobic function (MAF) HR at 135 bpm. In pure numeric terms, it doesn&amp;rsquo;t seem that much lower than it had been. In practice, it was vastly different. I could only walk. Any amount of running caused my HR to exceed my MAF number. My C25K graduation run was at a 15:12 pace. My first MAF workout on September 23, 2009 was at a 23:22 pace. This was painful, painfully slow. It would take forever to get any kind of speed. It almost has.
For the past five months, I have been gradually building my aerobic base. It has been slow, both in pace and in progress. The vast majority of that work has been at a walking pace and not running. I was supposed to have already become a runner, but I wasn&amp;rsquo;t any more. I was a walker again, like I had been long ago as a teenager. I don&amp;rsquo;t quite have that distance yet. Though I did do fifteen miles this week, it was over three days. This is still much more than the 1.08 miles of my first MAF workout. My weekly and monthly averages are increasing. My RunningAhead &lt;a href=&#34;http://www.runningahead.com/logs/98cf638b2edf42708b2e58254aff94dc&#34;&gt;Training Log&lt;/a&gt; has been very helpful for tracking this data. Seeing the changes I am making in the numbers is encouraging.
Compared with my high weight, I am now down thirty-two pounds to 205. I have much more to lose; my goal is to reach 150 pounds. If my calculations are correct, that is nearly two hundred thousand fat calories away from where I am now. I also dream of running a race, not just a marathon, but an ultra marathon, at least a 50k. When I started this journey of movement, I dreamed of doing this. I wanted to go from zero to 50k within two years.
Though I have had to retrace some steps along the way, these goals still seem possible. I really think I can make it. You see, I am on the verge of running again. My walking pace has been gradually improving, getting faster. Even with my now normal warm up and cool down included, it is currently at a 16:37 pace. This is not quite as fast as my C25K pace, which did not have warm up and cool down, but it is much closer than when I started this phase of the journey. I have also started adding brief running segments to my walking. It still raises my HR above my MAF number and I have to slow down to let it drop. Once it drops, I try again. Hopefully, soon, I will be able to keep running with a low HR. Then I can start running more quickly, building speed, and I will have once again become a runner.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>C25K-Summary</title>
      <link>https://timbutterfield.com/post/c25k-summary/</link>
      <pubDate>Thu, 10 Sep 2009 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/c25k-summary/</guid>
      
        <description>&lt;p&gt;My C25K journey has been completed.  It is amazing to be able to go from not running at all to being able to run for 3 miles non-stop.  Here is a recap of the journey.
It started on June 10, 2009.  The first week of the program needed to be repeated two additional times before I could complete it successfully.  This was due primarily to two factors.  The first was my current physical condition, being so out of shape and overweight.  The second was my recent conversion to minimal footwear (Vibram FiveFingers/VFF) that made this journey even possible.  I used to walk with a cane.  Wearing shoes with heels, including running shoes with heels, allows the calf muscles and achilles tendons to shrink.  When the heel of the shoe is removed, these need to be stretched and that stretching takes time.  For that first workout, I managed to cover a whole 0.95 miles in the half hour of walking and running.
One July 3, 2009, I finally completed the week one level successfully.  It took three weeks, but I was now ready to continue with the remainder of the program.  For this workout, I was up to 1.67 miles.
Week four is difficult for many.  Compared with the prior weeks, it has a big jump in the running times.  I discussed that in my &lt;a href=&#34;https://timbutterfield.com/blog/2009/07/22/c25k-interval-run-totals/&#34;&gt;Interval Run Totals&lt;/a&gt; post.
The program progressed well and steadily until week seven, day two.  I got sick this week and it took three tries to get through this particular workout.
On August 31, 2009, I begin week nine and the thirty minute runs.  Though I have been wearing minimal shoes throughout the program with occasional runs and walks barefoot, for the week nine, day one run, I ran the 2.2 miles entirely barefoot.  I am pleased with how it came out and intend to do more of this.
My speed is quite slow.  Even in later workouts, I normally averaged in the 4.0 to 4.3 mph range.  With this slow speed, there is no way I can complete the 5K/3 miles in only thirty minutes.  A common recommendation is to increase workouts by ten percent per week.  For my graduation run, I would need to substantially exceed this recommendation.
On September 5, 2009, I completed my graduation run, week nine, day three.  I mapped out a flat route and ran 3.15 miles in just under 48 minutes.  It was slow, but I completed a full 5K run.  I had finally graduated C25K!
This C25K journey is over.  My journey of running is just beginning.  I like that I am losing weight with the exercise I now get.  While running is not yet easy, I do enjoy being in motion, even if it is currently a slow motion.  My running goals for the future are to keep running and to increase both my duration and my speed.  To do this, I will need to find a way to work on my heart rate and further expand my aerobic capabilities.  With the C25K program, I have built a good foundation on which to continue.
For the full account, start with my &lt;a href=&#34;https://timbutterfield.com/blog/2009/06/10/beginning-c25k/&#34;&gt;Beginning C25K&lt;/a&gt; post.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>C25K-W9D3</title>
      <link>https://timbutterfield.com/post/c25k-w9d3/</link>
      <pubDate>Sat, 05 Sep 2009 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/c25k-w9d3/</guid>
      
        <description>&lt;p&gt;The C25K program consists of three workouts per week for nine weeks. This is the results of the workout for week nine, day three.&lt;/p&gt;
&lt;p&gt;Program: run for 3 miles or 30 minutes.&lt;/p&gt;
&lt;p&gt;Result: I completed the workout as planned. My heart rate averaged 155 bpm and peaked at 166 bpm. I did 3.15 miles in 47:58 for an average speed of 3.9 mph (15:12 minute/mile).&lt;/p&gt;
&lt;p&gt;Graduation run.  I didn&amp;rsquo;t want to delay it, not the final run.  I had to do it.  I am still not over this sinus infection.  But, the worst is over.  That peaked Thursday.  It figures.  By the time I get to the E.N.T. doc on Tuesday, it should be about all gone.  Back to this run.&lt;/p&gt;
&lt;p&gt;For my graduation run, I wanted to go for distance instead of time.  My distances have been far short of the alternate distance program.  Of course, trying to go for the distance at this stage feels like another week four level increase.  It is a substantial percentage increase.  I played around on the &lt;a href=&#34;http://www.gmap-pedometer.com/&#34;&gt;http://www.gmap-pedometer.com/&lt;/a&gt; site to plot a route.  I made sure to add a little extra distance to the route to make up for my running on the sidewalks instead of in the center of the street.  It plotted out to about 3.23 miles, a bit longer than my actual run.&lt;/p&gt;
&lt;p&gt;I had done most of this route on prior workouts.  This route was a combination with an extension to a leg of one route and a reduction to a leg of another.  Using another trick, the last three quarters of a mile are the same route that I have been running for the last month.  If needed, I can run this part on auto-pilot.&lt;/p&gt;
&lt;p&gt;I tried not to check my watch too often.  I probably did most of the checking when I first started.  I was trying to keep my speed down so I wouldn&amp;rsquo;t burn out too soon.  Once my speed stabilized, I only checked it occasionally to keep an eye on my heart rate.&lt;/p&gt;
&lt;p&gt;As expected, I ran slow.  Here are my mile splits:  Mile 1 - 14:38 (4.1 mph), Mile 2 - 15:06 (4.0 mph), Mile 3 - 15:44 (3.7 mph).  Even starting slow, I gradually slowed even more.&lt;/p&gt;
&lt;p&gt;I tried to monitor my feet.  For a while, I was successful in maintaining my form.  Near the end of the first mile, I noticed a swish, swish happening.  Time to correct.  Swish is slide.  Slide is bad.  Place and then lift.  Periodically, over the next mile, I checked and corrected this again.  After the second mile, this became more difficult and more frequent.&lt;/p&gt;
&lt;p&gt;Once into the final three quarter mile, I let auto-pilot take over  a little.  I didn&amp;rsquo;t worry about foot placement as much; just keep moving.  I also begin using small milestones.  Make it to the corner.  Make it to the parking lot driveway.  Make it to the next corner.  This is where I used to take off my VFFs and do a cool-down walk through the grass.  Not this time; I have to keep plugging away.  Make it to the street intersection.  Make it to the end of the next block.  Cross the street to add just a touch to the distance; I&amp;rsquo;ll cross back later.  Eventually, it is cross the street and go up my driveway.  At the front porch, stop the watch.  The run is over.  Right now, I neither know nor care about the distance or time.  I hope it is close to what I had planned.  I&amp;rsquo;ll find out when I cool down and review the data.&lt;/p&gt;
&lt;p&gt;The graduation run is over.  Now, I can rest and ponder over what I have accomplished in the last three months.  It is amazing!  But, I will summarize the journey in another post.&lt;/p&gt;
&lt;p&gt;Here is the Garmin log of this run: &lt;a href=&#34;http://connect.garmin.com/activity/12663372&#34;&gt;http://connect.garmin.com/activity/12663372&lt;/a&gt;&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>C25K-W9D2</title>
      <link>https://timbutterfield.com/post/c25k-w9d2/</link>
      <pubDate>Wed, 02 Sep 2009 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/c25k-w9d2/</guid>
      
        <description>&lt;p&gt;The C25K program consists of three workouts per week for nine weeks. This is the results of the workout for week nine, day two.&lt;/p&gt;
&lt;p&gt;Program: 30 minute run.&lt;/p&gt;
&lt;p&gt;Result: I completed the workout as planned. My heart rate averaged 152 bpm and peaked at 161 bpm. I did 2.29 miles in 33:18 for an average speed of 4.1 mph (14:33 minute/mile).&lt;/p&gt;
&lt;p&gt;I was still fighting a cold/sinus infection that was just starting on the last workout.  But, I wanted to complete the program this week and needed to keep on schedule.  So, I ran.  It was just a little slower than before.  I was hoping to add a little to the distance in hopes of getting a little closer to a true 5K for a graduation run.  Running down the boat ramp and up the path beside the lake probably wasn&amp;rsquo;t the best addition to my normal route.&lt;/p&gt;
&lt;p&gt;As I approached the one mile point, I did get a slight break.  I heard the exhaust rumble of a large engine and needed to stop for several seconds to let a Dodge Viper back out of a driveway.  Then, back to running.  As I neared the end point of the block to turn around, I crossed behind a minivan about to pull out of another driveway.  If I timed it right, I could stop again on the way back.  Nope; just a little too slow.  By the time I reached the end, turned around, and got back, they had already backed out past the sidewalk.  Oh, well.  Keep running.&lt;/p&gt;
&lt;p&gt;On the way back up the block, I was thinking of how I could extend the route a little more for my graduation run.  One way would be to keep my normal route and  add a down and back along the lake.  Though it would cut off the corner of the block, I decided to try it today and ran down the boat ramp and along the lake.  I had forgotten about there being more bugs near the water.  Yech!  It&amp;rsquo;s a good thing I was trying to practice my nose breathing.  Part of the way down along the lake, the path raises back up to street level.  My watch had already passed the two mile point and, back up at street level, the path splits.  One part continued along the lake.  Another cut across the street.  I took the latter and headed for home.  Only one more workout in the C25K.  I&amp;rsquo;m still not sure yet what route I&amp;rsquo;ll take for the graduation run.  I only know that I&amp;rsquo;ll run and run and run some more for at least half an hour.&lt;/p&gt;
</description>
      
    </item>
    
    <item>
      <title>C25K-W9D1</title>
      <link>https://timbutterfield.com/post/c25k-w9d1/</link>
      <pubDate>Mon, 31 Aug 2009 00:00:00 +0000</pubDate>
      <author>tim@timbutterfield.com (Tim Butterfield)</author>
      <guid>https://timbutterfield.com/post/c25k-w9d1/</guid>
      
        <description>&lt;p&gt;The C25K program consists of three workouts per week for nine weeks. This is the results of the workout for week nine, day one.&lt;/p&gt;
&lt;p&gt;Program: 30 minute run.&lt;/p&gt;
&lt;p&gt;Result: I completed the workout as planned. My heart rate averaged 157 bpm and peaked at 163 bpm. I did 2.2 miles in 31:03 for an average speed of 4.3 mph (14:05 minute/mile).&lt;/p&gt;
&lt;p&gt;I now know how far it is to the end of block on the far side of the lake near my house.  I stopped at the end of block, touched the end cap of the fence post on the corner, and turned around.  It was right at 1.1 miles.  If I decide to try for a 5K for my graduation run, I&amp;rsquo;ll need to add an extension to my route.  Or, I could go back to the asphalt path that I used during my week one repeats.  I have a few more days to decide.  But, back to this workout&amp;hellip;&lt;/p&gt;
&lt;p&gt;My splits for this workout were just slightly different than for the last.  The first mile was done in 13:24 (4.5 mph), 0.1 mph faster.  The second mile was done in 14:39 (4.1 mph), 0.1 mph slower.  This was a little surprising to me.  The reason it was surprising is that I did this entire workout barefoot.&lt;/p&gt;
&lt;p&gt;I had been afraid to try this.  Earlier in the C25K, I had removed my VFFs for some of the run intervals.  I could use the walks intervals to put on or take off the VFFs and not interrupt the run intervals.  I was afraid to try this for the later workouts as there were no walk intervals I could use to switch.  I would have to interrupt the run to do it and I didn&amp;rsquo;t want to have to do that.  Today, I decided to go ahead and try it and see what happened.  I carried the VFFs with me just in case I needed to stop and switch in order to finish the run.  They were easy to carry.  I carried them both together in my left hand, with my thumb stuck in one of the toe pockets.&lt;/p&gt;
&lt;p&gt;So, what happened with my bare feet?  Not much, actually.  For the most part, the run went well.  It was interesting feeling the textures of the various surfaces I ran on.  Some of the sidewalk was smooth cement.  Other sections were more pitted.  I also crossed over and ran on the asphalt of the streets.  I even ran a little on the grass of the park.  It was a good mix of textures, none of which were difficult to run on barefoot.  Instead of checking too many of the other focuses of ChiRunning, for this run, I mostly did the BodySensing to better monitor what was happening with my feet and my form.  About half a mile in, I lifted my right foot a little higher and brushed off a small pebble that stuck to the skin of the arch.  Some time after the turn around point, I noticed a slight stinging feeling in the pad of the third toe of my right foot.  It wasn&amp;rsquo;t too bad and I kept going.  It was slightly sensitive for the rest of the run.  After I got home at the end of the run and cooled down a little, I washed my feet and found the cause.  A layer of skin was off of that toe in about a one quarter inch diameter circle.  I&amp;rsquo;m not sure if I got a blister and it broke or if I slid that toe slightly and abraded it on the cement.  In any case, the blister I had early on in the C25K was worse.  Overall, my feet are a little tingly, like they have had a good massage.  Time will tell if there are any other issues that will appear.&lt;/p&gt;
&lt;p&gt;I&amp;rsquo;m amazed I can run two miles straight.  I&amp;rsquo;m more amazed I can run two miles straight while barefoot.  Only two more workouts remain in my C25K program.&lt;/p&gt;
</description>
      
    </item>
    
  </channel>
</rss>
