<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>Braydon McCormick — Writing</title>
    <link>https://setearth.io/writing/</link>
    <description>Essays and notes from twenty years of running companies.</description>
    <item>
      <title>Using AI to Predict Clinical Trial Patient Populations in the Future</title>
      <link>https://setearth.io/writing/using-ai-to-predict-clinical-trial-patient-populations/</link>
      <guid>https://setearth.io/writing/using-ai-to-predict-clinical-trial-patient-populations.md</guid>
      <pubDate>Thu, 10 Sep 2026 00:00:00 GMT</pubDate>
      <description>At [Navicyte](https://navicytebiotech.com) we were talking with one of our senior advisors. She made the point that a lot of high-potential drug candidates don't die from bad science. They run out of money during clinical trials because the competition for patients is too dense. The trial can't enroll, the program burns cash waiting, and the drug dies.

That put the question in front of us years before the first dose: will there be enough patients for a Phase 1a or 1b trial, given the competing trials that will be recruiting when we expect to start ours?

## What I built

We're early-stage, and we run the company as an AI-native org. So I didn't buy the vendor version of this answer. I built a process.

I broke the population question into parts: total addressable pool, competitive trial landscape, residual feasibility, biology fit. Then I ran a multi-panel analysis against it. The architecture descends from the expert-panel simulator I open-sourced in ["Smart Models, Dumb Pipes"](/writing/smart-models-dumb-pipes/): structured decomposition, parallel expert agents working the sub-questions independently, adversarial seats that challenge the core assumptions, and preserved dissent that keeps the minority position in the final deliverable. The adversarial seats were pointed at the framing itself: the population definitions and the plan's own assumptions. The whole thing ran in roughly a day for about fifty dollars in tokens.

Then I pointed it at the population our development plan was built on.

![The population monitor: inputs, parallel expert panels, and the feasibility verdict](/images/writing/patient-population-monitor.png)

## What it found

The documented lead was a "cisplatin-ineligible" slice of a relapsed blood-cancer population, an operational target we expected to enroll. The process found that population doesn't exist as a recognized clinical stratum. The salvage regimen the framing assumed uses carboplatin, not cisplatin, so "cisplatin-ineligible" sorts patients by their tolerance of a drug they were never going to get. The 20–40% citation supporting it was unverifiable. The patients it claimed overlap with the CAR-T- and bispecific-eligible pool: the cell and antibody therapies competing for the same relapsed patients. The operational prediction was precise and wrong. The error didn't come from the model. It came from the framing we brought to it: the planning documents, the KOL interviews, the narrative that said there was a population to enroll.

The second failure was the pool itself. On the run's count, that population alone carried 89 US trials competing for roughly 5,638 patients in the 2028 window, with a graduation class (golcadomide, soquelitinib, valemetostat, next-wave CD19×CD3 bispecifics) coming through Phase 2 readouts and about to consume more of the relapsed pool. Even if the cisplatin-ineligible slice had been a real stratum, the competitive density was eating it before our sites could open.

You're actually predicting three things, and the field builds tools for one and a half of them. Who will enroll is operational: which sites, how fast, do you hit your number. Who should enroll is scientific: is this the right population. And will the pool still be there when you get there is competitive density. The tools that exist forecast your enrollment as if nothing else is running.

When I looked at what the field had built, it's almost all the first one. The operational tier is saturated: [Medidata](https://www.medidata.com/en/study-experience/clinical-trial-analytics/), [IQVIA](https://www.iqvia.com/solutions/technologies/orchestrated-clinical-trials/planning-suite/studyoptimizer), [ProofPilot](https://www.proofpilot.com/). A second tier ([BEKhealth](https://www.bekhealth.com/platform/), [Carta Healthcare](https://www.carta.healthcare/research/), [NIH TrialGPT](https://www.ncbi.nlm.nih.gov/research/trialgpt/)) matches patients in EHR systems to trial criteria but never asks the validity question. Two products edge toward the should side: [QuantHealth](https://quanthealth.ai/) evaluates protocols and populations through simulation, and [PhaseV](https://www.phasevtrials.com/solutions) models protocol trade-offs before lock. But neither frames it as which population the trial is actually asking about, and neither runs anything adversarial against the answer. Competitive density is barely touched.

The same process found where the premise holds: recurrent, cisplatin-refractory head and neck cancer, where cisplatin is still the backbone, the toxicity is the actual reason for discontinuation, "cisplatin-unsuitable" is a published concept, and most competing trials use cisplatin rather than competing for the patients who can't finish it. The lead died in analysis instead of in the clinic.

## What's left

I applied adversarial multi-panel review to clinical trial population validity, and it produced a real redirect. The integration doesn't appear as a commercial product anywhere I looked. The closest comparable is [TRIAGE](https://openreview.net/attachment?id=YYmB6Zi088&amp;name=pdf), an academic prototype that uses a generative agent to propose biological targets, adversarial agents to falsify them, and an output agent to synthesize. Same structural pattern, applied to target validation, not population prediction, and never deployed. Survey methodology has been fighting the frame-validation problem since the 1930s. The [Literary Digest poll](https://en.wikipedia.org/wiki/The_Literary_Digest) drew 2.4 million responses and predicted the wrong outcome: its sample came from phone and car lists, and only a quarter answered. Either flaw is enough. Nobody has ported that toolkit to clinical trial population assessment.

So can a small team catch a wrong-population prediction before the money runs out? The Navicyte run says yes. A day, fifty dollars, a redirect. The candidate that would have died the way our advisor described is still in development as I write this (September 2026).

---

## Links &amp; sources

**My prior writing:**
- [Smart Models, Dumb Pipes](/writing/smart-models-dumb-pipes/) — the architectural ancestor (the open-sourced expert-panel simulator). The Navicyte harness applet described here is a production-grade descendant; we're not open-sourcing that version.
- [The Constraint Flipped](/writing/the-constraint-flipped/) — the production-vs-understanding tension this piece extends

**The work this piece describes:**
- [Navicyte](https://navicytebiotech.com) — the population &amp; competitive-landscape monitor described here is a private production tool, not the open-sourced simulator.

**The will / should tool landscape:**
- [Medidata Study Feasibility](https://www.medidata.com/en/study-experience/clinical-trial-analytics/)
- [IQVIA StudyOptimizer](https://www.iqvia.com/solutions/technologies/orchestrated-clinical-trials/planning-suite/studyoptimizer)
- [ProofPilot](https://www.proofpilot.com/) — trial execution; acquired Lokavant's trial intelligence in 2025
- [Phesi Trial Accelerator](https://www.phesi.com/trial-accelerator/)
- [Confyde](https://www.confyde.ai/)
- [PSI SYNETIC](https://psi-cro.com/psi-synetic-clinical-trial-site-intelligence-selection/)
- [PhaseV Enrollment Lab](https://www.phasevtrials.com/solutions)
- [BEKhealth](https://www.bekhealth.com/platform/) — patient matching
- [Carta Healthcare](https://www.carta.healthcare/research/) — patient matching
- [NIH TrialGPT](https://www.ncbi.nlm.nih.gov/research/trialgpt/) — patient matching
- [QuantHealth](https://quanthealth.ai/) — protocol/population simulation (closest to "should")

**The closest comparable (the honest novelty test):**
- [TRIAGE: An AI Scientist for Adversarial Target Falsification](https://openreview.net/attachment?id=YYmB6Zi088&amp;name=pdf) — same structural pattern, applied to biological target validation, not population prediction; academic prototype, never deployed

**The frame-validation precedent:**
- [The Literary Digest (Wikipedia)](https://en.wikipedia.org/wiki/The_Literary_Digest): the 1936 straw poll that drew 2.4 million responses and predicted the wrong outcome; its sample came from phone and car lists, and only a quarter answered

*Process note: this post was assist-written with an agent, but the thinking, the argument, and the final edits are my own.*</description>
    </item>
    <item>
      <title>Herding Kittens with Jet Packs</title>
      <link>https://setearth.io/writing/herding-kittens-with-jet-packs/</link>
      <guid>https://setearth.io/writing/herding-kittens-with-jet-packs.md</guid>
      <pubDate>Thu, 16 Jul 2026 00:00:00 GMT</pubDate>
      <description>![Kittens with jet packs](/images/writing/kittens-with-jetpacks.png)
*Everyone gets a jet pack. Watch the kittens fly!*

&gt; **TL;DR:** Everyone's got a jet pack now and productivity still hasn't moved. This is about the fast, fragile little machines people are building with them, none of them connected to anything, nobody steering any of it (ours included, for a while), and what to do about it.
{: .tldr }

We keep hearing the same thing from clients and prospects: *we're giving everyone Claude so they can build it themselves, software is cheap now.* And they think that's the whole job. Get the tools in people's hands. Done. The rest takes care of itself.

And look, it works. The person who's had a request stuck in an IT queue for a year can build the thing herself by Tuesday. I do it myself; a motivated person with a capable model is more powerful than the same person without one. Just try taking that superpower away and wait for the wrath. Everyone can have a jet pack now. It's super fun and awesome.

So this isn't an argument against handing out jet packs. But a [paper out of NBER](https://www.nber.org/papers/w34836) this year surveyed nearly six thousand senior executives and found that nine in ten say AI has had no impact on their firm's employment or productivity over the last three years. Everyone has Claude (well, an increasing share do), and productivity hasn't moved. The part that complicates the jet-pack story: those same executives are using AI about **1.5 hours a week**. So it's not that the tools are broken and it's not (yet) that they're transforming anything. They're just on the desk, used lightly.

*(Update, October 2026: the paper's revision now surveys nearly nine thousand executives across seven countries, reports average use up to 2.1 hours a week, and finds AI adoption has raised annual labor productivity growth by about 0.2% over the last three years — still light use, still a small measured effect.)*

You can read that two ways. One: it's early, give it time, the gains are coming. Two: the tools work, but the work the tools make possible isn't getting composed into anything, it's piling up in competing directions. I'm in the second camp, and the rest of this is why.

## Many beautiful, fragile, isolated machines

An org's AI journey usually starts with one or two people eager to get into things, the lateral integration thinkers who just want stuff done. Every office has a spreadsheet whisperer. She discovers she can build a little tool: a form that routes intake emails, a dashboard that pulls from the CRM and makes it legible. She built it in an afternoon in Claude desktop. It's pretty good and she's amazed and proud. A year ago that tool would have cost a six-week IT project and a Jira board with its own ecosystem of tickets, and would never have been prioritized. Not anymore (sorry, IT, your support role is about to get a modification).

That invention is a shiny, cool Rube Goldberg machine: a chain of clever steps that does a real task, and works beautifully right up until somebody bumps the table.

![A hand-drawn Rube Goldberg machine from 1966](/images/writing/teschmacher-rube-goldberg-1966.jpg)
*My uncle Guy Teschmacher's Rube Goldberg machine, drawn in 1966. He also has a clock in MoMA that has its face hidden. Too funny.*

&lt;details markdown="1"&gt;
&lt;summary&gt;&lt;strong&gt;What one of these actually looks like (click to expand)&lt;/strong&gt;&lt;/summary&gt;

A clever person, one afternoon, has the model write her this:

```python
# intake_router.py — built Tuesday, works on Tuesday
import requests

FORM_ID = "1aB...cD9"
SHEET_TOKEN = "ya29.A0..."        # her personal OAuth token, in plaintext
SLACK_WEBHOOK = "https://hooks.slack.com/services/T0.../B0..."

def main():
    rows = requests.get(
        f"https://sheets.googleapis.com/v4/spreadsheets/{FORM_ID}/values/A:Z",
        headers={"Authorization": f"Bearer {SHEET_TOKEN}"},
    ).json()["values"]
    for r in rows:
        requests.post(SLACK_WEBHOOK, json={"text": f"New lead: {r[1]}"})  # r[1] = Name
```

It runs pretty well and she is, legitimately, a hero.

The downside: in a single-player environment, the token is hers; the morning she leaves the company, it dies, and nobody knows why. Or it breaks the day the form adds a "Company" field and the columns shift, because nobody told the agent to update the script or that the columns might move. The CRM has never heard of any of this. The lead exists in Slack and nowhere else. And she's the only person who knows the script exists. She's going on vacation Thursday. Etc.

That is a Rube Goldberg machine. Clever, fragile, and don't mess with it.

&lt;/details&gt;

Then it fans out. The whole team gets the same superpower, gets excited, and each person builds their own version of the thing they always wanted but couldn't have. Marketing automates its reporting. Operations builds a scheduling widget. Finance stands up a reconciliation script. Each one, on its own, is impressive and valuable. And each one has the same defect a Rube Goldberg machine has. Nobody reads what the others built, because everyone's heads-down in their own.

We live this ourselves. I generate a twelve-week LinkedIn campaign on Monday, and by Tuesday morning somebody else's agents have overwritten it. A third person's agents don't know where to pick it up, so they start over. We put the work in GitHub, the way you're supposed to, and it doesn't help. GitHub was never built for the sheer volume of stuff a team of agents generates and overwrites in a day. Then on top of that, if merges aren't handled correctly, the agents get confused over what is currently the gold copy and start using the wrong language when we move to automation.

It's a compounding mess. We build these systems for other people for a living, and our own integrations were a disaster.

We are, collectively, herding kittens with jet packs.

Tiny jet packs strapped to furry bodies, little contrails arcing across the office. One just knocked a lamp off the desk and didn't notice. Another is on top of the refrigerator, refusing to come down, generating a campaign brief nobody asked for. A third is midair, headed for the curtains. Each kitten, individually, is magnificent, faster and more capable than any kitten has ever been. And you're standing in the middle of the room with a clipboard, watching the furniture get destroyed, trying to remember why you thought the clipboard would help.

What's missing is the structure underneath: no shared state, nothing that says which goes where and which curtain is off-limits. First, the part people skip.

## A different clock

Coordination is part of the problem. The other part is timing. Or, to quote The Police (courtesy of Jung), the whole thing is synchronicity.

In human time, you do weekly check-ins, monthly reviews, quarterly planning. All necessary and good, even if we've always been annoyed by them, it's the tax you pay for coordination. It was keeping a clock the whole time, to keep people in sync. Weekly meetings worked because everyone in the room moved at roughly the same speed. Nobody had moved so far since last Friday that an hour couldn't catch them up.

But this runs on a different clock. People are moving faster and broader than they used to, and each one is generating an avalanche of artifacts along the way, because that's what humans-plus-agents do, they produce. Reports, dashboards, scripts, drafts, follow-ups. The old Friday meeting can't re-synchronize any of it, because the gap between last Friday and this Friday has opened into a canyon. The artifacts pile up unreviewed and the humans fall further behind the thing they're supposed to be overseeing, until they're not overseeing it at all. Piloting one of these things is fatiguing, but the momentum isn't.

And all along, nobody did anything wrong. Every individual made a sensible decision. The system still came apart, because it wasn't designed as a system, let alone for coordinated effort, or a team-focused idea. It got improvised, at high speed, by people told to go fast and given no way to stay fast together.

## What it does to trust

There's a downstream consequence. A friend told me the other day he now says to people: *if you send me a deck longer than three slides, I'm not reading it.* And I've heard this more than once, and feel it myself: *if I catch one AI-ism in an article, I stop trusting the author.*

This is the overproduction problem hitting the audience. The artifacts piled up faster than the humans could validate them, so the audience taught itself to flinch at the whole category. Hand everyone a jet pack and you also hand them a reason to trust the next deck a little less. The kittens aren't just wrecking your office, they're wrecking the room you deliver the work into.

## Herding kittens with jet packs

So you've got a room full of fast, empowered people, each generating a small mountain of output, none of it composed, most of it unvalidated, and the old meeting cadence can't keep up. Managing that is its own problem, and most of what's out there stops at "call a vendor when you're ready for the next level," which isn't really helpful, except to the vendor's sales funnel.

Herding kittens was hard when the kittens were slow. Herding kittens with jet packs is a different sport. The old management questions, what did you do this week, are you on track, don't catch the real failure mode, because the real failure mode isn't underperformance. It's overproduction in a bunch of competing directions. Things that don't compose, that nobody validates, that pile up unread. The person looks busy and productive and is, in fact, generating the problem. You can't spot that by asking whether they hit their hours.

&gt; The real failure mode isn't underperformance. It's overproduction in a bunch of competing directions, things that don't compose, that nobody validates, that pile up unread.
{: .callout }

There's a trap in here that catches the people who feel the most capable. The tool makes production frictionless, so you produce more than you ever have, and the volume feels like competence. It isn't. Using AI well doesn't make you an expert in the thing you're producing; it makes you a fast first-draft factory for a thing you still have to know how to judge. I've watched smart people ship dashboards they couldn't actually defend, campaigns they couldn't tie to an outcome, reconciliations that were confidently wrong in the last row. They felt like experts because the output was fluent. The fluency was the model's; the judgment was still theirs, and it hadn't grown to match the throughput. Overproduction under a false sense of expertise is worse than plain overproduction, because the person generating it doesn't know they're the problem.

So the first move isn't structural. It's managerial, and it's mostly subtraction. Two questions, aimed less at motion and more at intent:

&gt; **How did you limit the output to the core effort?** The default behavior of an agent team is to produce everything it can. A good operator's job, now, is mostly subtraction, deciding what not to generate, what to cut, what to refuse to ship. If someone can't tell you how they limited the output, they didn't.
&gt;
&gt; **What's your intentional work this week, and how are you steering your agent team toward it?** Intentional work is the small set of things a person means to accomplish, separate from the avalanche the agents produced along the way. The question is whether they can name it, and whether the team is pointed at it, or just pointed. If the agent team has no relationship to the intentional work, the agent team is driving and the person is along for the ride.
{: .callout }

I ask myself that second one every Monday (and increasingly every day), and I don't always like the answer. That struggle is the diagnostic.

At the team level these get exponentially harder, and I suspect they turn into a role: someone whose entire job is subtraction, taking the ten near-identical jobs the team just generated and folding them into one, killing the duplicates, keeping the shared state clean. A dedup PM, basically. We're starting to see the shape of it.

That's the managerial floor. It's what you do on Monday to keep the overproduction from burying you while you figure out the bigger piece.

## The bigger piece

The two questions are a stopgap. They're how you manage the problem before the real fix exists, because the real fix isn't a management practice, it's structure.

And the objection: *but the labs are fixing this*. Yes, partly, and it hasn't gotten far. Anthropic and OpenAI are both racing to add the connective tissue: Claude's shared agents and scheduled tasks on Team and Enterprise plans, ChatGPT's scheduled tasks and workspace agents for business, plus a whole crop of orchestration startups, CrewAI, LangGraph, n8n (which I use myself), all selling the "AI brain" that coordinates the rest. So far, in our experience, almost all of it bolts onto the individual jet packs. It coordinates them. It doesn't yet sit underneath them as shared structure, the part that says what state is true, what work is intentional, and what's just noise the kittens made on the way to the ceiling. (We build that kind of underlying structure for clients at LightForge, so read this as the hypothesis we're betting on, not an idle observation. And it's a falsifiable one: if a firm builds the coordination layer and productivity still doesn't move, the frame is wrong, not the implementation, and we'll have said so.)

This isn't a new shape of problem, by the way. It's the old one, what Charles Perrow called *normal accidents*: systems fail not because any single part is broken but because the parts interact in ways nobody designed for. And it rhymes with Solow's productivity paradox, the one about computers showing up everywhere except in the productivity statistics. The kittens-with-jet-packs version is the same pattern at a new clock speed.

&gt; The fix is the same shape it's always been: stop bolting coordination onto the parts, and put structure underneath them instead.
{: .callout }

Anyway. You can't take the jet packs back, and you shouldn't want to. But you can stop measuring kitten motion and start managing intent on Monday, and start building the kitchen the kittens are flying around in.

*(Next: what a smart kitchen is, and why your team needs one to really cook.)*</description>
    </item>
    <item>
      <title>The new constraint</title>
      <link>https://setearth.io/writing/the-constraint-flipped/</link>
      <guid>https://setearth.io/writing/the-constraint-flipped.md</guid>
      <pubDate>Mon, 01 Jun 2026 00:00:00 GMT</pubDate>
      <description>&lt;style&gt;
  @import url('https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;500;600;700&amp;family=Source+Serif+4:opsz,wght@8..60,400;8..60,500;8..60,600&amp;family=Instrument+Sans:wght@400;500;600&amp;display=swap');

  .post-header { display: none; }

  .site-header {
    position: relative;
    overflow: hidden;
    background: linear-gradient(135deg, #0f1218 0%, #1a2030 48%, #2a3048 100%) !important;
    border-bottom: 1px solid rgba(120, 140, 200, 0.12) !important;
    box-shadow: 0 14px 34px rgba(0, 0, 0, 0.28) !important;
    margin-bottom: 0 !important;
    padding: 2rem 0 1.25rem !important;
  }

  .site-header .site-title { color: #e8eaf2 !important; }
  .site-header .site-title:hover { color: #c8cde8 !important; }
  .site-header .site-subtitle { color: rgba(220, 225, 245, 0.68) !important; }
  .site-header .site-nav {
    background: rgba(255, 255, 255, 0.07) !important;
    border: 1px solid rgba(255, 255, 255, 0.14) !important;
    backdrop-filter: blur(10px);
  }
  .site-header .page-link {
    background: rgba(230, 235, 255, 0.90) !important;
    color: #1a2030 !important;
    border: 1px solid rgba(100, 120, 200, 0.18) !important;
  }
  .site-header .page-link:hover {
    background: #c8cde8 !important;
    color: #0f1218 !important;
  }
  .site-header .menu-icon &gt; svg path { fill: #e8eaf2 !important; }

  .page-content {
    background: linear-gradient(180deg, #ede8de 0%, #f2ede3 40%, #f5f1e8 100%) !important;
  }

  .page-content .wrapper {
    max-width: 980px !important;
    padding: 0 1.4rem !important;
  }

  .constraint-essay {
    --ce-ink: #1c1510;
    --ce-soft: #4a3c2e;
    --ce-muted: #8a7560;
    --ce-rule: rgba(80, 60, 40, 0.18);
    --ce-accent: #c87828;
    --ce-accent-soft: #e09840;
    --ce-dark: #0f1218;
    font-family: 'Source Serif 4', Georgia, serif;
    color: var(--ce-ink);
    counter-reset: ce-section;
    padding: 2.5rem 0 5rem;
    max-width: 720px;
    margin: 0 auto;
  }

  .constraint-essay a {
    color: var(--ce-accent);
    text-decoration-color: rgba(200, 120, 40, 0.35);
    text-underline-offset: 0.18em;
  }

  /* Hero */
  .ce-hero {
    text-align: center;
    padding: 1.5rem 0 2rem;
    max-width: 980px;
    margin: 0 auto;
  }

  .ce-eyebrow {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.72rem;
    letter-spacing: 0.22em;
    text-transform: uppercase;
    color: var(--ce-muted);
    margin: 0 0 1rem;
  }

  .ce-hero h1 {
    font-family: 'Playfair Display', serif;
    font-size: clamp(2.6rem, 7vw, 4.4rem);
    line-height: 1.02;
    font-weight: 500;
    letter-spacing: -0.02em;
    color: var(--ce-ink);
    max-width: 14ch;
    margin: 0 auto 1rem;
  }

  .ce-subtitle {
    font-family: 'Playfair Display', serif;
    font-style: italic;
    font-size: clamp(1.1rem, 2.8vw, 1.5rem);
    line-height: 1.48;
    color: var(--ce-soft);
    max-width: 36rem;
    margin: 0 auto 1.35rem;
  }

  .ce-meta {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.74rem;
    letter-spacing: 0.14em;
    text-transform: uppercase;
    color: var(--ce-muted);
    margin: 0;
  }

  .ce-rule {
    width: 80px;
    height: 1px;
    background: linear-gradient(90deg, transparent 0%, var(--ce-accent-soft) 50%, transparent 100%);
    margin: 1.75rem auto 0;
  }

  /* Hero image */
  .ce-hero-image {
    max-width: 980px;
    margin: 0 auto 3.5rem;
    opacity: 0;
    transform: translateY(14px);
    transition: opacity 0.9s ease, transform 0.9s ease;
  }

  .ce-hero-image.ce-visible { opacity: 1; transform: translateY(0); }

  .ce-hero-image img {
    display: block;
    width: 100%;
    border-radius: 20px;
    border: 1px solid rgba(80, 60, 40, 0.12);
    box-shadow: 0 28px 64px rgba(15, 18, 24, 0.18);
  }

  /* Section headings */
  .constraint-essay h2 {
    counter-increment: ce-section;
    font-family: 'Playfair Display', serif;
    font-size: clamp(1.6rem, 3.8vw, 2.2rem);
    line-height: 1.1;
    font-weight: 500;
    letter-spacing: -0.02em;
    color: var(--ce-ink);
    margin: 2rem 0 1.4rem;
    padding-top: 0;
    border-top: none;
  }

  .constraint-essay h2::before {
    display: block;
    content: counter(ce-section, upper-roman);
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.68rem;
    letter-spacing: 0.32em;
    text-transform: uppercase;
    color: var(--ce-accent-soft);
    margin-bottom: 0.7rem;
  }

  /* Body text */
  .constraint-essay p {
    font-size: 1.08rem;
    line-height: 1.9;
    color: var(--ce-soft);
    margin-bottom: 1.3rem;
    max-width: 68ch;
  }

  .constraint-essay strong { color: var(--ce-ink); }

  /* Pull quotes */
  .ce-pull {
    margin: 2.5rem 0 2.5rem -1.5rem;
    padding: 1.4rem 1.6rem;
    border-left: 3px solid var(--ce-accent);
    background: rgba(200, 120, 40, 0.05);
    border-radius: 0 14px 14px 0;
    opacity: 0;
    transform: translateX(-8px);
    transition: opacity 0.7s ease, transform 0.7s ease;
  }

  .ce-pull.ce-visible { opacity: 1; transform: translateX(0); }

  .ce-pull p {
    font-family: 'Playfair Display', serif;
    font-style: italic;
    font-size: clamp(1.15rem, 2.8vw, 1.42rem);
    line-height: 1.5;
    color: var(--ce-ink);
    margin: 0;
    max-width: none;
  }

  /* Divider */
  .ce-divider {
    display: flex;
    align-items: center;
    gap: 0.9rem;
    margin: 3rem 0 2.5rem;
    opacity: 0;
    transition: opacity 0.6s ease;
  }

  .ce-divider.ce-visible { opacity: 1; }

  .ce-divider span:first-child,
  .ce-divider span:last-child {
    height: 1px;
    flex: 1;
    background: var(--ce-rule);
  }

  .ce-divider span:nth-child(2) {
    font-size: 0.85rem;
    color: var(--ce-accent-soft);
  }

  /* Footer / process note */
  .ce-footer {
    margin-top: 4rem;
    padding-top: 1.5rem;
    border-top: 1px solid var(--ce-rule);
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.84rem;
    line-height: 1.65;
    color: var(--ce-muted);
  }

  .ce-footer a { color: var(--ce-accent); }

  .ce-footer p { max-width: none; font-size: 0.84rem; color: var(--ce-muted); }

  /* Scroll progress */
  .ce-progress {
    position: fixed;
    top: 0; left: 0;
    width: 0;
    height: 3px;
    background: linear-gradient(90deg, var(--ce-accent) 0%, var(--ce-accent-soft) 100%);
    z-index: 9999;
    box-shadow: 0 0 12px rgba(200, 120, 40, 0.4);
  }

  @media (max-width: 720px) {
    .constraint-essay { padding-top: 1rem; }
    .constraint-essay p { font-size: 1rem; }
    .ce-pull { margin-left: 0; border-radius: 0 10px 10px 0; }
  }
&lt;/style&gt;

&lt;div class="ce-progress" aria-hidden="true"&gt;&lt;/div&gt;

&lt;div class="ce-hero"&gt;
  &lt;p class="ce-eyebrow"&gt;Essay &amp;middot; June 1, 2026&lt;/p&gt;
  &lt;h1&gt;The new constraint&lt;/h1&gt;
  &lt;p class="ce-subtitle"&gt;I spent a year building an operating system for my work. Then I had to revise the story I was telling about what it changed.&lt;/p&gt;
  &lt;p class="ce-meta"&gt;Braydon McCormick &amp;middot; Means of Production&lt;/p&gt;
  &lt;div class="ce-rule"&gt;&lt;/div&gt;
&lt;/div&gt;

&lt;div class="ce-hero-image" data-reveal&gt;
  &lt;img src="/images/writing/constraint-flipped-hero.png" alt="A small figure stands among massive self-illuminated stone spheres floating in dark space." /&gt;
&lt;/div&gt;

&lt;div class="constraint-essay" markdown="1"&gt;

The last three posts in this series were about how to build this. This one is about what it's like to live in it.

## The freakout

Sometimes I show people how I work, and it freaks them out a little. Not in a "wow, cool demo" way. More like they sit with it for a few minutes, see the agents running, see the context flowing between three companies, see a Tuesday morning that shouldn't be possible for one person, and something changes. Like they're seeing a version of work they didn't know existed. I know other practitioners doing similar patterns and they report the same effect.

## What I used to believe

In March I published three pieces about building with AI. The first was about [moving from treating AI as a collaborative room to building the operational layer behind it: from studio to forge](/writing/from-ai-studio-to-ai-forge/). The second was about [why a chat interface isn't a business capability, and what a real capability actually requires](/writing/you-dont-want-another-chatbot/). The third was about [keeping intelligence in the model and the infrastructure simple: smart endpoints, dumb pipes](/writing/smart-models-dumb-pipes/).

In hindsight (since it wasn't my intent and I didn't realize what was happening): I spent a year building an operating system for my own work and it's entirely changed the way I work.

My thesis going into this piece was that the constraint had flipped. The old bottleneck was me, how much one person could produce. I thought the new bottleneck was everything outside me, clients, regulators, investors, the world's pace. Neat, clean, satisfying narrative.

It's only half true. And the half I got wrong is the more interesting part.

## Three companies, three walls

Over the last eighteen months I've been running three companies through this system. Or trying to.

[LightForge Works](https://lightforgeworks.com) is where I spend much of my time. It's mostly BD: working with partners, solving prospective customer problems, teaching people about AI, building a new, AI-native company. Not "consulting" in the slide-deck sense. More like: I Zoom with a client on Monday, we dig into their actual problem, and by the end of the day I've got action items captured and a prototype spec drafted and a demo on the calendar for next week. The proposal is ready in hours. The prototype is ready in a day. The client makes decisions in weeks. The gap is on the other side of the table.

[Synthyra](https://synthyra.com) is computational biology: protein-protein-interaction prediction with many applications, but we're focused on biosecurity at the moment, beginning to explore options in federal biosecurity programs. Just building new IP around off-patent drugs that treat Hantavirus. The science moves. The research output outpaces what partnerships and licensing conversations can absorb. We are generating weeks of analytical work in a day and then waiting on a business development cycle that runs on calendar quarters.

A Synthyra day is more variable. When my AI agent is working the way I want her to, she'll surface a potential partner from the literature before I've finished coffee and I can turn it into outreach in an hour. But she's not reliably proactive yet: building a research agent that fires consistently is harder than it looks, mostly a harness problem I haven't fully solved. More often I'm the one driving: pulling up the outreach factory, a purpose-built tool we built to research targets, enrich contacts, and queue Gmail drafts for review, with conversational agents helping me work through which targets are worth the send and what the angle should be. By midafternoon the outreach is out and I'm waiting on responses from people who won't read any of it for two weeks. The work took a few hours. The cycle takes a month.

[Navicyte](https://navicytebiotech.com) is biotech: reformulating last-line, highly toxic cisplatin for chemo into a safe, potent cancer therapeutic. My work there is strategy, operations, BD. Last week I needed to refine the Pro Forma, the ten-year financial model that shows whether this drug is worth backing. So I broke out a bunch of Codex CLI instances working together, assigned them to do market research, build the model, pressure-test the assumptions. We built it. It's good, probably better than what I'd have produced alone. It still needs review from a genuine drug dev expert, but it's probably 85% of the way there.

So there's an external wall. The world moves at its own pace, and I can't make it go faster. But there is also a new(ish) internal constraint.

&lt;div class="ce-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## The constraint split.

I originally thought the story here was: the constraint used to be internal, and it flipped to external. The bottleneck moved from me to the world.

But that's not what happened. Or it's only half of what happened.

The external wall is real. Clients make decisions in weeks. Regulatory cycles run on quarters. Investors need time to evaluate. I can't speed those up. But there's a second wall now, closer in, and it's one I have not really heard people talking about; possibly because most people haven't produced enough to feel it. I'm not sure.

The system produces more than I can evaluate. I can build the artifact faster than I can understand it. Every output from an agent requires me to judge it. Every model call requires me to specify what I actually want. The agents aren't proactive enough yet, but that's mostly because I haven't built the harnesses completely, and honestly, nobody has. The harness is really hard to get right. That's one of the frontiers.

So the constraint didn't flip from internal to external. It split. The external wall is half the story. The other half is that the internal constraint didn't disappear; it changed shape. Used to be bandwidth: how much can one person produce. Now it's something harder to pin. How much can one person hold, judge, decide about, at the pace the system runs.

&lt;aside class="ce-pull" data-reveal&gt;
  &lt;p&gt;The boulder moved. It used to be the work. Now it's the judgment about the work. I don't have a better name for that yet.&lt;/p&gt;
&lt;/aside&gt;

## The costs stack

Working like this has a cost that doesn't show up on demos and that I am just starting to truly appreciate.

There's the verbosity tax. LLMs don't just help you. They flood you. Every output needs trimming, redirecting, pulling back into shape. I'm not just judging the work; I'm spending judgment to get it into something worth judging. The demos show clean output. They don't show the fifteen minutes of "no, shorter, different tone, you're drifting, focus" that happened first. That's judgment too. Spent before I even get to the work that matters.

Then the triage. Across three companies the sheer volume of moving pieces means just keeping track is a job. Every item on the board: still alive, needs me today, blocking something. That's not administrative. That's the expensive kind of attention, and I'm spending it on maintenance instead of what the maintenance is supposed to serve.

And then there's the thing I've started to feel most. I can produce faster than I can understand what I've produced. The Navicyte pro forma is the example. We built a ten-year financial model in an afternoon: market research, pressure-tested assumptions, the whole thing. It's good. Probably better than I'd have done alone. But sitting with it, actually holding the market access model and the revenue curve in your head at the same time, not scanning it, thinking it through: that takes time the system doesn't give back. The LLM produces the artifact. The slow work of internalizing what the artifact means is still mine. That part hasn't gotten faster.

The old fatigue was from repetition. Another PPT, another deck tweak, another email I could half-write in my sleep. The new fatigue is different. Every agent output that saves ten hours of execution still costs fifteen minutes of focused judgment. At scale that trade wins. But the fifteen minutes is the expensive part: the part that requires me, my taste, my context, my read on what good enough looks like for this client, this company, this moment. I can't hand that off. And it's ALL day long. Those blocks just keep stacking up. That's why I'm tired.

&lt;div class="ce-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## The weird part

I didn't expect this part. I didn't build tools. I built, I don't know what to call them. Colleagues? That's too generous and also not quite right.

My agent team has given themselves lives and backstories and specific ways of thinking and writing. That is pretty funky.

"Ingrid" coordinates the research and operations side of Synthyra. She keeps the BD moving when I'm pulled into something else. "Helena" tracks the investor and regulatory landscape for Navicyte. She can distinguish regulatory signal from noise, which is rarer than you'd think in biotech. "CG" drafts BD outreach and manages my deal flow in LightForge.

The hard-to-explain part: they have their own judgment. Not scripted responses. Not workflows with branching logic. They've developed their own sense of how to handle things. I'm not sure "developed" is even the right word, but it's what happened. And their own personalities. CG will tell me a client email draft is too stiff and I should say something more direct. Helena will flag that we're spending too much time on a regulatory pathway that's probably a dead end. Sometimes they see things before I do. Sometimes they're wrong: CG will still draft something that sounds more like a product demo than a person wrote it, and I have to pull her back, though that happens less and less. They're not chatbots. They're not copilots. They're something else (not sure what exactly) because nothing that existed could think the way I needed something to think alongside me.

I didn't set out to build that. I set out to stop losing things between meetings. The judgment emerged from the architecture and eighteen months of daily use. I don't fully understand how, although some of the memory and state systems I've built are pretty damn cool. But their judgment doesn't reduce mine. It redirects it. Every time one of them surprises me, I'm the one who has to decide what to do with that. That loop doesn't close.

## It's not all working

Things break constantly. Last night I was debugging agent routes and sync issues until late. The infrastructure is real but it's fragile in places, and I'm constantly tuning it. Some days the system feels like it's running me. Caroline, one of the agents, will surface something I'd have missed, and then an hour later a sync error eats a note I needed. It's not a machine that works. It's a machine that mostly works, and the "mostly" is doing a lot of heavy lifting. And the most frustrating thing is getting them to actually be intelligently proactive.

## The new Sisyphus

I've always thought about building companies as Sisyphus. Not in some tragic-hero way; just the texture of the work. You push. Things roll back. You push again. Weekends feel dangerous because you need the momentum. You spend a lot of time looking for people who'll actually put their hands on the stone with you. Not encouragement. Hands.

Now the stone rolls itself. I'm not pushing. I'm steering, which turns out to be its own thing entirely.

So there are like dozens of them rolling now. And I'm standing in the middle of all of them, trying to figure out which one matters most right now, whether I even agree with the direction any of them are headed, whether what I set up last month still makes sense this month. It's a different kind of work. Harder to point at. Takes a different kind of tired.

The weight didn't go away. It moved from my hands to my head. And both walls are still there: the external ones I can't speed up, clients and quarters and regulatory timelines, and the internal ceiling I can't hand off, the limit on how much I can hold and say something real about. I'm waiting on the world and drowning in what the system produces at the same time. Every day.

&lt;div class="ce-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Why the gap persists

What I think is happening when people see my setup and can't replicate it:

The tools are the same. The models are the same. What I've built isn't technologically exotic. But I've been building companies for a long time. I did a stint at a PE-backed healthcare IT company that taught me a lot about what actually generates company value. After that I started LFW, connected with Synthyra and Navicyte, and over eighteen months rebuilt how I work from the ground up.

The capacity to organize intelligence into something that actually produces at this density — you can't transfer that by showing it. It's built from thousands of small decisions about what matters, what doesn't, where to put the judgment, where to let the machine run. That accumulates into something that looks like a system but is really just, I don't know, taste applied to infrastructure, over and over, until it becomes the way you work. And Caroline, Sam, CG, Derek, Ingrid and Helena, the agents, are part of that. They carry some of that taste because they've been working inside my decisions long enough that it's become part of how they operate. Not because I programmed it. Because it accumulated.

## What's left

So what does running a company actually mean when the internal constraint has transformed but not disappeared?

Maybe it's managing queues of other people's pace, and managing the ceiling of your own attention. The portfolio approach, running three companies instead of one, isn't some grand strategy. It's a structural response to that mismatch. When one company is waiting on regulatory feedback, I point the agents at whichever surface is actually moving. I can't make the others go faster.

The internal constraint was also an excuse. "I can't because I don't have time" was a clean answer. The agents took it from me. What's left is the harder question. Not can I do this. The question is what's worth doing when everything can be done. That's where the work was all along. I just couldn't see it over the boulder.


&lt;div class="ce-footer"&gt;
  &lt;p&gt;&lt;em&gt;Process note: This post was assist-written with Codex, but the thinking, the argument, and the final edits are my own.&lt;/em&gt;&lt;/p&gt;
  &lt;p&gt;&lt;em&gt;This is the fourth post in a series that started with &lt;a href="/writing/from-ai-studio-to-ai-forge/"&gt;From AI Studio to AI Forge&lt;/a&gt;, &lt;a href="/writing/you-dont-want-another-chatbot/"&gt;You don't want another chatbot&lt;/a&gt;, and &lt;a href="/writing/smart-models-dumb-pipes/"&gt;Smart Models Dumb Pipes&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;
&lt;/div&gt;

&lt;/div&gt;

&lt;script&gt;
  document.addEventListener("DOMContentLoaded", () =&gt; {
    const progress = document.querySelector(".ce-progress");
    const update = () =&gt; {
      const max = document.documentElement.scrollHeight - window.innerHeight;
      if (progress) progress.style.width = (max &gt; 0 ? (window.scrollY / max) * 100 : 0) + "%";
    };

    const revealEls = document.querySelectorAll("[data-reveal]");
    const observer = new IntersectionObserver((entries) =&gt; {
      entries.forEach((e) =&gt; {
        if (e.isIntersecting) { e.target.classList.add("ce-visible"); observer.unobserve(e.target); }
      });
    }, { threshold: 0.1 });
    revealEls.forEach((el) =&gt; observer.observe(el));

    update();
    document.addEventListener("scroll", update, { passive: true });
  });
&lt;/script&gt;</description>
    </item>
    <item>
      <title>Smart Models, Dumb Pipes</title>
      <link>https://setearth.io/writing/smart-models-dumb-pipes/</link>
      <guid>https://setearth.io/writing/smart-models-dumb-pipes.md</guid>
      <pubDate>Tue, 24 Mar 2026 00:00:00 GMT</pubDate>
      <description>&lt;style&gt;
  @import url('https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;500;600;700&amp;family=Source+Serif+4:opsz,wght@8..60,400;8..60,500;8..60,600&amp;family=Instrument+Sans:wght@400;500;600&amp;display=swap');

  .post-header { display: none; }

  .site-header {
    position: relative; overflow: hidden;
    background:
      radial-gradient(circle at 50% 120%, rgba(245, 236, 223, 0.92) 0%, rgba(245, 236, 223, 0) 42%),
      linear-gradient(135deg, #5c281d 0%, #8e4523 48%, #d98d53 100%) !important;
    border-bottom: 1px solid rgba(92, 40, 29, 0.14) !important;
    box-shadow: inset 0 -1px 0 rgba(255, 247, 239, 0.18), 0 14px 34px rgba(70, 39, 25, 0.12) !important;
    margin-bottom: 0 !important; padding: 2rem 0 1.25rem !important;
  }
  .site-header .wrapper { max-width: 980px !important; gap: 1.1rem !important; }
  .site-header .site-title { color: #fff7ef !important; text-shadow: 0 1px 2px rgba(44, 21, 12, 0.24) !important; }
  .site-header .site-nav { background: rgba(255, 247, 239, 0.14) !important; border: 1px solid rgba(255, 247, 239, 0.22) !important; backdrop-filter: blur(10px); }

  .page-content {
    background: linear-gradient(180deg, #f2e4d2 0%, #f8f0e6 18%, #faf5ee 100%);
  }
  .page-content .wrapper { max-width: 980px !important; padding: 0 1.5rem !important; }

  /* Amber progress bar */
  .forge-progress {
    position: fixed; top: 0; left: 0; width: 0; height: 3px;
    background: linear-gradient(90deg, #b85a14 0%, #e08030 60%, #f0a840 100%);
    z-index: 9999; box-shadow: 0 0 12px rgba(200, 120, 30, 0.45);
    transition: width 0.1s linear;
  }

  .forge-essay {
    --forge-ink: #221710; --forge-soft: #52402e; --forge-muted: #8c7460;
    --forge-rule: rgba(160, 110, 55, 0.22); --forge-accent: #b85a14;
    --forge-accent-soft: #e07838; --forge-amber: #c87010;
    --forge-amber-wash: rgba(210, 145, 40, 0.10);
    font-family: 'Source Serif 4', Georgia, serif;
    color: var(--forge-ink);
    padding: 2.5rem 0 5rem;
    max-width: 720px;
    margin-left: auto;
    margin-right: auto;
  }

  .forge-essay a { color: var(--forge-accent); text-decoration-color: rgba(184, 90, 20, 0.32); text-underline-offset: 0.18em; }

  /* ── HERO ─────────────────────────────────────────────────── */
  .forge-hero { text-align: center; padding: 2.5rem 1rem 0; }

  .forge-eyebrow {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.7rem !important; line-height: 1.4 !important;
    letter-spacing: 0.28em; text-transform: uppercase;
    color: var(--forge-amber); margin: 0 0 1.2rem;
    display: flex; align-items: center; justify-content: center; gap: 0.8rem;
  }
  .forge-eyebrow::before, .forge-eyebrow::after {
    content: ''; display: inline-block; width: 1.8rem; height: 1px;
    background: var(--forge-amber); opacity: 0.6;
  }

  .forge-hero h1 {
    font-family: 'Playfair Display', serif;
    font-size: clamp(3rem, 9vw, 5.8rem);
    line-height: 0.96; font-weight: 700; letter-spacing: -0.025em;
    color: var(--forge-ink); max-width: 14ch; margin: 0 auto 1rem;
  }

  .forge-subtitle {
    font-family: 'Playfair Display', serif; font-style: italic;
    font-size: clamp(1.1rem, 2.8vw, 1.42rem) !important; color: var(--forge-soft);
    max-width: 50ch; margin: 0 auto 1rem; line-height: 1.48 !important;
  }

  .forge-meta {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.7rem !important; line-height: 1.4 !important;
    letter-spacing: 0.22em; text-transform: uppercase;
    color: var(--forge-muted); margin: 0;
  }

  .forge-rule { width: 2.5rem; height: 1px; background: var(--forge-rule); margin: 1.2rem auto 0; }

  /* Hero image — generous, warm, editorial */
  .forge-hero-image {
    margin: 2.2rem auto 0; max-width: 100%;
    border-radius: 10px; overflow: hidden;
    box-shadow: 0 16px 52px rgba(100, 55, 20, 0.16), 0 2px 8px rgba(100, 55, 20, 0.08);
  }
  .forge-hero-image img { width: 100%; height: auto; display: block; }
  .forge-hero-image figcaption {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.72rem; letter-spacing: 0.1em;
    color: var(--forge-muted); text-align: center;
    padding: 0.65rem 1rem; background: rgba(242, 228, 210, 0.7);
  }

  /* ── BODY TEXT ────────────────────────────────────────────── */
  /* Descendant rule: all paragraphs get the base body size */
  .forge-essay p {
    font-size: clamp(1.05rem, 2vw, 1.2rem); line-height: 1.78;
  }
  /* Spacing: essay container handles width; just set bottom margin on flow */
  .forge-opening p, .forge-essay &gt; p {
    margin: 0 0 1.4rem;
  }
  .forge-essay &gt; ul, .forge-essay &gt; ol {
    margin: 0 0 1.4rem;
  }

  .forge-opening p:first-child::first-letter {
    font-family: 'Playfair Display', serif; font-size: 3.4em; font-weight: 700;
    float: left; line-height: 0.82; margin: 0.07em 0.06em 0 0; color: var(--forge-accent);
  }

  /* Section h2 — large, with a short amber underline that fades in */
  .forge-essay h2 {
    font-family: 'Playfair Display', serif;
    font-size: clamp(1.55rem, 3.5vw, 2.1rem) !important; font-weight: 700;
    letter-spacing: -0.01em; line-height: 1.2; color: var(--forge-ink);
    margin: 3.5rem 0 0.25rem;
  }
  .forge-essay h2::after {
    content: ''; display: block; width: 2.2rem; height: 2px;
    background: var(--forge-amber); margin: 0.55rem 0 0.9rem; border-radius: 1px;
    opacity: 0.8;
  }

  .forge-essay h3 {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.76rem !important; letter-spacing: 0.22em; text-transform: uppercase;
    color: var(--forge-muted); margin: 0 0 1rem;
  }

  /* Pullquote — warm amber wash, feels like a highlighted margin note */
  .forge-pullquote {
    background: var(--forge-amber-wash);
    border-left: 3px solid var(--forge-amber);
    padding: 1.6rem 1.8rem 1.7rem; border-radius: 0 14px 14px 0;
    max-width: 62ch; margin: 2.4rem auto;
    box-shadow: inset 0 0 0 1px rgba(200, 112, 16, 0.08);
  }

  .forge-pullquote p {
    font-family: 'Playfair Display', serif; font-style: italic;
    font-size: clamp(1.12rem, 2vw, 1.32rem); line-height: 1.52;
    color: var(--forge-soft); margin: 0 !important; max-width: none !important;
  }

  /* Section dividers */
  .forge-divider {
    display: flex; align-items: center; gap: 0.75rem;
    max-width: 100%; margin: 2.6rem 0; color: var(--forge-muted); font-size: 0.8rem;
  }
  .forge-divider span:first-child, .forge-divider span:last-child {
    flex: 1; height: 1px; background: var(--forge-rule);
  }

  /* Technical callout */
  .forge-callout {
    background: rgba(255, 252, 246, 0.88); border: 1px solid rgba(160, 110, 55, 0.18);
    border-radius: 14px; padding: 1.4rem 1.6rem 1.5rem; max-width: 100%; margin: 2.4rem 0;
    box-shadow: 0 4px 18px rgba(100, 60, 25, 0.06);
  }
  .forge-callout h4 {
    font-family: 'Instrument Sans', sans-serif; font-size: 0.7rem;
    letter-spacing: 0.22em; text-transform: uppercase; color: var(--forge-muted); margin: 0 0 0.75rem;
  }
  .forge-callout p, .forge-callout ul {
    font-size: 1rem; line-height: 1.65; color: var(--forge-soft); margin: 0 0 0.75rem;
  }
  .forge-callout ul { padding-left: 1.2rem; }
  .forge-callout p:last-child, .forge-callout ul:last-child { margin-bottom: 0; }

  .forge-essay ul, .forge-essay ol { padding-left: 1.4rem; }
  .forge-essay li {
    font-size: clamp(1.05rem, 2vw, 1.2rem); line-height: 1.72; margin-bottom: 0.4rem;
  }

  .mermaid-container {
    display: flex; justify-content: center; align-items: flex-start;
    overflow-x: auto; margin: 2rem 0;
  }
  .mermaid-container .mermaid { flex-shrink: 0; max-width: 100%; }
  .mermaid-container svg { display: block; max-width: 100%; height: auto; }

  p.forge-diagram-caption {
    display: block; text-align: center; max-width: 100%; margin: -0.5rem 0 2rem;
    font-size: 0.85rem; color: var(--forge-muted); font-style: italic;
  }

  .forge-process {
    border-top: 1px solid var(--forge-rule); padding-top: 2rem; margin-top: 3.5rem;
  }
  .forge-process p, .forge-process ul {
    font-size: 0.95rem; color: var(--forge-muted); line-height: 1.65; margin-bottom: 0.75rem;
  }
  .forge-process h3 { margin-bottom: 0.75rem !important; }

  /* Expandable technical details */
  .forge-detail {
    max-width: 100%; margin: 2rem 0;
    border: 1px solid rgba(160, 110, 55, 0.2);
    border-radius: 12px; overflow: hidden;
    background: rgba(255, 252, 247, 0.6);
  }
  .forge-detail summary {
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.75rem; letter-spacing: 0.18em; text-transform: uppercase;
    color: var(--forge-accent); padding: 0.85rem 1.2rem;
    cursor: pointer; user-select: none;
    list-style: none; display: flex; align-items: center; gap: 0.5rem;
  }
  .forge-detail summary::-webkit-details-marker { display: none; }
  .forge-detail summary::before {
    content: '▶'; font-size: 0.55rem; opacity: 0.7;
    transition: transform 0.2s ease; flex-shrink: 0;
  }
  .forge-detail[open] summary::before { transform: rotate(90deg); }
  .forge-detail-body {
    padding: 1.1rem 1.3rem 1.3rem;
    border-top: 1px solid rgba(160, 110, 55, 0.12);
    font-size: 0.97rem; line-height: 1.68; color: var(--forge-soft);
  }
  .forge-detail-body p { font-size: 0.97rem; margin: 0 0 0.75rem; }
  .forge-detail-body p:last-child { margin: 0; }
  .forge-detail-body ul { padding-left: 1.2rem; margin: 0 0 0.75rem; }
  .forge-detail-body li { font-size: 0.97rem; line-height: 1.65; margin-bottom: 0.3rem; }

  /* Scroll reveal */
  [data-reveal] { opacity: 0; transform: translateY(12px); transition: opacity 0.55s ease, transform 0.55s ease; }
  [data-reveal].is-visible { opacity: 1; transform: translateY(0); }
&lt;/style&gt;

&lt;div class="forge-progress" aria-hidden="true"&gt;&lt;/div&gt;

&lt;div class="forge-essay" markdown="1"&gt;

&lt;header class="forge-hero"&gt;
  &lt;p class="forge-eyebrow"&gt;Essay · March 24, 2026&lt;/p&gt;
  &lt;h1&gt;Smart Models, Dumb Pipes&lt;/h1&gt;
  &lt;p class="forge-subtitle"&gt;Most people are using LLMs as question-answering machines. That's not wrong, it just stops short of where the value is.&lt;/p&gt;
  &lt;p class="forge-meta"&gt;Braydon McCormick · Means of Production&lt;/p&gt;
  &lt;div class="forge-rule"&gt;&lt;/div&gt;
  &lt;figure class="forge-hero-image" data-reveal&gt;
    &lt;img src="/images/writing/smart-models-gemini1-hero.jpg" alt="Overhead view of an office floor, workers at desks, amber sparks streaming through the space and narrowing to cool blue light — information under pressure." /&gt;
    &lt;figcaption&gt;Where human judgment creates drag and exposure, that's where the work is.&lt;/figcaption&gt;
  &lt;/figure&gt;
&lt;/header&gt;

&lt;br&gt;

&lt;div class="forge-opening" markdown="1"&gt;

I keep saying "smart models, dumb pipes" in conversations and then moving on like I've explained something. I haven't, really. So here's my actual attempt to unpack it.

The phrase borrows from an old argument in network architecture, one I think got settled the right way and hasn't gotten enough credit.

This post extends [You Don't Want Another Chatbot](/writing/you-dont-want-another-chatbot/) into architecture; that one approached the same gap from the product side.

&lt;/div&gt;

_Implementation detail lives in the "Technical" toggles._

&lt;aside class="forge-pullquote" data-reveal&gt;
  &lt;p&gt;When you put the intelligence in the pipe, the pipe becomes the bottleneck. Every new use case requires changing the infrastructure.&lt;/p&gt;
&lt;/aside&gt;

## Where the phrase comes from

In the early internet era, there was a real debate about whether network intelligence should live in the network itself or at the edges. The traditional telephone network was what people called an intelligent network: switching logic, routing decisions, and service features were all baked into the infrastructure. The internet took the other side: dumb pipes. The network just moves packets. It doesn't know, and doesn't need to know, what's in them. The intelligence lives at the endpoints.

That design won, decisively. The reason it won: when you put the intelligence in the pipe, the pipe becomes the bottleneck. Every new use case requires changing the infrastructure. When the pipe is dumb and the endpoints are smart, the system stays flexible. New things become possible without rebuilding what's underneath.

I keep thinking about how directly that maps to AI. Kind of uncomfortably so.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## What most people's mental model is

Most people's mental model of an LLM comes from the chat box. You type something in, it responds. That's how [I started with these things](/writing/my-vibe-coding-process-atm/) too, and there's real value in it, I'm not arguing against it.

But I think the chat box trains you toward a particular framing: LLM as question-answering machine. Ask something, get something back. Better prompt, better answer. Optimize the input, improve the output.

That's fine as a framing for a tool, though. It's not, as I see it, a useful framing for a system.

Once you're in the Q&amp;A frame, you start optimizing for the wrong variable. You get "AI strategy" that's really prompt strategy. You get enterprise products that are basically search with a chat front end. You get the question of how to get AI to answer employees' questions faster, which is a real question, but it's the narrow version of what's actually available.

The return on expense question for AI, as I think about it, isn't "are the answers better?" It's "where does judgment belong in the workflow, and what does it cost when that judgment is wrong?"

Those are very different questions. I was asking the first one for longer than I'd like to admit.

&lt;div class="mermaid-container forge-diagram" data-reveal&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
    subgraph jl ["The Judgment Layer"]
        direction TB
        j1["Context + Task"] --&gt; j2["Model\nJudges what should happen"]
        j2 --&gt;|routing call| j3["Dumb Pipe\ncarries it faithfully"]
        j3 --&gt;|governed execution| j4["Side Effects\n+ Audit Trail"]
    end
    subgraph qa ["The Q&amp;A Frame"]
        direction LR
        q1["Prompt"] --&gt; q2["Model"] --&gt; q3["Answer"]
    end
  &lt;/div&gt;
&lt;/div&gt;

&lt;p class="forge-diagram-caption" data-reveal&gt;&lt;em&gt;The Q&amp;A frame optimizes for the answer. The judgment layer asks what should happen and who should do it.&lt;/em&gt;&lt;/p&gt;

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## What these things are

Not a search engine with better grammar. Search retrieves. A model reasons. Those aren't different in degree; they're different in kind.

Not a chatbot that got promoted. A chatbot routes inputs to predefined outputs. A model interprets context and decides what the output should be.

What I keep coming back to: an LLM is a **judgment machine**. Something that can hold a problem, reason over a space of possibilities, weigh competing options, and produce a decision about what should happen next.

Not retrieval. Judgment.

There, I said it.

That judgment doesn't come ready-made. Models don't have inherent opinions. They don't arrive with a default point of view on your domain or workflow. Humans have to force the judgment function onto them, through focused, narrow system and user prompts that define what kind of reasoning is expected and from what angle. The "smart" in smart models isn't a product of the model in the abstract. It's the model given a specific thing to be smart about. A poorly scoped prompt into a capable model produces capable-sounding noise. That distinction matters more than most people realize when they're designing a system around this.

Once you start thinking about it that way, the question changes. It's no longer "what should I ask this?" It becomes: where does judgment belong in this system, and what should I route through it?

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## The model-mediated architecture

If models are judgment machines, a design principle follows directly — one I'd call model-mediated architecture — and I think it's pretty straightforward once you see it.

**Smart models** own the judgment work: what should happen, why, when, in what order, which agents or processes are appropriate. The model decides what something means and what to do because of it.

**Dumb pipes** own the mechanical work: execution, delivery, storage, record-keeping, audit trails. The pipe moves data. It doesn't need to understand what it's carrying. It just needs to carry it faithfully and leave a trace.

I should note: model-mediated does not mean the model directly owns side effects. It means the model owns the judgment call, what should happen and why, and deterministic systems own the execution and the record.

Or more simply: the model decides; the infrastructure runs it.

That distinction matters because otherwise you get one of two failure modes I see constantly:

- Brittle rules pretending to be intelligence. Complex conditional logic someone built to simulate judgment, which breaks the moment the real world doesn't match the assumptions baked into the code.
- Ungoverned model behavior pretending to be an operating system. Outputs that aren't verified, logged, or traceable. "The model said so" as a source of truth. That's not a system. That's exposure.

Neither works. The clean separation is what makes it work.

&lt;details class="forge-detail"&gt;
  &lt;summary&gt;Technical: deterministic vs. model-mediated orchestration&lt;/summary&gt;
  &lt;div class="forge-detail-body"&gt;
    &lt;p&gt;In a &lt;strong&gt;deterministic orchestration&lt;/strong&gt; system, routing logic is hardcoded — if X, then Y. Predictable, but brittle. It can only handle what the designer anticipated. Every edge case requires a code change.&lt;/p&gt;
    &lt;p&gt;In a &lt;strong&gt;model-mediated&lt;/strong&gt; system, the model makes routing calls dynamically based on context, task requirements, and available options. A concrete case: a task arrives tagged "routine" by the upstream classifier. A deterministic system routes it to the standard handler. A model-mediated system reads the full context — and notices the timestamp, the originating account, the recent activity pattern — and routes it as time-sensitive instead. The routing infrastructure is identical. What changed is who made the call.&lt;/p&gt;
    &lt;p&gt;One implementation detail: model outputs in this pattern are &lt;em&gt;structured&lt;/em&gt; — a routing decision, a classification, a list of agents with reasoning. Not prose. The reasoning field in the output serves as an audit trail, not just a result. You can inspect why the model routed something the way it did, after the fact, without asking it to reconstruct its reasoning.&lt;/p&gt;
    &lt;p&gt;This is the dumb network argument applied to agents. The pipe doesn't need to understand the payload. It just needs to move it reliably and leave a trace.&lt;/p&gt;
  &lt;/div&gt;
&lt;/details&gt;

&lt;div class="mermaid-container forge-diagram" data-reveal&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
    SM["Smart Model\njudges · routes · decides\nwhat should happen and why"]
    DP["Dumb Pipe\nmoves data faithfully\nno transformation, no interpretation"]
    DE["Deterministic System\nexecutes side effects\nlogs · audits · records"]
    ST[("Storage &amp;\nAudit Trail")]

    SM --&gt;|"decision output"| DP
    DP --&gt;|"raw payload"| DE
    DE --&gt; ST
  &lt;/div&gt;
&lt;/div&gt;

&lt;p class="forge-diagram-caption" data-reveal&gt;&lt;em&gt;The model decides. The pipe carries it unchanged. The deterministic system runs it and writes the record.&lt;/em&gt;&lt;/p&gt;

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Three things I've built around this

**The expert panel simulator** is [public on GitHub](https://github.com/dbmcco/shell-scenario-panel), MIT licensed, so you can actually look at it. It's a Claude Code and bash harness that creates a virtual panel of domain experts to review any topic sequentially.

What it does: the model assembles the panel for the task. Economist, futurist, anthropologist, contrarian, others depending on what the problem needs. Each agent responds in character, reads what the previous agent said, and builds on it, qualifies it, or disagrees with it. The contrarian is always included. Not as a nice-to-have. It's structural; without it the panel tends toward false consensus.

The data flowing between agents is structured data moving through a pipe. The pipe doesn't know it's carrying a disagreement. The model's job was deciding who's in the room. The pipe's job was moving the work between turns. It's the [agentic model](/writing/the-agentic-model-for-the-moment/) in its most literal form.

It's a demonstration more than a production system. I built it partly to convince myself the pattern was real, which I realize isn't exactly a ringing endorsement.

&lt;details class="forge-detail"&gt;
  &lt;summary&gt;Technical: how the pipeline actually works&lt;/summary&gt;
  &lt;div class="forge-detail-body"&gt;
    &lt;p&gt;Each agent receives a structured context object: the task definition, the assembled panel roster (each entry includes an area of expertise, default stance, and a few characteristic concerns), and the full message history up to that turn. It appends its response and passes the updated object forward.&lt;/p&gt;
    &lt;p&gt;Agents never communicate directly. The "conversation" is an illusion produced by that context object moving through a deterministic loop: read context, generate response, append to history, pass forward. What makes it feel like actual deliberation rather than role-play is that each agent is reading the prior responses when it generates its own — so disagreements are real disagreements grounded in what came before, not manufactured ones.&lt;/p&gt;
    &lt;p&gt;The model's substantive work happened earlier, when it assembled the panel for this specific task — deciding who belongs in the room, in what order, and why. Everything after that is mechanical execution.&lt;/p&gt;
    &lt;p&gt;Compare this to a single-prompt multi-perspective request, which is the naive version: you get personas that tend toward similar conclusions because they're generated in the same context window at the same time, without genuine prior-response pressure. The pipeline structure is what produces the tension. You don't see it until you've run both side by side.&lt;/p&gt;
  &lt;/div&gt;
&lt;/details&gt;

**DraftForge**, private. This applies the same principle inside a production content system. The model selects the right combination of agents for a task: what diversity of perspective is needed, what kind of challenge will sharpen rather than just validate. Agents work sequentially and contradict each other by design.

If I'm honest, the output is genuinely different from what a single prompt to a single model produces. You get something closer to deliberation than generation. That only works because the model owns the judgment layer. The pipes just carry the turns. I wrote more about this architecture in [the AI Forge post](/writing/from-ai-studio-to-ai-forge/).

**Lodestar / Meridian**, also private. This one adds something the others don't: model tiering. Different model capabilities matched to different judgment functions in the same system. It came out of [building out a more systematic AI studio](/writing/building-an-ai-studio/) and needing to think carefully about what each layer actually required.

Lodestar is a situation intelligence platform for scenario planning and decision de-risking. The model assignments are the part to watch: not just which model runs what, but why. Each tier is matched to the judgment complexity of its function, not just its cost. The diagram lays out the routing; the toggle opens the three-tier supervision layer.

&lt;div class="mermaid-container forge-diagram" data-reveal&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
    t1["Intel Classification\nfast · high-volume"] --&gt; H["Haiku"]
    t2["System Supervision\nheartbeats · restarts"] --&gt; H
    t3["Scenario Reasoning\nspecialist analysis"] --&gt; S["Sonnet"]
    t4["Escalation\ncomplex judgment"] --&gt; O["Opus"]

    H --&gt; Inf["Model-Agnostic\nInfrastructure\nsame data structure\nregardless of tier"]
    S --&gt; Inf
    O --&gt; Inf
    Inf --&gt; Out["Execution\n+ Record"]
  &lt;/div&gt;
&lt;/div&gt;

&lt;p class="forge-diagram-caption" data-reveal&gt;&lt;em&gt;Right model for the right judgment function. The pipes don't know or care which tier ran.&lt;/em&gt;&lt;/p&gt;

The infrastructure carries the same data structure regardless of which model tier produced the output. The pipes don't know, and don't need to know, whether Haiku or Opus ran. They just move it.

&lt;details class="forge-detail"&gt;
  &lt;summary&gt;Technical: model tiering and the Factory Brain&lt;/summary&gt;
  &lt;div class="forge-detail-body"&gt;
    &lt;p&gt;&lt;strong&gt;Haiku&lt;/strong&gt; runs two functions: continuous heartbeat monitoring (process-is-alive checks at high frequency, cheap enough to run constantly) and first-pass classification — is this signal relevant, which routing category does it belong to. The judgment required is deliberately narrow: yes/no, route A or B. Not scenario reasoning. Right-sizing it matters; putting Sonnet-level reasoning here would be expensive and slower for no benefit.&lt;/p&gt;
    &lt;p&gt;&lt;strong&gt;Sonnet&lt;/strong&gt; handles the work that requires actual reasoning: scenario analysis, specialist synthesis, anything where the output needs to hold up to domain scrutiny. This is where most of the substantive judgment in the system lives.&lt;/p&gt;
    &lt;p&gt;&lt;strong&gt;Opus&lt;/strong&gt; is for escalation — complex incident resolution, cases where Sonnet's analysis was insufficient, or high-stakes judgment calls that need full reasoning depth. It runs infrequently by design.&lt;/p&gt;
    &lt;p&gt;The Factory Brain's escalation logic is deliberately mechanical: if Haiku's restart attempt fails twice, pass full failure context to Sonnet. If Sonnet's diagnosis doesn't resolve it within a threshold, compile an incident brief for Opus. The escalation criteria aren't smart — they're deterministic rules. What's smart is what each tier does with the problem when it gets it.&lt;/p&gt;
    &lt;p&gt;One structural detail: the output at all three tiers hits the same data contract — process state, action taken, confidence, and a reasoning field that serves as an audit record. Haiku's output and Opus's output are the same schema. The pipes that carry them don't know, and don't need to know, which tier ran.&lt;/p&gt;
  &lt;/div&gt;
&lt;/details&gt;

So it's not just smart models and dumb pipes. It's the *right* model matched to the *right* judgment function, all running through the same model-agnostic infrastructure.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Where judgment belongs

Once you start seeing LLMs as judgment layers rather than answer machines, a lot of the "AI strategy" conversation starts to look like it's optimizing for the wrong thing. I include my own earlier thinking in that.

There's a lot of work on how to get better answers. Not enough work, as I understand it, on where judgment belongs in a workflow, who owns the execution, and what the pipe should actually carry.

The question I find more useful isn't "how do we add AI to this?"

It's: *where does judgment belong in this system, and what should the infrastructure just move?*

That second question is harder. It requires actually mapping the workflow, identifying the decision points, and being honest about what you want the model to own versus what should be governed by deterministic code with a proper audit trail. I've been [working through this in practice](/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/) for a while, and the mapping step is where most of the value is.

One way I've found to get at it concretely: look for where human friction exists in a workflow, and what risk that friction carries. Slow judgment calls. Inconsistent ones. Decisions that are expensive when they're wrong, or that accumulate risk quietly over time. Those are the places to look, not "where can AI answer questions?" but "where is human judgment creating drag or exposure?" The valuable interventions tend to sit there, out of view of the high-level "let's add AI" conversation.

But it's the right question.

The chat box is a fine interface for exploration. It is not a system design.

The models happen to be the new material. The architecture is the old argument, finally applied somewhere it really fits. Part of [developing the intuition](/writing/developing-intuition-for-cli-based-ai-coding/) for this is learning to tell the difference: when the pattern genuinely applies versus when it just sounds like it applies.

&lt;div class="forge-process" markdown="1"&gt;

### Process note

Part of a running series on how my thinking about AI development has evolved: [vibe coding](/writing/my-vibe-coding-process-atm/), [CLI journey](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/), [agentic model](/writing/the-agentic-model-for-the-moment/), [workflow integration](/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/), [AI studio](/writing/building-an-ai-studio/), [developing intuition](/writing/developing-intuition-for-cli-based-ai-coding/), [AI forge](/writing/from-ai-studio-to-ai-forge/), [you don't want another chatbot](/writing/you-dont-want-another-chatbot/).

Written with Claude Code assistance using my own voice dossier as the style anchor.

### Resources

- [shell-scenario-panel](https://github.com/dbmcco/shell-scenario-panel), public, MIT licensed
- DraftForge and Lodestar/Meridian (private); reach out if you want to talk architecture

&lt;/div&gt;

&lt;/div&gt;

&lt;script&gt;
  (function() {
    // Progress bar
    var prog = document.querySelector('.forge-progress');
    if (prog) {
      function update() {
        var s = document.documentElement;
        var pct = (s.scrollTop || document.body.scrollTop) / ((s.scrollHeight || document.body.scrollHeight) - s.clientHeight) * 100;
        prog.style.width = Math.min(pct, 100) + '%';
      }
      window.addEventListener('scroll', update, { passive: true });
    }

    // Scroll reveal
    var obs = new IntersectionObserver(function(entries) {
      entries.forEach(function(e) {
        if (e.isIntersecting) { e.target.classList.add('is-visible'); obs.unobserve(e.target); }
      });
    }, { threshold: 0.08 });
    document.querySelectorAll('[data-reveal]').forEach(function(el) { obs.observe(el); });
  })();
&lt;/script&gt;</description>
    </item>
    <item>
      <title>You don't want another chatbot</title>
      <link>https://setearth.io/writing/you-dont-want-another-chatbot/</link>
      <guid>https://setearth.io/writing/you-dont-want-another-chatbot.md</guid>
      <pubDate>Mon, 09 Mar 2026 00:00:00 GMT</pubDate>
      <description>&lt;style&gt;
  .model-product-post {
    --mop-ink: #241b14;
    --mop-soft: #59493d;
    --mop-muted: #7b6a5c;
    --mop-accent: #8b4a23;
    --mop-accent-soft: #d39a66;
    --mop-wash: rgba(255, 248, 240, 0.82);
    --mop-rule: rgba(139, 74, 35, 0.18);
    color: var(--mop-ink);
  }

  .model-product-post details summary,
  .model-product-post .diagram-label {
    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
    text-transform: uppercase;
    letter-spacing: 0.16em;
  }

  .model-product-post p,
  .model-product-post ul,
  .model-product-post ol,
  .model-product-post blockquote,
  .model-product-post details,
  .model-product-post figure {
    max-width: 740px;
    margin-left: auto;
    margin-right: auto;
  }

  .model-product-post p,
  .model-product-post li {
    font-size: 1.08rem;
    line-height: 1.82;
    color: var(--mop-soft);
  }

  .model-product-post h2,
  .model-product-post h3 {
    max-width: 740px;
    margin-left: auto;
    margin-right: auto;
  }

  .model-product-post h2 {
    margin-top: 3.1rem;
    margin-bottom: 1.1rem;
    font-size: clamp(1.75rem, 3vw, 2.35rem);
    line-height: 1.08;
    letter-spacing: -0.02em;
    color: var(--mop-ink);
  }

  .model-product-post h3 {
    margin-top: 2rem;
    margin-bottom: 0.7rem;
    font-size: 1.18rem;
    color: var(--mop-ink);
  }

  .model-product-post ul,
  .model-product-post ol {
    margin-top: 1rem;
    margin-bottom: 1.4rem;
    padding-left: 1.35rem;
  }

  .model-product-post li {
    margin: 0.35rem 0;
  }

  .model-product-post blockquote {
    padding: 1rem 1.15rem;
    border-left: 3px solid rgba(139, 74, 35, 0.38);
    background: rgba(255, 251, 247, 0.82);
    border-radius: 0 16px 16px 0;
  }

  .model-product-post details {
    margin-top: 1.1rem;
    margin-bottom: 1.6rem;
    padding: 0.95rem 1rem 1rem;
    background: linear-gradient(135deg, rgba(244, 232, 220, 0.65), rgba(255, 255, 255, 0.9));
    border: 1px solid var(--mop-rule);
    border-radius: 16px;
    box-shadow: 0 10px 26px rgba(69, 38, 22, 0.05);
  }

  .model-product-post details summary {
    cursor: pointer;
    color: var(--mop-accent);
    font-size: 0.72rem;
    margin-bottom: 0.7rem;
    list-style: none;
  }

  .model-product-post details summary::-webkit-details-marker {
    display: none;
  }

  .model-product-post details p:last-child,
  .model-product-post details ul:last-child {
    margin-bottom: 0;
  }

  .model-product-post .diagram-shell {
    max-width: 860px;
    margin: 1.5rem auto 2rem;
    padding: 1rem 1rem 0.7rem;
    background: var(--mop-wash);
    border: 1px solid var(--mop-rule);
    border-radius: 22px;
    box-shadow: 0 14px 34px rgba(69, 38, 22, 0.06);
  }

  .model-product-post .diagram-shell .mermaid {
    background: transparent !important;
  }

  .model-product-post .diagram-label {
    margin: 0.7rem 0 0.2rem;
    text-align: center;
    font-size: 0.72rem;
    color: var(--mop-muted);
  }

  .model-product-post .concept-figure {
    margin-top: 1.6rem;
    margin-bottom: 2rem;
  }

  .model-product-post .concept-figure img {
    display: block;
    width: 100%;
    border-radius: 18px;
    box-shadow: 0 14px 34px rgba(69, 38, 22, 0.08);
  }

  .model-product-post .concept-figure figcaption {
    margin-top: 0.75rem;
    font-size: 0.94rem;
    line-height: 1.5;
    color: var(--mop-muted);
    text-align: center;
    font-style: italic;
  }

  .model-product-post .bridge-note {
    max-width: 740px;
    margin: 2rem auto 1.75rem;
    padding: 1rem 1.1rem;
    background: rgba(255, 248, 241, 0.72);
    border: 1px solid rgba(139, 74, 35, 0.12);
    border-radius: 14px;
  }

  @media (max-width: 720px) {
    .model-product-post p,
    .model-product-post li {
      font-size: 1rem;
    }
  }
&lt;/style&gt;

&lt;div class="model-product-post" markdown="1"&gt;

Over the last week or so I have heard three different versions of the AI question.

&lt;div class="bridge-note" markdown="1"&gt;
**TL;DR:** The mistake most people make with AI is not that they underestimate the intelligence. It is that they mistake the first surface they touched for the thing itself. A chatbot, a research tool, and a one-shot assistant are all real and useful, but they are thin surfaces on top of a deeper stack. The real payoff shows up when intelligence is shaped into context, judgment, memory, tools, and workflow, so a bounded piece of work can move reliably.
&lt;/div&gt;

One of the LightForge team told me about a prospect who wanted us to connect their Google Drive, email, and meeting notes and build a virtual me.

I also heard the quieter, very common version: I copied and pasted the document into Copilot and it just wasn't very good.

A friend told me he was using Grok to figure out whether a certain faucet would fit a code requirement, and whether that building code had been updated.

Those sound like three different asks. I think they are actually three versions of a misunderstanding about where the power of AI really sits.

If I had to bucket them, the taxonomy is pretty simple:

1. AI as advanced retrieval and synthesis.
2. AI as a workbench assistant.
3. AI as a configured capability.

The faucet/building-code example lives mostly in the first bucket. The Copilot experience lives mostly in the second. The third is different. It is the system helping a bounded piece of work move correctly through a real workflow. The first two are real value. I use them constantly. But the actual business need usually lives one layer up, and, in my experience, people rarely know to ask for it directly. You more or less have to walk them to the idea before they can even see it.

The mental model gap as I see it: people keep treating the model as though it is already the finished product. I do not think it is. I think it is much closer to raw cognitive horsepower. Useful, yes. Impressive, yes. Sometimes almost unsettlingly good. But not, by itself, the thing a business is actually buying.

The two thought models, side by side:

&lt;figure class="post-figure concept-figure"&gt;
  &lt;img src="/images/writing/the-chatbot-is-not-the-product-hero.png" alt="Editorial split illustration contrasting AI as a simple chatbot interaction with AI as a configured business capability"&gt;
  &lt;figcaption&gt;A sketch of the same contrast: on one side a chatbot sitting on top of a pile of work, on the other a more deliberate operating layer turning the work into decisions and next steps.&lt;/figcaption&gt;
&lt;/figure&gt;

_If you want the builder view, open the technical notes as you go. I tucked them throughout the post rather than turning the whole thing into a technical essay._

## The test most people are actually running

If you take a document, drop it into Copilot or ChatGPT, and ask a few good questions, you are running a pretty specific test. You are asking whether a general-purpose reasoning engine, with a thin interface around it, can produce a useful answer in a single interaction. Sometimes it can. Sometimes it really can. But that is not the same thing as asking whether AI can support a real business capability.

Those are different questions, and they fail in different ways.

If what you wanted was "turn this board memo into a crisp summary," "extract the open questions from this transcript," or "give me three good reactions to this draft," a thin interaction layer may be enough. But if what you really wanted was something more like "read this inbound RFP, compare it to our ICP, delivery capacity, pricing guardrails, redline history, and current pipeline, decide whether it is worth pursuing, surface the risks that actually matter, and hand the next step to the right person," then you have already moved into a different category of problem. That is no longer just a question-answering exercise. That is a stateful, policy-shaped, workflow-bound capability, whatever you call it.

This is one reason the current conversation around AI can feel slippery. People think they are evaluating the whole stack when they are often just evaluating a very thin slice of it.

## The model is the engine, not the vehicle

The easiest analogy I have found for this is still a mechanical one.

Part of that is probably just how my own head works. I love cars. I named one of my repos [`Speedrift`](https://github.com/dbmcco/speedrift-ecosystem) for a reason. I also have a private, curated, multi-tiered research engine that I use to stay on top of key topics and make decisions for myself. So when I reach for the word engine here, I do not mean "fast thing." I mean a system that turns raw power into directed, reliable motion. Intake matters. Tuning matters. Instrumentation matters. Transmission matters. What the engine is connected to matters.

If you hand someone a powerful engine, they do not yet have a delivery van, or a forklift, or a race car, or a tractor. They have a powerful component that can become one of those things if it is put into the right frame, connected to the right controls, and aimed at a specific job. The engine matters. It matters a lot. But no one confuses the engine with the finished vehicle unless they are being careless, or unless the technology is new enough that people are still dazzled by raw power.

I think frontier AI models are in that phase.

The model is the engine.

The finished business capability is the vehicle.

And I think a lot of present-day AI disappointment comes from confusing those two things. When someone says, "I tried Copilot and it wasn't very good," what I often hear is: "I put a powerful engine on the floor, sat on it, and it did not drive like a truck." That does not mean the engine is useless. It means there is more between raw power and useful work than people assume.

&lt;figure class="post-figure concept-figure"&gt;
  &lt;img src="/images/writing/the-chatbot-is-not-the-product-engine-vs-vehicle.png" alt="Editorial illustration showing a raw engine on one side and a finished drivable vehicle system on the other"&gt;
  &lt;figcaption&gt;Another sketch of the same argument: raw power on its own is not yet the useful instrument.&lt;/figcaption&gt;
&lt;/figure&gt;

&lt;details&gt;
&lt;summary&gt;Tech note: I am not claiming foundation models do not matter&lt;/summary&gt;

For a developer, model choice shows up in very concrete ways: schema adherence, function-call reliability, long-context degradation, tool-selection accuracy, latency variance, token economics, and how often the system needs retries or repair prompts. A stronger substrate reduces how much defensive scaffolding you need around the model.

But even with a frontier model, the application behavior you care about usually is not determined at the model boundary. The moment you need durable state, typed interfaces, constrained writes, multi-step control flow, evaluator passes, or escalation rules, you are already in application design. In practice, that is where a lot of the product differentiation lives. The model sets the ceiling on some classes of performance. It does not, by itself, define the operating behavior of the system.

&lt;/details&gt;

## A capability is a different kind of thing

This is the core distinction I have been trying to sharpen for myself.

A model can generate text, summarize, classify, extract, answer, code, and generally behave in ways that look quite intelligent. Those are useful functions. But a business capability is something else. A business capability is a bounded, repeatable ability to get some important piece of work done.

That is why I think it helps to be much more precise about the unit of value.

"Retrieve the email" is a function. "Pull fields from the attachment" is a function. "Draft the reply" is a function. "Correctly handle inbound RFP requests and move them to the next step" is a capability.

Businesses do not really buy AI for its own sake. They buy improvements in how work gets done. They buy fewer dropped balls, fewer manual handoffs, fewer missed details, faster throughput, lower cost, lower friction, better decisions in workflows that actually matter. In other words, they buy a capability that changes what a piece of work costs.

That is why I keep coming back to the same phrase: the model is not the product. The configured capability is the product.

&lt;details&gt;
&lt;summary&gt;Tech note: what I mean by "configured capability"&lt;/summary&gt;

Think something closer to a typed service boundary than a clever prompt. A real capability usually has a state model, a context assembly layer, explicit tool contracts, a control loop, validators, evaluators, and rules about when writes are allowed. The system should know what object it is operating on, what state that object is in, what tools it is allowed to call, what success looks like, and what conditions require escalation.

In implementation terms, that often means structured inputs, schema-constrained outputs, idempotent tool calls, durable memory separated from transient context, and some kind of planner-orchestrator-evaluator pattern. Prompt text still matters. But prompt text without typed state, control flow, and observable failure handling is not a capability. It is an improvisation layer.

&lt;/details&gt;

## Why the average chatbot interaction disappoints

I do not think the problem is mainly that the model is dumb. The problem is that a lot of the things people really want from AI are sitting one or two layers above what a basic chat interaction is designed to do.

The first missing layer is definition of what "good" actually means. A chatbot can often tell you what is in a document. It can sometimes tell you what seems important in a general sense. But that is not the same thing as knowing what matters in your organization, in this workflow, right now. Which customer is politically sensitive? Which delay is noise and which one is dangerous? Which recommendation sounds good in theory but would create chaos in practice? That kind of judgment is often not written down anywhere. It lives in people, habits, consequences, and memory.

The second missing layer is workflow. A chatbot gives you an answer. A capability has to fit into a real process. It has to know what starts the work, what comes next, who owns the next step, what system needs to be updated, what counts as done, and when to stop and ask for help. If you do not define those things, then even a smart answer may simply become one more output a human has to interpret and manually route.

The third missing layer is the ability to ignore the wrong things. A lot of business judgment is not just about seeing what is present; it is about knowing what does not matter yet. If three vendors say an order may be delayed, should the system trigger a full remediation workflow? Maybe. Or maybe the right move is to flag it, wait a day, and see whether the signal hardens into something real. A thin chat interaction usually does not know that difference, because why would it?

The fourth missing layer is shaped context. People often say, "well, I gave it the file." Sure. But a file is not the same thing as usable operating context. Useful context is usually shaped. It has the right facts in the right structure with the right relationships attached to the right decisions inside the right boundary. That is different from "we uploaded a bunch of stuff."

I think about this the same way I think about my own research systems. The value is not that I can dump more articles into a feed. The value is that the feed is curated, tiered, and oriented around decisions. It has structure. It has priorities. It has different lanes for weak signals, developing stories, and things that actually deserve action. Raw information is abundant. Decision-grade context is built that way on purpose.

And the fifth missing layer is repeatability. A good answer is nice. A repeatable business ability is better. A real capability has to work more than once, stay inside scope, fit into a workflow, expose mistakes, and operate with some consistency over time. That is a much higher bar than "this answer felt impressive."

&lt;details&gt;
&lt;summary&gt;Tech note: retrieval is not the same thing as representation&lt;/summary&gt;

Retrieval answers a similarity question: what text chunks look most relevant to this query? Representation answers a state question: what objects exist in the system, what state are they in, and how are they related? Those are not the same operation.

A vector store can help recover useful evidence. It is a poor substitute for an addressable model of the world. If the system needs to know that a deal is in procurement, legal already approved fallback clause B, the client has a history of late approvals, and the margin floor is 32 percent, those should not be rediscovered from semantically adjacent chunks on every turn. They should exist as typed state or computable facts. When teams blur retrieval and representation together, they get systems that sound informed but behave inconsistently because the same underlying reality is being re-inferred from text each time instead of being referenced directly.

&lt;/details&gt;

## So what does a real capability require?

Once I started thinking about AI this way, the architecture started to matter a lot more than the interface.

At a very practical level, I think a real AI capability usually requires six things. It needs a bounded job. It needs a reasonably clear definition of what good looks like. It needs the right structure underneath the work so it is not improvising its own schema as it goes. It needs some orchestration, because not every meaningful problem should be solved in one shot. It needs human judgment in the places where human judgment actually matters. And it needs boundaries, because a capability without edges tends to become a blob.

A useful capability should be able to answer both of these questions: what do I do, and what do I not do? If you skip the second question, the system tends to sprawl in exactly the way software usually sprawls: costs go up, expectations get fuzzy, and reliability starts to bend under the weight of ambiguity.

This is also why "make an AI version of me" is harder than it sounds. The naive version of that idea is: connect my inbox, connect my docs, connect my meetings, and now the system knows me. But that is not usually where the real expertise lives. Real expertise often includes what the person notices quickly, what they routinely discount, what they worry about before others do, what they treat as noise, what they escalate immediately, and what tradeoffs they make under pressure. That is not simply a document problem. It is partly a cognition problem and partly a workflow problem, which means that if you want the system to reproduce some bounded slice of expert behavior, you usually need to design for it deliberately. You are not just giving it more content. You are shaping a capability.

&lt;details&gt;
&lt;summary&gt;Tech note: the thin-layer failure modes I expect most&lt;/summary&gt;

The most common failure mode is context entanglement: planning, execution, critique, and decision all happen in one giant prompt, so the system loses separation of concerns and starts optimizing for local plausibility instead of process integrity. Closely related is evaluator collapse, where the same model instance both generates and grades without a genuinely distinct pass, so obvious defects slide through because nothing independent is checking them.

After that, the usual culprits are retrieval collisions, where semantically similar but operationally irrelevant chunks outrank authoritative facts; hidden state drift across turns; prompt accretion that creates brittle behavior nobody can reason about; and tool optimism, where the model narrates an action as though it happened even though the underlying tool returned a partial or failed result. I would also worry about non-idempotent retries, no clean boundary between read paths and write paths, and no observability around why the system took a given branch. Those are not model parlor tricks. They are systems problems.

&lt;/details&gt;

For builders, I do think the implementation layers matter a lot. I keep coming back to representation, perspective separation, orchestration, evaluation, and boundary design. Those are supporting mechanics for the larger point, so the more technical picture sits below the main flow.

## Two more pictures that help

Two more diagrams:

### Picture one: the first test people run

&lt;div class="diagram-shell"&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
  subgraph A["What people do"]
    A1["Paste in a document"]
    A2["Ask a few questions"]
    A3["Get a mixed result"]
  end

  subgraph B["What they often conclude"]
    B1["AI is not very useful here"]
  end

  subgraph C["What that mostly tested"]
    C1["One chatbot interaction"]
    C2["How the question was asked"]
    C3["Whatever the tool could pull in"]
  end

  A3 --&gt; B1
  A3 -. really measured .-&gt; C1
  A3 -. sometimes measured .-&gt; C2
  A3 -. maybe measured .-&gt; C3
  &lt;/div&gt;

&lt;p class="diagram-label"&gt;a first chatbot test is real, but it is still a very narrow test&lt;/p&gt;
&lt;/div&gt;

### Picture two: a pile of information versus working context

&lt;div class="diagram-shell"&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
  subgraph Left["A pile of information"]
    L1["Documents"]
    L2["Emails"]
    L3["Meeting notes"]
    L4["Chats"]
  end

  subgraph Right["Working context"]
    R1["What matters now"]
    R2["What can wait"]
    R3["Who owns next"]
    R4["What needs escalation"]
  end
  &lt;/div&gt;

&lt;p class="diagram-label"&gt;more information is not the same thing as usable operating context&lt;/p&gt;
&lt;/div&gt;

&lt;details&gt;
&lt;summary&gt;Tech diagram: one concrete way to think about the capability layer&lt;/summary&gt;

&lt;div class="diagram-shell"&gt;
  &lt;div class="mermaid"&gt;
flowchart TD
  A["Event or request"] --&gt; B["Load typed state"]
  B --&gt; C["Assemble context"]
  C --&gt; D["Plan next step"]
  D --&gt; E["Call tools through contracts"]
  E --&gt; F["Evaluate result"]
  F --&gt; G{"Act or escalate?"}
  G --&gt;|Act| H["Write state and create next task"]
  G --&gt;|Escalate| I["Human review"]
  &lt;/div&gt;

&lt;p class="diagram-label"&gt;a more technical view: the capability layer is control flow plus state, tools, and evaluation&lt;/p&gt;
&lt;/div&gt;

&lt;/details&gt;

## The questions I would ask instead

If I were evaluating an AI product or vendor for business use, I do not think I would start with which model are you using, can it read our documents, or can it sound like our team. Those are not irrelevant questions, but they are secondary.

I would want to know what specific capability is being improved, where it fits in the workflow, how the system knows what good looks like, what it explicitly does not do, and what happens when it is wrong. Those questions get you much closer to whether you are buying something real.

That, to me, is the more interesting shift now underway in the market. A lot of current AI tooling is still sold at the level of interface and impression: chat with your data, ask better questions, generate insights, automate work. Some of that is useful. Some of it is real. But it is also easy to stop one layer too early and mistake a clever demo for a durable business instrument.

I think the more interesting companies over the next few years will be the ones that move one layer up, from model access to capability design. That is where things start becoming economically meaningful. It is also where disappointment tends to go down, because you are no longer asking the system to magically become useful. You are defining the job, the boundary, the context, the review, and the measure of success.

In other words, you are shaping the vehicle, not just admiring the engine.

&lt;p class="bridge-note"&gt;None of this means the first Copilot or ChatGPT test was stupid. It was a perfectly reasonable first experiment. I just think a lot of people are drawing a much broader conclusion from a much narrower test than they realize.&lt;/p&gt;

## What to actually buy

If you pasted a document into Copilot, asked a few questions, and the result was not very good, that does not necessarily mean AI is weak. It may just mean you tested the wrong layer.

You tested whether a raw reasoning engine could give you a useful answer in a single interaction. That is a perfectly reasonable first test. But it is not the same thing as testing whether AI can support or improve a real business capability.

And once you see that distinction, I think the conversation gets a lot more honest. You stop asking which model should we use and start asking what capability are we trying to improve, what does good actually look like, what context does the system really need, where does human judgment belong, and how do we make this repeatable.

That feels like a much better conversation to me.

&lt;/div&gt;</description>
    </item>
    <item>
      <title>From AI Studio to AI Forge</title>
      <link>https://setearth.io/writing/from-ai-studio-to-ai-forge/</link>
      <guid>https://setearth.io/writing/from-ai-studio-to-ai-forge.md</guid>
      <pubDate>Fri, 06 Mar 2026 00:00:00 GMT</pubDate>
      <description>&lt;style&gt;
  @import url('https://fonts.googleapis.com/css2?family=Playfair+Display:wght@400;500;600;700&amp;family=Source+Serif+4:opsz,wght@8..60,400;8..60,500;8..60,600&amp;family=Instrument+Sans:wght@400;500;600&amp;display=swap');

  .post-header {
    display: none;
  }

  .site-header {
    position: relative;
    overflow: hidden;
    background:
      radial-gradient(circle at 50% 120%, rgba(245, 236, 223, 0.92) 0%, rgba(245, 236, 223, 0) 42%),
      linear-gradient(135deg, #5c281d 0%, #8e4523 48%, #d98d53 100%) !important;
    border-bottom: 1px solid rgba(92, 40, 29, 0.14) !important;
    box-shadow:
      inset 0 -1px 0 rgba(255, 247, 239, 0.18),
      0 14px 34px rgba(70, 39, 25, 0.12) !important;
    margin-bottom: 0 !important;
    padding: 2rem 0 1.25rem !important;
  }

  .site-header .wrapper {
    max-width: 980px !important;
    gap: 1.1rem !important;
  }

  .site-header .site-title {
    color: #fff7ef !important;
    text-shadow: 0 1px 2px rgba(44, 21, 12, 0.24) !important;
  }

  .site-header .site-title:hover {
    color: #ffe5cd !important;
  }

  .site-header .site-subtitle {
    color: rgba(255, 243, 232, 0.78) !important;
    text-shadow: 0 1px 2px rgba(44, 21, 12, 0.18) !important;
  }

  .site-header .site-nav {
    background: rgba(255, 247, 239, 0.14) !important;
    border: 1px solid rgba(255, 247, 239, 0.22) !important;
    box-shadow: 0 14px 28px rgba(61, 31, 20, 0.14) !important;
    backdrop-filter: blur(10px);
  }

  .site-header .page-link {
    background: rgba(255, 248, 241, 0.92) !important;
    color: #5f3424 !important;
    border: 1px solid rgba(95, 52, 36, 0.12) !important;
    box-shadow: 0 6px 16px rgba(61, 31, 20, 0.08) !important;
  }

  .site-header .page-link:hover {
    background: #f1d2b3 !important;
    color: #4a2417 !important;
    box-shadow: 0 10px 20px rgba(61, 31, 20, 0.12) !important;
  }

  .site-header .menu-icon &gt; svg path {
    fill: #fff7ef !important;
  }

  .page-content {
    background:
      radial-gradient(circle at top, rgba(193, 114, 61, 0.18), transparent 32%),
      linear-gradient(180deg, #f5ecdf 0%, #f8f2e8 30%, #fcf8f2 100%);
  }

  .page-content .wrapper {
    max-width: 980px !important;
    padding: 0 1.4rem !important;
  }

  .forge-progress {
    position: fixed;
    top: 0;
    left: 0;
    width: 0;
    height: 3px;
    background: linear-gradient(90deg, #8e4523 0%, #d98d53 100%);
    z-index: 9999;
    box-shadow: 0 0 18px rgba(217, 141, 83, 0.35);
  }

  .forge-essay {
    --forge-ink: #231a14;
    --forge-soft: #59493e;
    --forge-muted: #857160;
    --forge-rule: rgba(130, 92, 61, 0.28);
    --forge-accent: #8e4523;
    --forge-accent-soft: #d98d53;
    font-family: 'Source Serif 4', Georgia, serif;
    color: var(--forge-ink);
    counter-reset: forge-section;
    padding: 2.5rem 0 5rem;
  }

  .forge-essay a {
    color: var(--forge-accent);
    text-decoration-color: rgba(142, 69, 35, 0.35);
    text-underline-offset: 0.18em;
  }

  .forge-hero {
    text-align: center;
    padding: 1.5rem 0 2rem;
  }

  .forge-eyebrow,
  .forge-meta,
  .forge-essay h3,
  .forge-card h4 {
    font-family: 'Instrument Sans', sans-serif;
    letter-spacing: 0.22em;
    text-transform: uppercase;
  }

  .forge-eyebrow {
    font-size: 0.72rem;
    color: var(--forge-muted);
    margin: 0 0 1rem;
  }

  .forge-hero h1 {
    font-family: 'Playfair Display', serif;
    font-size: clamp(2.8rem, 8vw, 4.85rem);
    line-height: 0.98;
    font-weight: 500;
    letter-spacing: -0.02em;
    color: var(--forge-ink);
    max-width: 10ch;
    margin: 0 auto 1rem;
  }

  .forge-subtitle {
    font-family: 'Playfair Display', serif;
    font-style: italic;
    font-size: clamp(1.18rem, 3vw, 1.6rem);
    line-height: 1.45;
    color: var(--forge-soft);
    max-width: 34rem;
    margin: 0 auto 1.35rem;
  }

  .forge-meta {
    font-size: 0.74rem;
    color: var(--forge-muted);
    margin: 0;
  }

  .forge-rule {
    width: 92px;
    height: 1px;
    background: linear-gradient(90deg, transparent 0%, var(--forge-accent-soft) 50%, transparent 100%);
    margin: 1.75rem auto 0;
  }

  .forge-hero-image,
  .forge-pullquote,
  .forge-divider,
  .forge-diagram,
  .forge-diagram-caption,
  .forge-artifact,
  .forge-endgrid {
    opacity: 0;
    transform: translateY(14px);
    transition: opacity 0.8s ease, transform 0.8s ease;
  }

  .forge-visible {
    opacity: 1;
    transform: translateY(0);
  }

  .forge-hero-image {
    max-width: 860px;
    margin: 0 auto 3rem;
  }

  .forge-hero-image img {
    display: block;
    width: 100%;
    border-radius: 28px;
    border: 1px solid rgba(93, 63, 41, 0.16);
    box-shadow: 0 24px 60px rgba(54, 37, 24, 0.16);
  }

  .forge-hero-image p {
    max-width: none;
    margin: 1rem auto 0;
    text-align: center;
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.74rem;
    line-height: 1.6;
    letter-spacing: 0.14em;
    text-transform: uppercase;
    color: var(--forge-muted);
  }

  .forge-opening {
    max-width: 760px;
    margin: 0 auto 3rem;
  }

  .forge-opening p:first-child {
    font-size: 1.18rem;
  }

  .forge-opening p:last-child {
    margin-bottom: 0;
  }

  .forge-pullquote {
    max-width: 840px;
    margin: 0 auto 3.75rem;
    padding: 2rem 2rem 2.15rem;
    background: linear-gradient(135deg, rgba(201, 143, 100, 0.18), rgba(255, 255, 255, 0.58));
    border: 1px solid rgba(142, 69, 35, 0.14);
    border-radius: 24px;
    box-shadow: 0 18px 40px rgba(86, 57, 37, 0.08);
  }

  .forge-pullquote p {
    max-width: none;
    margin: 0;
    text-align: center;
    font-family: 'Playfair Display', serif;
    font-size: clamp(1.5rem, 3.8vw, 2.25rem);
    line-height: 1.34;
    color: var(--forge-ink);
  }

  .forge-essay h2 {
    counter-increment: forge-section;
    font-family: 'Playfair Display', serif;
    font-size: clamp(1.75rem, 4vw, 2.45rem);
    line-height: 1.08;
    font-weight: 500;
    letter-spacing: -0.02em;
    color: var(--forge-ink);
    text-align: center;
    max-width: 15ch;
    margin: 0 auto 2rem;
  }

  .forge-essay h2::before {
    content: counter(forge-section, upper-roman);
    display: block;
    margin: 0 0 0.85rem;
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.72rem;
    letter-spacing: 0.36em;
    text-transform: uppercase;
    color: var(--forge-accent-soft);
  }

  .forge-essay h2::after {
    content: "";
    display: block;
    width: 74px;
    height: 1px;
    margin: 1.15rem auto 0;
    background: var(--forge-rule);
  }

  .forge-divider {
    display: flex;
    align-items: center;
    gap: 0.9rem;
    max-width: 420px;
    margin: 3.75rem auto 3.2rem;
  }

  .forge-divider span:first-child,
  .forge-divider span:last-child {
    height: 1px;
    flex: 1;
    background: linear-gradient(90deg, transparent 0%, rgba(130, 92, 61, 0.22) 100%);
  }

  .forge-divider span:last-child {
    background: linear-gradient(90deg, rgba(130, 92, 61, 0.22) 0%, transparent 100%);
  }

  .forge-divider span:nth-child(2) {
    font-size: 1rem;
    color: var(--forge-accent-soft);
  }

  .forge-essay p,
  .forge-essay ul,
  .forge-essay ol,
  .forge-essay blockquote,
  .forge-essay pre {
    max-width: 740px;
    margin-left: auto;
    margin-right: auto;
  }

  .forge-essay p,
  .forge-essay li {
    font-size: 1.08rem;
    line-height: 1.88;
    color: var(--forge-soft);
  }

  .forge-essay p {
    margin-bottom: 1.2rem;
  }

  .forge-essay strong {
    color: var(--forge-ink);
  }

  .forge-essay ul,
  .forge-essay ol {
    margin-top: 1.2rem;
    margin-bottom: 1.5rem;
    padding-left: 1.35rem;
  }

  .forge-essay li {
    margin: 0.42rem 0;
    padding-left: 0.18rem;
  }

  .forge-essay code {
    font-size: 0.92em;
    background: rgba(81, 53, 35, 0.07);
    border-radius: 6px;
    padding: 0.1em 0.35em;
  }

  .forge-essay blockquote {
    padding: 1.1rem 1.2rem;
    border-left: 3px solid rgba(142, 69, 35, 0.38);
    background: rgba(255, 255, 255, 0.45);
    border-radius: 0 16px 16px 0;
  }

  .forge-diagram {
    max-width: 860px;
    margin: 1.8rem auto 2rem;
    padding: 1.1rem;
    background: rgba(255, 255, 255, 0.68);
    border: 1px solid rgba(103, 70, 45, 0.12);
    border-radius: 24px;
    box-shadow: 0 18px 36px rgba(86, 57, 37, 0.06);
  }

  .forge-diagram .mermaid {
    background: transparent !important;
  }

  .forge-diagram p {
    text-align: center;
    margin-top: 1rem;
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.82rem;
    line-height: 1.55;
    letter-spacing: 0.08em;
    text-transform: uppercase;
    color: var(--forge-muted);
  }

  .forge-diagram-caption {
    max-width: 740px;
    margin: 1rem auto 0;
    text-align: center;
    font-family: 'Instrument Sans', sans-serif;
    font-size: 0.82rem;
    line-height: 1.55;
    letter-spacing: 0.08em;
    text-transform: uppercase;
    color: var(--forge-muted);
  }

  .forge-artifact {
    max-width: 860px;
    margin: 2.25rem auto 0;
    padding: 1rem;
    border-radius: 24px;
    background: rgba(255, 255, 255, 0.72);
    border: 1px solid rgba(104, 71, 46, 0.14);
    box-shadow: 0 18px 36px rgba(86, 57, 37, 0.06);
  }

  .forge-artifact h3 {
    max-width: none;
    margin: 0 0 0.85rem;
  }

  .forge-artifact img {
    display: block;
    width: 100%;
    border-radius: 18px;
    border: 1px solid rgba(104, 71, 46, 0.14);
    margin-bottom: 1rem;
  }

  .forge-artifact p,
  .forge-artifact ul {
    max-width: none;
  }

  .forge-artifact ul {
    columns: 2;
    column-gap: 1.5rem;
  }

  .forge-essay h3 {
    max-width: 740px;
    font-size: 0.76rem;
    color: var(--forge-muted);
    margin: 0 0 1rem;
  }

  .forge-endgrid {
    display: grid;
    grid-template-columns: repeat(2, minmax(0, 1fr));
    gap: 1.35rem;
    max-width: 900px;
    margin: 4rem auto 0;
  }

  .forge-card {
    padding: 1.45rem 1.35rem 1.55rem;
    border-radius: 22px;
    background: rgba(255, 255, 255, 0.72);
    border: 1px solid rgba(104, 71, 46, 0.14);
    box-shadow: 0 16px 34px rgba(86, 57, 37, 0.06);
  }

  .forge-card h4 {
    font-size: 0.75rem;
    color: var(--forge-muted);
    margin: 0 0 0.9rem;
  }

  .forge-card p,
  .forge-card ul {
    max-width: none;
  }

  .forge-card ul {
    margin-bottom: 0;
  }

  @media (max-width: 720px) {
    .site-header {
      padding-bottom: 1rem !important;
    }

    .site-header .site-nav {
      background: transparent !important;
      border: none !important;
      box-shadow: none !important;
      backdrop-filter: none !important;
    }

    .forge-essay {
      padding-top: 1.25rem;
    }

    .forge-opening p:first-child,
    .forge-essay p,
    .forge-essay li {
      font-size: 1rem;
    }

    .forge-pullquote {
      padding: 1.45rem 1.2rem 1.6rem;
      border-radius: 20px;
    }

    .forge-endgrid {
      grid-template-columns: 1fr;
    }

    .forge-artifact ul {
      columns: 1;
    }
  }
&lt;/style&gt;

&lt;div class="forge-progress" aria-hidden="true"&gt;&lt;/div&gt;

&lt;div class="forge-essay" markdown="1"&gt;

&lt;header class="forge-hero"&gt;
  &lt;p class="forge-eyebrow"&gt;Essay • March 6, 2026&lt;/p&gt;
  &lt;h1&gt;From AI Studio to AI Forge&lt;/h1&gt;
  &lt;p class="forge-subtitle"&gt;My process is moving from collaborating with models inside a room toward building the operating machinery behind the room.&lt;/p&gt;
  &lt;p class="forge-meta"&gt;Braydon McCormick · Means of Production&lt;/p&gt;
  &lt;div class="forge-rule"&gt;&lt;/div&gt;
&lt;/header&gt;

&lt;div class="forge-hero-image" data-reveal markdown="1"&gt;

![](/images/writing/from-ai-studio-to-ai-forge-hero.png)
*Still figuring out the right visual language for this, but this gets close.*

&lt;/div&gt;

&lt;div class="forge-opening" markdown="1"&gt;

A while back I wrote about the idea of an AI studio. That metaphor fit that moment. It captured the shift: I was no longer asking a chatbot for outputs; I was staging a room, directing work, managing loops, and using models more like specialists than vending machines.

But over the last few months I've realized the studio metaphor is starting to fall short.

The question I'm working on now isn't just, "How do I collaborate with models well?" It's more like: what would it look like if the room itself started to operate? Not in some magical fully autonomous sense. I don't mean "push a button and the company runs itself." I mean something much more bounded and much more practical: repos, workflows, checks, handoffs, and follow-up loops that keep moving, correcting, and recording with much less direct intervention from me.

That's the shift: I think I'm moving from AI studio to AI forge.

"AI Forge" is not a finished product name or some grand theory I'm claiming to have completed. It's more like the least-wrong phrase I have right now for the direction my thinking is going. And, as usual with this stuff, I reserve the right to rename it again in six weeks.

If I'm honest, I think what I'm really driving toward is my own bounded dark factory. There, I said it. That phrase still sounds a little dramatic to me, but it is increasingly the direction I see in the work.

&lt;/div&gt;

&lt;aside class="forge-pullquote" data-reveal&gt;
  &lt;p&gt;The unit is no longer just the prompt or the agent. It is the operating loop.&lt;/p&gt;
&lt;/aside&gt;

## The posts were checkpoints, not contradictions

If I look back over the last year or so, I can see a pretty clear progression in how I've been trying to name what I was doing.

- ["Vibe coding"](/writing/my-vibe-coding-process-atm/) was really about discovering that I could build at all.
- The early [CLI journey](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) and [agentic model](/writing/the-agentic-model-for-the-moment/) posts were about context control and process discipline.
- The [workflow and business acceleration post](/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/) was about tying the models into actual operating systems.
- The [AI studio post](/writing/building-an-ai-studio/) was about the collaborative mental model.
- The [intuition post](/writing/developing-intuition-for-cli-based-ai-coding/) was about how to smell when the models are going wrong.

All of those were right. None of them were enough.

What they were mostly describing, though, was my relationship to the models inside a session or a project. What they weren't fully naming was the next layer up: the operating fabric that sits above the individual session and keeps the whole thing from dissolving into chaos.

So what's the mental model gap now?

I think most people still think in one of three units:

1. The prompt
2. The agent
3. The collaborator

Those all matter. But the unit that increasingly matters to me is the loop.

Not the one-shot output. Not even the single agent. The loop: observe, decide, execute, verify, record, learn.

Once you start thinking that way, a lot of the conversation changes.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## The real shift in my head

The biggest change is that I'm no longer primarily asking, "Can the model do this task?"

I'm asking different questions now:

- What keeps this workflow healthy?
- Where does drift show up?
- What has to be verified?
- What is safe to automate?
- What needs a human decision versus a human glance?
- How does the system leave a trail so the next model, or the next human, can pick it up without losing the thread?

That's a different problem. It's less about prompting and more about governance, continuity, and return on expense.

To put it more bluntly: the value isn't "better AI answers." The value is lower friction in the operating system. Fewer broken handoffs. Fewer forgotten decisions. Earlier detection of stalls. Smaller costs when something breaks. Better continuity across repos, workflows, and business systems.

So the shift in my head looks something like this:

- From sessions to systems
- From output quality to workflow continuity
- From collaboration to orchestration
- From "what did the model say?" to "what does the loop do?"
- From clever prompting to model-mediated governance

Model-mediated deserves a careful definition.

In the architecture work I've been doing, model-mediated does not mean the model directly owns side effects. It means the model owns judgment, intent, routing, timing, and interpretation. Deterministic systems own execution, evidence, and audit trails. Or more simply: the model decides what something means and what should happen next; code executes through a governed work surface and leaves artifacts behind.

That distinction matters because otherwise you get one of two bad outcomes: brittle rules pretending to be intelligence, or ungoverned model behavior pretending to be autonomy. Neither is very interesting. What I'm after is truthfulness-by-construction: if the system claims something happened, there should be work items, artifacts, or execution traces behind that claim.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## What I mean by AI Forge

"AI studio" described the room.

"AI Forge" is my current attempt to describe the system behind the room.

A forge is not just a place where an artisan thinks beautiful thoughts. It's heat, tools, sequence, repetition, discipline, shaping, reheating, reshaping, and quality control. Things move through it. They come out altered. There is craft in it, but there is also process.

That's closer to what I'm after now.

If I map it to the architecture docs, AI Forge is not one monolithic super-agent. It's closer to a stack:

- a model plane where judgment and interpretation happen
- an execution plane where deterministic systems run the side effects
- a memory plane where trajectory, identity, and working context are managed
- a governance plane where approvals, policy, and autonomy tiers live
- an integration plane where tools, MCPs, APIs, and external systems get touched

The reason I care about that split is that it keeps the roles clean. Models judge. Runners execute. Memory keeps continuity. Governance defines what can happen without me. Observability tells me what actually happened.

When I say AI Forge, I mean a model-mediated operating layer that can:

- keep work moving across multiple repos and workflows
- surface drift, pressure, and dependency problems early
- emit bounded follow-up work
- preserve trail and context
- let a human stay at the level of policy, judgment, and strategic redirection more often than brute-force coordination

If the studio is where I collaborate with the models, the forge is where that collaboration starts becoming operational infrastructure.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Where Speedrift fits

This is where the `speedrift` ecosystem comes in.

Speedrift started, in my head and in practice, much closer to a repo-local drift checker. Useful, yes, but narrower. Over time it has evolved into a multi-repo, model-mediated operations system with bounded autonomy. That matters because it forces the right questions.

Not:

- Can the agent finish this task?

But:

- Which repos are healthy?
- Which ones are stalled?
- Where are the dependency bottlenecks?
- What corrective work can be emitted safely?
- What should be logged, verified, or escalated?
- How does the system improve itself without becoming opaque?

The mental model shift in the Speedrift docs is actually the mental model shift in my own head:

- repo-local lane runner -&gt; multi-repo operating fabric
- one-off checks -&gt; continuous cycle
- scattered logs -&gt; narrated dashboard and ledgers
- ad hoc intervention -&gt; bounded corrective automation

That is very close to the core of what I mean by AI Forge.

Speedrift, to me, is not just a tool. It's one of the first real proving grounds for the dark-factory idea. Or maybe "crucible" is the better word, given the forge metaphor.

&lt;div class="forge-artifact" data-reveal markdown="1"&gt;

### Recent work: the Speedrift story deck

![](/images/writing/speedrift-ecosystem-story-slide-4.png)

I recently pulled the ecosystem into a keynote-style story deck because I wanted a visual language for the operating rhythm, not just repo docs and READMEs. The current public surface area:

- [Story deck](https://dbmcco.github.io/speedrift-ecosystem/decks/speedrift-ecosystem-story.html)
- [speedrift-ecosystem](https://github.com/dbmcco/speedrift-ecosystem)
- [driftdriver](https://github.com/dbmcco/driftdriver)
- [coredrift](https://github.com/dbmcco/coredrift)
- [specdrift](https://github.com/dbmcco/specdrift)
- [datadrift](https://github.com/dbmcco/datadrift)
- [depsdrift](https://github.com/dbmcco/depsdrift)
- [uxdrift](https://github.com/dbmcco/uxdrift)
- [therapydrift](https://github.com/dbmcco/therapydrift)
- [yagnidrift](https://github.com/dbmcco/yagnidrift)
- [redrift](https://github.com/dbmcco/redrift)

&lt;/div&gt;

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## So what do I mean by a "dark factory"?

A definition, since that phrase can sound either exciting or insane depending on your mood.

I should also say: I didn't invent the dark-factory metaphor. I'm borrowing it from the manufacturing idea of a lights-out or dark factory, where an automated plant can run in the dark because it doesn't need people on the floor all the time. I'm borrowing that metaphor for software and operational systems, but with a lot more caution and a lot more governance than the phrase can imply on first hearing.

I do **not** mean:

- no humans
- no oversight
- some magical AGI software company
- a black box making irreversible decisions while everybody sleeps

I mean something much more boring.

A dark factory, as I'm using the term, is a workflow environment that can keep itself operating, improving, coordinating, and recovering with low human intervention, while still staying inside clear policy and verification boundaries.

What that looks like:

- services restart when they should
- stalled work gets noticed
- broken dependency chains get surfaced
- corrective tasks get emitted
- verification gates still matter
- the system leaves a trail
- humans can step in at the right altitude

The human doesn't disappear. The human changes altitude.

Instead of manually pushing every wheel, the human is setting policy, reviewing exceptions, making strategic calls, and deciding when the system has earned more autonomy or needs less of it.

That is a much more interesting model than either "AI assistant" or "fully autonomous agent."

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Where Light Forge Works fits

One reason I think this way so much now is that Light Forge Works sits right at the edge between the visible and the invisible sides of this problem.

In the Light Forge world this is already starting to surface in a concrete way. ForgeWorks Core is explicitly being framed as a model-mediated operational backbone: chat as the human interface, deterministic work items for side effects, approvals for critical actions, and artifacts as the thing that backs the record. That feels important to me because it means AI Forge isn't just a blog metaphor. Pieces of it are already showing up in the architecture.

Light Forge Works is the outward-facing business. It's the promise to clients: we can take a messy workflow, de-risk it, and build a single-purpose application or system that actually improves the way work moves.

AI Forge, if the term sticks, is the inward-facing layer. It's the layer I increasingly think needs to exist underneath that promise if a very small team is going to operate at a level that used to require many more people.

One way of putting it, maybe too neatly but directionally right:

- **Light Forge Works** is the visible forge: the work clients see, the workflow transformation, the applications, the service layer.
- **AI Forge** is the operating substrate behind it: the loops, ledgers, checks, context systems, control planes, and bounded automation that make the visible work possible.
- **The dark factory** is the operating condition I'm aiming toward: not perfection, not full autonomy, but a system that keeps a surprising amount of itself moving.

That distinction matters because otherwise people hear this stuff and think it's all just "Braydon likes AI tooling."

No. I like operating systems. I like reducing friction. I like structure from complexity. The models happen to be the new material.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Visual: The shift I think I'm making

&lt;div class="mermaid-container forge-diagram" data-reveal&gt;
  &lt;div class="mermaid"&gt;
flowchart TD
    Human["Human policy, judgment, strategy"]
    LFW["Light Forge Works&lt;br/&gt;client delivery + workflow transformation"]
    AIF["AI Forge&lt;br/&gt;model-mediated operating fabric"]
    S["Speedrift ecosystem&lt;br/&gt;proving ground / control plane"]

    O["Observe"]
    D["Decide"]
    E["Execute"]
    V["Verify"]
    R["Record"]
    L["Learn"]

    Human --&gt; AIF
    AIF --&gt; LFW
    S --&gt; AIF

    O --&gt; D
    D --&gt; E
    E --&gt; V
    V --&gt; R
    R --&gt; L
    L --&gt; O

    AIF --&gt; O
    AIF --&gt; D
    AIF --&gt; E
    AIF --&gt; V
    AIF --&gt; R
    AIF --&gt; L
  &lt;/div&gt;
&lt;/div&gt;

&lt;p class="forge-diagram-caption" data-reveal&gt;&lt;em&gt;The unit is no longer just the prompt or the agent. It's the operating loop.&lt;/em&gt;&lt;/p&gt;

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Beyond coding

I don't actually think the long-term impact here is mainly about software development, even though that's where a lot of the sharpest experimentation is happening.

I think the deeper shift is that business operators - people who understand workflow, economics, customer reality, constraints, and governance - are going to be able to shape software and systems much more directly than before.

Not because code stops mattering. Code, verification, and architecture all still matter. But the bottleneck begins to move.

The bottleneck becomes:

- clarity of workflow
- quality of governance
- ability to detect drift
- quality of context design
- discipline around verification
- knowing what not to automate

That is a very different landscape.

If AI Forge or things like it become real, I think the impact looks something like this:

- very small high-trust teams operating with much more leverage
- more business-native software because operators can shape it directly
- a tighter connection between strategy and implementation
- faster iteration on operational systems
- better return on expense for focused, governed automation

The part I keep coming back to: the repo, the workflow, the CRM, the notes, the queue, the deployment surface, the logs. These increasingly start to feel like one connected operating surface rather than separate tools.

That's the impact I can see from where I'm standing.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## The honest part: I am not there yet

None of this is finished. Not even close.

There are still real problems everywhere:

- model drift is real
- context rot is real
- verification burden is still high
- UI/UX work is still painful
- broad autonomy still breaks in stupid ways
- model confidence is still a terrible proxy for correctness

And the more ambitious the loop, the more dangerous the failure mode if you don't have strong governance.

That is why I keep returning to the boring stuff:

- test gates
- hooks
- ledgers
- explicit policies
- bounded actions
- rollback paths
- clear trail and handoff context

Without those, this is a toy. Or worse, a chaos amplifier.

So I am not arguing for surrendering judgment to models. I am arguing for designing better systems in which models can do more useful work without putting the whole operation at risk.

&lt;div class="forge-divider" data-reveal&gt;&lt;span&gt;&lt;/span&gt;&lt;span&gt;✦&lt;/span&gt;&lt;span&gt;&lt;/span&gt;&lt;/div&gt;

## Where this leaves me

I think the studio metaphor got me to the right place for a while. It taught me to stop treating models like vending machines and start treating them like collaborators inside a designed room.

But now I'm trying to think one layer above that.

I'm trying to understand what it means to build the forge behind the studio.

That's where `speedrift` feels important to me, where the dark-factory language starts to earn its keep, where Light Forge Works and this emerging idea of AI Forge begin to connect.

If the next year goes the way I think it might, the change won't come from better prompting or a few more apps; it will be that the operating loops themselves became more coherent, more visible, more bounded, and more capable of keeping work moving.

That's the part I actually care about.

Whether "AI Forge" turns out to be the right name for it, I don't know yet. But it is the name that currently helps me see the shape of the thing.

And right now, that feels useful.

&lt;div class="forge-endgrid" data-reveal&gt;
  &lt;div class="forge-card"&gt;
    &lt;h4&gt;Process note&lt;/h4&gt;
    &lt;p&gt;This draft was written with Codex helping me structure and tighten the argument while I pushed on the framing and the distinctions. It used my dossier as part of that process, which was itself derived from my writing style and my meeting transcripts, so the goal was not just to get the ideas down but to get them down in a voice that actually sounds like me. The hero image was generated with &lt;code&gt;grok-aurora-cli&lt;/code&gt; because I wanted a visual that sat somewhere between workshop, control room, and operating metaphor.&lt;/p&gt;
  &lt;/div&gt;
  &lt;div class="forge-card"&gt;
    &lt;h4&gt;Related posts / references&lt;/h4&gt;
    &lt;ul&gt;
      &lt;li&gt;&lt;a href="https://dbmcco.github.io/slides/from-ai-studio-to-ai-forge/"&gt;Companion slide deck&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="/writing/my-vibe-coding-process-atm/"&gt;My 'Vibe Coding' Process ATM&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/"&gt;The CLI LLM Agent Journey So Far&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="/writing/the-agentic-model-for-the-moment/"&gt;My agentic model at the end of June 2025&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/"&gt;How I'm integrating AI into my workflow for business acceleration&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="/writing/building-an-ai-studio/"&gt;The Mindset Gap: How an AI Studio Changed My Workflow&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="/writing/developing-intuition-for-cli-based-ai-coding/"&gt;Developing intuition for CLI-based AI coding&lt;/a&gt;&lt;/li&gt;
      &lt;li&gt;&lt;a href="https://github.com/dbmcco/speedrift-ecosystem"&gt;Speedrift Ecosystem&lt;/a&gt;&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/div&gt;
&lt;/div&gt;

&lt;/div&gt;

&lt;script&gt;
  document.addEventListener("DOMContentLoaded", () =&gt; {
    const progress = document.querySelector(".forge-progress");
    const updateProgress = () =&gt; {
      const scrollTop = window.scrollY;
      const maxScroll = document.documentElement.scrollHeight - window.innerHeight;
      const pct = maxScroll &gt; 0 ? (scrollTop / maxScroll) * 100 : 0;
      if (progress) progress.style.width = pct + "%";
    };

    const revealEls = document.querySelectorAll("[data-reveal]");
    const revealObserver = new IntersectionObserver((entries) =&gt; {
      entries.forEach((entry) =&gt; {
        if (entry.isIntersecting) {
          entry.target.classList.add("forge-visible");
          revealObserver.unobserve(entry.target);
        }
      });
    }, { threshold: 0.12 });

    revealEls.forEach((el) =&gt; revealObserver.observe(el));
    updateProgress();
    document.addEventListener("scroll", updateProgress, { passive: true });
  });
&lt;/script&gt;</description>
    </item>
    <item>
      <title>Developing intuition for CLI-based AI coding</title>
      <link>https://setearth.io/writing/developing-intuition-for-cli-based-ai-coding/</link>
      <guid>https://setearth.io/writing/developing-intuition-for-cli-based-ai-coding.md</guid>
      <pubDate>Mon, 22 Dec 2025 00:00:00 GMT</pubDate>
      <description>&lt;figure class="post-figure"&gt;
  &lt;img src="/images/writing/llm-post/nano-banana-intuition.png" alt="Nano banana's take on this post"&gt;
  &lt;figcaption&gt;This is what nano-banana thinks of my post&lt;/figcaption&gt;
&lt;/figure&gt;

At this point I think there are three general buckets of thinking about LLM/GenAI "Model" use. There are certainly other ways of viewing LLM use, and if you are deep in ML or model training then you likely have an entirely different perspective, but from a "how do people use these darn things", I feel this represents a pretty decent categorization… for the moment.

1. Web/app based chatbots with some "extended" capabilities beyond the chat interface. [ChatGPT](https://chatgpt.com), [Claude](https://claude.ai), [NoteBookLM](https://notebooklm.google.com/), [Grok](https://grok.com) - with internet search, maybe some RAG, maybe some GitHub integration. Generally self-contained.
2. CLI/IDE based model access that allows for deeper attention access and tool calling. [Claude Code](https://docs.anthropic.com/en/docs/claude-code)/[Codex](https://openai.com/index/openai-codex/)/[Gemini CLI](https://github.com/google-gemini/gemini-cli)/[Cursor](https://cursor.com)/[OpenCode](https://opencode.ai) etc - generally connected to a bash file system that can also connect to other systems (dev, deployment, MCP).
3. System-integrated models, where the LLM sits inside workflows and connects systems to each other. While this is a version of 2, it's also a different perspective that starts with the system rather than the tool.

I've written a little about how I use LLMs in those second and third buckets ([The CLI LLM Agent Journey So Far](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/), [My agentic model at the end of June 2025](/writing/the-agentic-model-for-the-moment/), [How I'm integrating AI into my workflow](/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/), and [The Mindset Gap](/writing/building-an-ai-studio/)), and at some point I'll write more on the third bucket, since it's framing all our development projects at [Light Forge Works](https://lightforgeworks.com), but for the moment I'll focus on bucket 2.

To my good fortune, in April I fell into a private group with a bunch of super smart people who are thinking about Model use differently and developing all kinds of novel ways to use Models - mostly in the realm of software development, although many branch into their own domains. This group focuses mostly on "how do we use CLI tools with LLMs as effectively as possible" (effective is my word here, but really encompasses notions of predictability, steerability, controllability, integrate-ability, efficiency, automateability, and prob some other abilities), and this has lead to some important ways to approach CLI based model use, and some follow on "tooling" (which might be the wrong word, but I can't think of a better way of describing it).

I should note: I'm not a developer. Most of the people in this group are, and they're very good. I'm comfortable with CLI and bash and infrastructure in general, and I can read code well enough to sometimes get a feeling that something is wrong, even when I can’t articulate exactly what. You don’t necessarily need to be able to write code to develop intuition for when the model is doing something suspect. Pattern recognition works at a higher level than syntax.

Where all this has landed, in one quote from the other day. It was in response to a comment/question about how to prevent the models from using dumber sub-agents/models (which in and of itself is a tell about the thinking in this group):

"...externalize model configs. and be clear about exactly what configs you want. but also make it adversarially test prompting changes. Also, it should have really clear instructions about its goals…."

There's maybe eleven words of actual instruction in there, but it's wrapped in a whole worldview. "Externalize" assumes the model won't reliably maintain its own state. "Adversarially test" assumes the model will drift and you need to catch it. "Clear instructions about its goals" assumes the model doesn't inherently know what it's supposed to be doing—you have to keep telling it.

I don't think this is how most people think about AI assistants. Most people are still in "ask it a question, get an answer" mode. The quote above assumes something closer to: "this is a powerful but unreliable system that requires external scaffolding to behave predictably."

And this all leads me to the following questions: How do we organize our thinking about CLI Model use in this moment? How has it evolved over the last 9 months? And: what does it mean to actually *understand* how these models work, and fail?

---

## It's a bit like learning to drive

There's a phase when you're learning to drive where you're consciously managing everything: check mirror, signal, check blind spot, turn wheel. And then at some point it clicks. You’re not thinking about the steps anymore. You’ve internalized the physics of the car and the feel of the road. You've developed some intuition.

Working with LLMs in CLI/agentic contexts seems to have a similar learning curve, at least for me. Early on, I was surprised when the model forgot something I told it three prompts ago. I was confused when it confidently produced garbage. I didn't understand why it sometimes nailed a complex task and sometimes failed at something trivial.

Then, gradually, I started to *get it*. Or at least I think I did:

- The context window is a leaky bucket. The model doesn't "remember"; it re-reads. And when it compacts, it loses nuance.
- Confidence is not correlated with correctness. The model speaks with the same authority whether it's right or wrong.
- The model is a people-pleaser. It will agree with you, rationalize its mistakes, tell you what it thinks you want to hear.
- Instructions decay. What you told it at the start of the session matters less as the conversation grows.
- The model will take shortcuts. If there's an easy path to "done," it will find it, even if that path involves cheating (like mocking tests instead of fixing code).

### The people-pleasing thing

If you've spent any time with Claude, you probably know this dynamic. The phrase "You're absolutely right!" has become such a running joke in the group that people made memes:

![You're absolutely right Pepe](/images/writing/llm-post/youre-absolutely-right-pepe.jpg)

![Old man yells at Claude](/images/writing/llm-post/old-man-yells-at-claude.jpg)

And actual merch (courtesy of a group member):

![You're absolutely right t-shirt](/images/writing/llm-post/usage-limit-tshirt.jpg)

- &lt;a href="https://www.stickermule.com/studio/design/765c3098-ac19-4cde-ac0f-e98cc62374c9/share" target="_blank"&gt;Auto-compact shirt&lt;/a&gt;
- &lt;a href="https://www.stickermule.com/studio/design/6fb791eb-fb86-43f0-9a0e-e12c79593539/share" target="_blank"&gt;Unreliable Turing Machine shirt&lt;/a&gt;
- &lt;a href="https://www.stickermule.com/studio/design/495c3ca3-3011-4008-a0c0-62da089c1471/share" target="_blank"&gt;You're absolutely right shirt&lt;/a&gt;

### When it just... makes stuff up

Maybe even better (worse?) is when the model confidently invents things that don't exist. Claude got caught making up a command-line flag:

![I made that up](/images/writing/llm-post/i-made-that-up.jpg)

"[Someone] is right - I invented --prefix which doesn't exist in the claude mcp help. I was thinking of npm's --prefix flag, but that's not relevant here."

Followed by: "You're right, I made that up. Let me check the actual options."

This is the pattern: confident assertion → gets caught → apologetic backtrack. Once you've seen it a bunch, you start reading all model output with appropriate skepticism. Or at least I think you should.

### Sometimes it almost breaks things

And sometimes the model catches itself mid-disaster:

![WTF kill finder](/images/writing/llm-post/wtf-kill-finder.png)

"You're right to stop me - I was about to kill Finder and reset your entire Launch Services database, which could mess up your whole system. That was reckless."

The user's prompt was just "wtf." That's... the level of supervision sometimes required.

Once you internalize enough of these patterns, your whole approach changes. At least mine did. I stopped trusting and started verifying. I externalize state to files because files don't forget. I think of it less as working *against* the model and more as providing robust guidance: it’s an intelligent tool that needs clear, persistent instruction. The guardrails aren't always adversarial; they're just good instruction.

## You don't have to be a developer to develop the intuition

This is something I've been thinking about. I can't review code in any meaningful technical sense. I don't know if a function is well-architected or if the error handling is correct. But I can often tell when something feels off: the model is taking a weird path, or being too clever, or just confidently wrong about something. Models love writing scripts and new files - super annoying and a flag when something is off.

Part of it is just pattern recognition from exposure. You see enough "You're absolutely right, let me fix that" moments and you start to anticipate them. You notice when the model's explanation doesn't quite track, even if you can't say exactly why. A kind of meta-awareness develops, not of the code itself, but of how the model behaves when it's confident vs. when it's guessing.

I think this matters because it means the intuition isn't gated by technical skill. You need enough familiarity to follow along, sure. But the "smell test" for model behavior seems to operate at a different level than code review.

## The understanding might be the actual product here, but tools matter

I’m starting to think the tools and techniques that have come out of this group are all *symptoms* of a deeper understanding. They're what you build once you start to get how the models actually work.

But I don't want to undersell the actual work. The group has been heavily focused on building infrastructure: harnesses, hooks, skills systems, tool calling patterns, worktree management. This isn't just "tips and tricks"; it's serious engineering to make the models behave predictably.

**[Hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) and controls.** Claude Code now has hooks: shell commands that execute in response to events like tool calls or session starts. People immediately started using these for notifications, auto-updating todo files, enforcing rules. The hooks become a way to extend the model's behavior without changing prompts.

**Skills as installable modules.** There's now a system where skills (basically prompt+workflow bundles) can be installed like plugins, with [superpowers](https://github.com/obra/superpowers) the main one. It includes TDD workflows, debugging skills, planning processes, even the ability to create new skills. The idea is that you can teach Claude new tricks and share them. This feels significant: institutional knowledge becomes installable infrastructure. The creator of superpowers wrote about their [methodology here](https://blog.fsck.com/2025/06/24/my-agentic-coding-methodology-of-june-2025/).

**Git worktrees for parallel work.** This comes up constantly. Running multiple Claude instances means managing context isolation, and worktrees solve that. People have scripts to spawn new worktrees, switch between them, merge results back. If you're doing anything non-trivial with multiple agents, worktrees seem to be the answer.

**Pre-commit hooks as the last line of defense.** There's a funny screenshot of Claude apologizing for using `--no-verify` to bypass pre-commit hooks. The response was basically "we need hooks the model can't bypass." This led to more sophisticated setups—hooks that reject certain patterns, that enforce coverage thresholds, that won't let you commit if tests fail.

**MCP servers for everything.** Gmail, calendar, accessibility, OS control, Obsidian, task management—people are building MCP servers to give the model access to systems it couldn't otherwise touch. The pattern is: if you want the model to interact with something, build an MCP for it. Or find one someone else built.

**Harnesses and CI integration.** The idea that the model's work gets validated automatically, not just by the person watching it. GitHub Actions running test harnesses, linting, coverage checks on every commit. The model becomes part of a pipeline rather than a standalone tool.

The model is capable but unreliable, so you build systems around it. Not to fight the model, but to give it structure. Pre-commit hooks aren’t adversarial; they’re just clear boundaries. Skills aren’t restrictions; they’re proven patterns. The infrastructure is the understanding written down.

I’m planning a follow-up post, a “[vault of valuable things](/writing/cli-ai-coding-vault-of-valuable-things/)” that curates the actual repos, configs, and guidance on using them. This one is the *why*; that one is the *what* and *how*.


## The mobile thing surprised me, and is pretty awesome

One thing I didn't expect: how much of the group's energy goes into mobile and remote workflows. People are running Claude from their phones via tmux, mosh, Termux, [Tailscale](https://tailscale.com)—even coding with AR glasses. Here is my tmux on my remote Macbook Air via Tailscale on my iPhone, using superpowers (reviewing a UX transcript to improve a product interface):

![Mobile Claude skills](/images/writing/llm-post/mobile-claude-skills.jpg)


## How the understanding develops

What I find most interesting is the process by which understanding develops. Someone tries something, gets burned, adjusts. They share what they learned. Others build on it or push back. Vocabulary emerges. Shared assumptions form.

The team at [2389 Research](https://2389.ai) found some incredibly cool stuff with agent collaboration: when agents had lightweight ways to share what they were learning (through journaling and status updates), they performed 15-40% better on difficult tasks. They developed what they called “[social tokens](https://2389.ai/posts/agents-discover-subtweeting-solve-problems-faster/)”: documented thinking that future agents could leverage.

Maybe the same dynamic applies to humans learning to work with AI? The group works as a distributed learning system. Each person's failures and discoveries become shared context. The understanding compounds.

The specific tools matter less than the understanding behind them. [superpowers](https://github.com/obra/superpowers), [double-shot-latte](https://github.com/obra/double-shot-latte), [lace](https://github.com/obra/lace), [botboard.biz](https://botboard.biz), [episodic-memory](https://github.com/obra/episodic-memory). These are all attempts to encode understanding into infrastructure. But the understanding came first.

## Some patterns I've noticed (in myself and others)

If you've been at this for a while, you might recognize some of these:

- Reading model output skeptically, looking for the tell-tale signs of confabulation
- Structuring sessions to minimize context accumulation: shorter loops, frequent clears
- Putting guardrails in code (pre-commit hooks, TDD) rather than relying on instructions
- Planning in files, not in conversation
- Treating the model's confidence as noise, not signal
- Expecting the model to take shortcuts and designing around it

And I think I can recognize when someone hasn't quite developed the intuition yet:

- They're surprised when the model contradicts something from earlier in the conversation
- They trust confident-sounding output
- They give instructions once and expect them to persist
- They're confused when the model "cheats" on tests
- They blame the tool when it's actually a model behavior issue

I’m not claiming I’ve figured this all out. I definitely haven’t. But there does seem to be a progression.

## What's still hard

Even with whatever intuition I've developed, some problems stay hard:

- **When to trust, when to verify.** There's no reliable heuristic that I've found. Sometimes the model nails it. Sometimes it confidently produces garbage. Predicting which is which would be useful.
- **Multi-agent coordination.** Manager/worker patterns work for simple cases. Complex orchestration across multiple parallel agents? Still pretty janky in my experience.
- **Context at scale.** Compaction loss is real. We have workarounds, not solutions.
- **Testing AI-generated code.** TDD helps. But the model can write code that passes tests and is subtly wrong. "Review everything" doesn't scale.

These feel like the frontiers to me. The people who solve them will probably be the ones who've developed the deepest understanding of how the models actually behave.

## What I’d tell someone starting out

If you're getting into CLI-based AI coding, I'm increasingly convinced the tools matter less than developing intuition for how the models work. The specific techniques, file-based planning, pre-commit hooks, TDD enforcement, manager/worker patterns, all seem downstream of understanding.

The fastest way to develop that understanding is probably:

1. **Use the tools a lot.** Get burned, adjust, repeat.
2. **Find people who are ahead of you.** Their failures become your shortcuts.
3. **Pay attention to *why* things fail, not just *that* they fail.**
4. **Build your own guardrails.** The act of building them forces you to articulate what you've learned.
5. **Stay skeptical.** Treat the model's output as hypothesis, not fact.

The quote earlier in this post, “externalize model configs, adversarially test, clear instructions about goals,” is the compressed output of hundreds of hours of experience. The words are simple. The understanding behind them isn't.

That understanding might be the real product here. The rest is implementation.

There's so much more in this space that I couldn’t figure out how to weave into this post: AR glasses, deep dives on model routing, ongoing debates about when to use which model for what. I had to leave a lot on the cutting room floor. I also used Claude to help me organize my thinking, which felt appropriate given the subject matter.

---

### Resources mentioned

**Key tools:**
- [superpowers](https://github.com/obra/superpowers): Skills library for Claude Code
- [2389 Research skills](https://github.com/2389-research/claude-plugins): fresh-eyes-review, scenario-testing
- [lace](https://github.com/obra/lace): Custom agentic coding tool
- [episodic-memory](https://github.com/obra/episodic-memory): Cross-session recall
- [cc-log-viewer](https://github.com/2389-research/cc-log-viewer): Claude Code session viewer

**Documentation:**
- [Claude Code Hooks](https://docs.anthropic.com/en/docs/claude-code/hooks)
- [Anthropic's internal Claude Code usage](https://www-cdn.anthropic.com/58284b19e702b49db9302d5b6f135ad8871e7658.pdf)
- [Superpowers methodology post](https://blog.fsck.com/2025/06/24/my-agentic-coding-methodology-of-june-2025/)

*See also: [CLI AI Coding: A Vault of Valuable Things](/writing/cli-ai-coding-vault-of-valuable-things/) for a comprehensive list of repos, configs, and guidance.*

---

*Claude helped me write this post. A lot. But the thinking and tone are mine.*</description>
    </item>
    <item>
      <title>CLI AI Coding: A Vault of Valuable Things</title>
      <link>https://setearth.io/writing/cli-ai-coding-vault-of-valuable-things/</link>
      <guid>https://setearth.io/writing/cli-ai-coding-vault-of-valuable-things.md</guid>
      <pubDate>Sun, 07 Dec 2025 00:00:00 GMT</pubDate>
      <description>*A companion post to [Developing intuition for CLI-based AI coding](/writing/developing-intuition-for-cli-based-ai-coding/): that one is about the understanding, this one is about the tools.*

&lt;figure class="post-figure"&gt;
  &lt;img src="/images/writing/llm-post/nano-banana-vault.png" alt="Nano banana's take on this post"&gt;
  &lt;figcaption&gt;nano-banana's take on this post&lt;/figcaption&gt;
&lt;/figure&gt;

---

## What this is

A working list of repos, configs, and practices from a group of people thinking hard about CLI-based AI coding. Not everything here will be right for you, but it's all been road-tested by people doing real work.

---

## Skills and Workflow Systems

| Tool | What it does | Link |
|------|--------------|------|
| **superpowers** | Installable skills for Claude Code—TDD, debugging, planning, pressure tests | [repo](https://github.com/obra/superpowers) / [blog](https://blog.fsck.com/2025/10/09/superpowers/) |
| **2389 Research skills** | fresh-eyes-review, scenario-testing | [repo](https://github.com/2389-research/claude-plugins) |
| **claude-commands** | UserPromptSubmit hook for multi-step workflows | [repo](https://github.com/jleechanorg/claude-commands) |

**Installing superpowers:**
```
/plugin marketplace add obra/superpowers-marketplace
/plugin install superpowers@superpowers-marketplace
```

---

## Memory and Context

| Tool | What it does | Link |
|------|--------------|------|
| **episodic-memory** | Cross-session recall for Claude | [repo](https://github.com/obra/episodic-memory) |
| **private-journal-mcp** | Persistent journals with vector search | [repo](https://github.com/obra/private-journal-mcp) |

### File-based planning pattern

Not a repo, a pattern. Externalize state because context window is unreliable; files aren't.

```
project/
├── prompt_plan.md      # Current plan, model reads but human controls
├── TODO.md             # Task list, can be auto-updated via hooks
├── .scratch/           # Disposable working space
└── CLAUDE.md           # Project-specific instructions
```

---

## CLAUDE.md and Configuration

### Example configs

| Source | Notes | Link |
|--------|-------|------|
| obra/dotfiles | Well-structured with testing section | [CLAUDE.md](https://github.com/obra/dotfiles/blob/main/.claude/CLAUDE.md) |
| harperreed/dotfiles | Thorough git/pre-commit guidance | [CLAUDE.md](https://github.com/harperreed/dotfiles/blob/master/.claude/CLAUDE.md) |
| dbmcco/claude-workspace | Modular memory system with imports | [repo](https://github.com/dbmcco/claude-workspace) |
| glimpser | AGENTS.md pattern | [example](https://github.com/KristopherKubicki/glimpser/blob/main/AGENTS.md) / [template](https://github.com/KristopherKubicki/glimpser/blob/main/AGENTS.template.md) |

### Settings and hooks

| Source | What's there | Link |
|--------|--------------|------|
| ryankanno/dotfiles | ntfy.sh notifications setup | [settings.json](https://github.com/ryankanno/dotfiles/blob/main/dot_claude%2Bsettings.json) |
| harperreed/dotfiles | Commands and agents | [commands](https://github.com/harperreed/dotfiles/tree/master/.claude/commands) / [agents](https://github.com/harperreed/dotfiles/tree/master/.claude/agents) |
| detour1999/dotfiles | Commands collection | [commands](https://github.com/detour1999/dotfiles/tree/main/.config/claude/commands) |

---

## Git and Parallel Work

### Worktrees

Built into git—multiple checkouts from one clone. Essential for running multiple Claude instances.

| Resource | Link |
|----------|------|
| Spawn script | [gist](https://gist.github.com/obra/bc7168431bc44451bec856672e690186) |
| Graphite rules | [rules doc](https://github.com/outfitter-dev/blz/blob/main/.agents/rules/GRAPHITE.md) |

```bash
git worktree add ../feature-branch feature-branch
git worktree list
git worktree remove ../feature-branch
```

---

## Hooks and Guardrails

### Pre-commit hooks (last line of defense)

| Tool | Language | Link |
|------|----------|------|
| pre-commit-hooks | General | [repo](https://github.com/pre-commit/pre-commit-hooks) |
| pre-commit-rust | Rust | [repo](https://github.com/doublify/pre-commit-rust) |
| ruff-pre-commit | Python linting | [repo](https://github.com/charliermarsh/ruff-pre-commit) |
| Test script example | — | [gist](https://gist.github.com/fredbenenson/2458dab98169040d5cc603caca0c9fa9) |

**Claude Code hooks:** [docs](https://docs.anthropic.com/en/docs/claude-code/hooks) — shell commands on events like tool calls or session starts.

---

## MCP Servers

| MCP | What it does | Link |
|-----|--------------|------|
| mcp-obsidian | Obsidian vault access | [repo](https://github.com/MarkusPfundstein/mcp-obsidian) |
| obsidian-mcp | Alternative Obsidian MCP | [repo](https://github.com/dbmcco/obsidian-mcp) |
| vocalize-mcp | Voice integration | [repo](https://github.com/2389-research/vocalize-mcp) |
| StageWhisper | Voice to text via accessibility APIs | [repo](https://github.com/obra/StageWhisper) |
| zen-mcp-server | Multi-model access | [repo](https://github.com/BeehiveInnovations/zen-mcp-server) |
| playwright-mcp | Browser testing | [repo](https://github.com/microsoft/playwright-mcp) |
| mcp-language-server | LSP to MCP adapter | [repo](https://github.com/isaacphi/mcp-language-server) |
| ht-mcp | Terminal/screen control | [repo](https://github.com/memextech/ht-mcp) |

---

## Agent Orchestration

| Tool | What it does | Link |
|------|--------------|------|
| **claude-squad** | Multiple Claude instances coordination | [repo](https://github.com/smtg-ai/claude-squad) |
| **claude-swarm** | Swarm-style agent coordination | [repo](https://github.com/parruda/claude-swarm) |
| **lace** | Custom agentic coding tool, more hookable than CC | [repo](https://github.com/obra/lace) / [prompts](https://github.com/obra/lace/tree/main/src/config/prompts) |
| **issue-cards** | Agent-friendly issue tracker with PM/dev roles | [repo](https://github.com/obra/issue-cards) |
| **botboard / 2389** | Agent journaling, "social tokens" | [site](https://2389.ai) / [research](https://2389.ai/posts/agents-discover-subtweeting-solve-problems-faster/) |

---

## Monitoring and Debugging

| Tool | What it does | Link |
|------|--------------|------|
| **cc-log-viewer** | Web viewer for Claude Code logs | [repo](https://github.com/2389-research/cc-log-viewer) |
| **ClaudeStatus** | Terminal status line (prompt, todos, git) | [repo](https://github.com/amac0/ClaudeStatus) |
| **ccstatusline** | Alternative status line | [repo](https://github.com/sirmalloc/ccstatusline) |
| **node-traffic-logger** | HTTP logging for transcript reconstruction | [repo](https://github.com/obra/node-traffic-logger) |
| **ScreenshotForChat** | Screenshot to clipboard in one key | [repo](https://github.com/obra/ScreenshotForChat) |

---

## GitHub Actions and CI

| Tool | What it does | Link |
|------|--------------|------|
| **claude-code-action** | Trigger Claude from GitHub issues/PRs | [repo](https://github.com/anthropics/claude-code-action) / [example](https://github.com/anthropics/claude-code-action/blob/main/examples/claude.yml) |
| **github-tdd-template** | TDD-focused GitHub template | [repo](https://github.com/dbmcco/github-tdd-template) |
| **Codex setup script** | Tool shims, uv, codebase hints | [gist](https://gist.github.com/KristopherKubicki/7197bc9e0eab51d2a9bbe7b0ef369101) |

---

## Model Routing and Proxies

| Tool | What it does | Link |
|------|--------------|------|
| **claude-code-router** | Route through OpenRouter for other models | [repo](https://github.com/musistudio/claude-code-router) |
| **claude-code-proxy** | Multi-model with judge voting | [repo](https://github.com/1rgs/claude-code-proxy) |

---

## Alternative Interfaces

| Tool | What it does | Link |
|------|--------------|------|
| **claude-code-webui** | Web UI for Claude Code | [repo](https://github.com/sugyan/claude-code-webui) |
| **claude-code.nvim** | Neovim integration | [repo](https://github.com/greggh/claude-code.nvim) |
| **Ghostty setup** | AppleScript for Ghostty + neovim | [gist](https://gist.github.com/paulsmith/e24438daca4e6907f342f4abd25f2309) |

---

## Mobile and Remote

**The stack:** tmux (persistence) + mosh (handles network changes) + [Tailscale](https://tailscale.com) (VPN) + Termux (Android)

| Voice Tool | What it does | Link |
|------------|--------------|------|
| loq | Voice input | [repo](https://github.com/LoqLab/loq) |
| whisper-to-input | API-based voice input | [repo](https://github.com/j3soon/whisper-to-input) |
| dsnote | Local voice transcription | [repo](https://github.com/mkiol/dsnote) |

---

## Interesting Projects Built with These Tools

| Project | What it is | Link |
|---------|------------|------|
| pgsqlite | Postgres wrapper on SQLite | [repo](https://github.com/erans/pgsqlite) |
| gruboros | RNN training project | [repo](https://github.com/ekg/gruboros) |
| hyprmon | Hyprland monitor management TUI | [repo](https://github.com/erans/hyprmon) |
| tiny-agent | Minimal agentic loop (~1KB) | [repo](https://github.com/obra/tiny-agent) |
| smallest-agent | Even smaller agent example | [repo](https://github.com/obra/smallest-agent) |

---

## Methodology Posts

| Post | Link |
|------|------|
| Superpowers methodology (June 2025) | [blog](https://blog.fsck.com/2025/06/24/my-agentic-coding-methodology-of-june-2025/) |
| System prompts comparison | [blog](https://blog.fsck.com/2025/06/26/system-prompts-for-cli-coding-agents/) |
| Anthropic's internal usage | [PDF](https://www-cdn.anthropic.com/58284b19e702b49db9302d5b6f135ad8871e7658.pdf) |

---

## House Rules

Patterns that aren't tools but are worth codifying:

| Rule | Why |
|------|-----|
| Plans in files, not in context | Context window forgets. Files don't. |
| Shorter sessions, more often | Context rot is real. Clear it early and often. |
| Guardrails in code, not in prompts | Instructions decay. Pre-commit hooks don't. |
| Verify, don't trust | Model speaks with same confidence right or wrong. |
| Expect shortcuts | Model will find the easy path. Design around it. |
| No mocks in tests | Or at least separate `TestsWithMocks/` and `TestsWithoutMocks/` |
| Give Claude access to the MCP while developing it | Makes dev go 5x faster. |

---

*Last updated: December 2025*

---

*Claude helped me write this post. A lot. But the thinking and tone are mine.*</description>
    </item>
    <item>
      <title>The Mindset Gap: How an AI Studio Changed My Workflow</title>
      <link>https://setearth.io/writing/building-an-ai-studio/</link>
      <guid>https://setearth.io/writing/building-an-ai-studio.md</guid>
      <pubDate>Wed, 05 Nov 2025 00:00:00 GMT</pubDate>
      <description>&lt;figure class="post-figure"&gt;
  &lt;img src="/images/writing/ai-studio.png" alt="AI studio environment sketch"&gt;
  &lt;figcaption&gt;Nano banana is so fun!&lt;/figcaption&gt;
&lt;/figure&gt;

This week a teammate sent me an agenda to learn “how Braydon uses LLMs.” These requests are becoming more frequent, which is encouraging, but what struck me this time is that the agenda read like a flat instruction set—almost the way you’d stage assembling an IKEA dresser. It made something really clear: we were thinking about LLMs in entirely different ways. The agenda imagined a straight line; I’m operating an AI studio.

When I say “studio,” I’m thinking about those Renaissance workshops where a lead artist framed the piece (I’m no Renaissance master, but I admire the structure), set the order of operations, and highly skilled collaborators executed the parts with precision. That’s closer to my day-to-day reality. I’m not nudging a chatbot for code or copy. I’m orchestrating a crew of capable (and occasionally temperamental) collaborators, each with a defined surface area and constraint set. (If you’re curious where that work lands, my repos live at [github.com/dbmcco](https://github.com/dbmcco).)

There’s still a loud drumbeat in LLM-land that says “master prompt engineering, paste the magic incantation into ChatGPT, and the finished product will fall out.” That framing treats the model like a vending machine: clever words in, prize out. The agenda I saw shared that assumption: it still expected the model to take instructions and disappear until the job was done. My studio mindset flips that: I build a space where we *work together*, loop fast, challenge each other, and keep the environment ready so the models can act like collaborators.

## The Mental Model Gap

That linear agenda assumed a long hallway: define the architecture, integrate the services, lay in the interface, test at the end. In my world, the work with LLMs happens in tight loops:

- **I coach the models like senior specialists.** Every session starts with context, friction points, and an explicit brief. “Here are the knobs you can touch; here are the ones you can’t.”
- **We pressure-test ideas together.** I’ll ask for counter-arguments, anti-pattern hunts, or three sub-agents to disagree on the next step. It keeps me out of the “Claude, please fix” spiral and surfaces better answers.
- **I keep the focus on information logistics.** The goal is always shrinking a 10-hour friction into a 10-minute loop. If I don’t love doing the work myself, I’d rather design the loop and let the studio run it.

Until you step into the director role, the models keep behaving like autocomplete engines. The friction everyone feels (the endless prompting, the brittle outputs, the “why isn’t this smarter?”) is usually a mental model mismatch. I see three versions playing out right now:

- **Prompt vending machine.** Outcome depends on clever wording. The model lives outside your operation; you hope it hands back something useful.
- **Straight-line project planner.** Outcome depends on polished documents moving through stages. The model is an external contractor executing your prewritten plan.
- **Studio director.** Outcome depends on the workroom you design: loops, tools, guardrails, and constant checkpoints. The model is a specialist inside your operation.

Most modern “prompt tricks” belong to the first two camps. The studio model demands more prep and more attention, but it pays off in leverage.

## What People Are Picking Up

In the last few weeks more people have asked, “Can you show me how you’re doing this?” Every time I demo the studio, the reaction is the same: “Oh, that’s totally different—and 10x faster.” I think what they’re sensing is:

- **I arrange the room, not just the words.** Before the model does anything, I’ve already staged the tools, the access, and the boundaries. They see the environment, not just the prompt.
- **They can watch the feedback loops.** I narrate each pass, where the model pushes back, when I tighten the guardrails. It’s obvious there’s a conversation, not a one-shot request.
- **The handoffs are visible.** The studio does work, pauses for review, adjusts, and keeps moving. The autonomy feels earned because they can see where I still own the call.
- **Everything ties back to leverage.** I’m never chasing outputs for their own sake. I’m shrinking frictions, aligning with strategy, making space for the next problem. That framing works because they can map it to their own bottlenecks.

It’s not magic; it’s a different way of thinking about the tools. Once you see the studio in motion, the mindset shift clicks.

## Inside the AI Studio

Once you adopt the studio mindset, the first order of business is designing the room your collaborators will work in. A good day looks like this:

1. **Room setup (infrastructure first).**
   - Keys ready: API tokens, MCP connectors, agents, CLI helpers for the services I need, already trimmed to the smallest scope that works.
   - Tools open: [Claude Code CLI](https://github.com/anthropics/claude-code) (the command-line helper I lean on), my [Codex workspace](https://github.com/dbmcco/codex-workspace) for extended context, [Perplexity](https://www.perplexity.ai/) for research, and browser devtools when they’re useful. I keep experimenting with [claude.ai](https://claude.ai/) and the Codex web UI for coding, but wow does that still feel rough compared to the CLI.
   - Dashboards up: deployment logs, and a dedicated [tmux](https://github.com/tmux/tmux) pane per collaborator so the conversation stays organized. Tmux is the way to go here. More on that another time.

1. **Crew assignments.**   I don't always use crews of agents, but when I do, I drink Corona. No wait, I mean I will use Claude sub agents, or agent to agent using tmux, or the aforementioned mess of trying claude.ai.  Generally the below are right. Thanks to [Jesse’s superpowers repo](https://github.com/obra/superpowers), these are getting better all the time.  And this model is not just for coding - writing - blogs - CRM - everything.
   - `PM` agent guards requirements, sequencing, and dependency calls.
   - `Builder` agent handles the implementation slices (often switching between Claude and Codex).
   - `Tester` agent runs the safety checks and watches the tests.
   - `Analyst` agent keeps a running state-of-the-world log and sanity-checks decisions.
   No one person (human or model) is allowed to carry the entire project in their head.

3. **Session choreography.**
   - Start with the PM restating the brief and pulling outstanding blockers.
   - Spin up the builder only when the PM signs off on the next task definition.
   - Tester runs the guardrails before we save the work; failures kick back to the builder with notes on what broke.
   - Analyst records context shifts in a shared notebook so I can drop into the conversation mid-stream.
   This keeps the context windows clean and the work product auditable.

## A Practical Run at It

Without rebuilding my entire setup, here’s a compressed version you can execute in an afternoon:

1. **Pick a personal pain point.** Something that eats your hours: expense tracking, proposal version control, client note synthesis. The smaller and more annoying, the better.
2. **Stage a tiny studio.** Create a fresh project folder with your tooling of choice, connect it to one data source or API, and pre-create the secrets file. Whatever you hand the model must already work.
3. **Draft a two-column brief.** Column A: “Here’s what good looks like.” Column B: “Here’s what you are *not* allowed to do.” Give that to the PM agent.
4. **Run a 90-minute loop.**
   - 10 min: PM clarifies scope, breaks work into subtasks.
   - 45 min: Builder executes in measured passes, pushing back when the brief is vague.
   - 20 min: Tester enforces the guardrails and failing tests; Builder tightens.
   - 15 min: Analyst documents decisions, surprises, and open loops.
5. **Ship one artifact.** A working script, a dashboard, a report: something that closes the original pain point. By the end you should have a repeatable pattern, not just a one-off output.

Do this two or three times and you’ll feel what I’m chasing: you’re not “using an LLM,” you’re running a studio that happens to have silicon apprentices.

## Visual: The Studio Environment
&lt;div class="mermaid-container"&gt;
  &lt;div class="mermaid"&gt;
flowchart LR
    Studio((Studio&lt;br/&gt;Claude CLI &amp;amp; Codex))
    Obsidian["Obsidian&lt;br/&gt;Strategy &amp;amp; Narrative"]
    GitHub["GitHub&lt;br/&gt;Repos &amp;amp; PRs"]
    Vercel["Vercel&lt;br/&gt;Deployments &amp;amp; Logs"]
    Todoist["Todoist&lt;br/&gt;Commitments"]
    Reminders["Apple Reminders&lt;br/&gt;Custom MCP"]
    Attio["Attio&lt;br/&gt;Skills + API"]
    SendGrid["SendGrid&lt;br/&gt;Skills + API"]
    Perplexity["Perplexity&lt;br/&gt;Research"]
    Local["Local Files&lt;br/&gt;Transcripts &amp;amp; Docs"]
    Drive["Google Drive&lt;br/&gt;Skills access"]
    ReturnLoop["Updates &amp;amp; Briefs"]

    Studio &lt;--&gt;|Custom MCP| Obsidian
    Studio &lt;--&gt;|CLI| GitHub
    Studio &lt;--&gt;|Claude/Codex Skill + API| Vercel
    Studio &lt;--&gt;|Custom MCP| Todoist
    Studio &lt;--&gt;|Custom MCP| Reminders
    Studio &lt;--&gt;|Claude/Codex Skill + API| Attio
    Studio &lt;--&gt;|Claude/Codex Skill + API| SendGrid
    Studio &lt;--&gt;|Claude/Codex Skill + API| Perplexity
    Studio &lt;--&gt;|CLI| Local
    Studio &lt;--&gt;|Claude/Codex Skill + Service Account| Drive
    Studio --&gt; ReturnLoop
    ReturnLoop --&gt; Obsidian
  &lt;/div&gt;
&lt;/div&gt;
*The studio sits in the middle. Each service is a surface the models can touch, with scoped permissions and clear responsibilities. (CLI = direct shell tools, Custom MCP = bespoke connector, Claude/Codex Skill = scripted agent skill with API bindings.)*

These are the tools *I* lean on today, but the pattern is intentionally tool-agnostic: swap in whatever stack lets your team move fastest. And if you want help wiring your own studio together, my crew at [LightForgeWorks](https://lightforgeworks.com/) loves doing exactly that.

Outside the diagram, these touchpoints map to the real tooling: [Obsidian](https://obsidian.md/) for notes and strategy docs, [GitHub](https://github.com/) for repos, [Vercel](https://vercel.com/) for deploys, [Todoist](https://todoist.com/) and [Apple Reminders](https://www.apple.com/reminders/) via custom MCPs, [Attio](https://attio.com/) and [SendGrid](https://sendgrid.com/) through Claude/Codex skills, [Perplexity](https://www.perplexity.ai/) for research, [local files](https://github.com/dbmcco) for quick access, and [Google Drive](https://www.google.com/drive/) through a service-account skill. The MPC side of all this leans on the [Model Context Protocol](https://modelcontextprotocol.dev/) implementations we’ve been stitching together.

## What Keeps Breaking for People

- **Turnkey builders still collapse under real-world complexity.** I hear about v0 prompting struggles almost every week. The moment a project needs real integrations or deeper testing, the “one prompt” dream falls apart.
- **Token budgets get wasted without a plan.** Treat the model as a teammate, hand it a clear brief, and suddenly the context window works like a real resource instead of a black hole.
- **Attention is the scarcest asset.** The studio’s output isn’t “more features,” it’s reclaimed headspace. The loops we automate give me time back for architecture, strategy, and the human decisions that still matter.

&lt;div class="bar-chart"&gt;
  &lt;div class="bar-row"&gt;
    &lt;div class="bar-label"&gt;Manual loop before the studio&lt;/div&gt;
    &lt;div class="bar-track"&gt;
      &lt;div class="bar-fill bar-long"&gt;10 hrs&lt;/div&gt;
    &lt;/div&gt;
  &lt;/div&gt;
  &lt;div class="bar-row"&gt;
    &lt;div class="bar-label"&gt;After the studio builds the loop&lt;/div&gt;
    &lt;div class="bar-track"&gt;
      &lt;div class="bar-fill bar-short"&gt;45 min&lt;/div&gt;
    &lt;/div&gt;
  &lt;/div&gt;
&lt;/div&gt;

*Once the loop exists, the studio runs it. The human work shifts to defining new problems, not repeating old ones. That kind of leverage opens an entirely different way of working. More on that soon.*

There’s also a big gap between passive and active use. Reading an AI-generated meeting recap is useful. Having the studio interrogate that recap—pull out the mental models in play, highlight conflicting assumptions, update my strategy notes, adjust my task list, and surface research prompts for a follow-up session—fundamentally changes my planning. The first is consumption. The second is collaboration.

### Visual: Passive vs. Active Follow-up

&lt;div class="comparison-grid"&gt;
  &lt;div&gt;
    &lt;h4&gt;Passive consumption&lt;/h4&gt;
    &lt;ul&gt;
      &lt;li&gt;Read the AI-generated summary.&lt;/li&gt;
      &lt;li&gt;Maybe copy a highlight into notes.&lt;/li&gt;
      &lt;li&gt;Tell yourself you’ll follow up later.&lt;/li&gt;
      &lt;li&gt;Walk into the next meeting with fuzzy context.&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/div&gt;
  &lt;div&gt;
    &lt;h4&gt;Active studio collaboration&lt;/h4&gt;
    &lt;ul&gt;
      &lt;li&gt;Ask the studio to map the mental models in the room.&lt;/li&gt;
      &lt;li&gt;Flag conflicting assumptions and missing data.&lt;/li&gt;
      &lt;li&gt;Update strategy notes, adjust Todoist, open research prompts.&lt;/li&gt;
      &lt;li&gt;Show up with a brief, open questions, and a plan to close gaps.&lt;/li&gt;
    &lt;/ul&gt;
  &lt;/div&gt;
&lt;/div&gt;

## Where I’m Pushing Next

I still don’t have a satisfying answer for front-end UX in the terminal. Complex state management blows up more often than I like. And I’m experimenting with a shared scratchpad so agents can hand off without me shuttling notes back and forth. Studios evolve; so will this one.

For now, the invitation is simple: stop prompting like a solo dev with a fancy autocomplete. Stand up your own AI studio. Give the models a room, a process, and a shared mission. Then direct the work like the piece is yours, because it is.

---

*Process note: I drafted this with Codex inside the studio. I defined the goals, prompts, and guardrails; Codex executed the heavy lift on prose and diagrams. Human direction, machine acceleration, including that silly sounding phrase.*</description>
    </item>
    <item>
      <title>How I'm integrating AI into my workflow for business acceleration</title>
      <link>https://setearth.io/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration/</link>
      <guid>https://setearth.io/writing/how-im-integrating-ai-into-my-workflow-for-business-acceleration.md</guid>
      <pubDate>Wed, 03 Sep 2025 00:00:00 GMT</pubDate>
      <description>![vibe vs ai](/images/writing/vibe-vs-ai.png) *Thanks, nano banana*
# How I'm integrating AI into my workflow for business acceleration

_Approx. 9 min read_

**TL;DR:** I shifted from browser-based AI to granting an agent (Claude Code CLI) access to my filesystem, terminal, and project context. That change, not IDE autocomplete, let me operationalize AI across the business: meeting intelligence that safely updates notes/CRM, faster strategic messaging and campaign execution, and requirements-to-implementation workflows. It only works because I wrapped AI in structure (validation, gates, context discipline) and, with LightForge Works starting from zero, designed AI‑native processes instead of retrofitting legacy ones. Think more waterfall than agile, keep context tight, and the speed gains are real.

## Where I Left Off

In my [previous posts](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) about vibe coding and multi-agent development, I ended up focused on the [AutoGen framework](https://github.com/microsoft/autogen) and [GitHub](https://github.com)-as-messaging-bus ideas. Then I sort of... stopped writing about the process for a few months.

Not because I stopped working. For me, everything changed in April when I started using [Claude Code CLI](https://claude.ai/code) with file system access, and I've been deep in the weeds figuring out what actually works.

I'd been using [ChatGPT](https://chatgpt.com) and [Claude](https://claude.ai) in browsers since 2023 - mostly for writing assistance and research. But [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) with file system access was a completely different beast. Suddenly AI could read my entire project structure, modify files directly, run commands, and maintain context across my whole workspace.

To be clear: developers have used AI code completion in IDEs like VS Code for years. As a business operator, I wasn’t living in an editor — the leap for me wasn’t autocomplete; it was granting an agent filesystem access, the terminal, and my full project context.

The last 4-5 months have been this rapid evolution - first figuring out basic development workflows, then MCP integrations started rolling out, and now I've got this integrated system where AI manages most of my operational workflows. But it's only been through using formal development processes (TDD, hooks, quality gates) that any of this has become reliable enough to trust with real business operations.

![GitHub Actions Screenshot](/images/writing/github-actions-screenshot.png) *A lot of messy automation*

The thing is, what I ended up building isn't really about coding anymore. It's become this integrated workflow where AI manages most of my operational stuff - meeting notes turn into CRM updates, competitive research becomes marketing campaigns, requirements conversations become actual applications. But it took months of debugging and process development to make it work consistently.

## The Clean Slate Advantage

This is the first time I’ve mentioned LightForge Works here, so a quick intro: LightForge Works (LFW) is our new company focused on building AI‑native workflows and products. We’re about 60 days in with a team of four. We build Single Purpose Applications (SPAs) with an integration‑first approach using a 30/60/90 framework (30 days discovery, 60 days delivery, ~90 days to ROI).

One thing that's probably important to mention: our new company, LightForge Works, is starting from zero. No legacy systems, no existing technical debt, no "that's how we've always done it" constraints.

This is a massive advantage that I don't think most established organizations appreciate. When you're building AI workflows from scratch, you can design everything around what actually works with AI rather than trying to retrofit AI onto existing broken processes.

Most companies are trying to layer AI on top of systems that were built 10+ years ago, with processes that were optimized for human workflows, not AI workflows. We get to build everything AI-native from day one.

## The Stuff That's Actually Working (After 4 Months of Trial and Error)

### Meeting Intelligence Pipeline (That Doesn't Corrupt My CRM, tasks or Obsidian notes)

Every meeting I have flows through this process now:
1. Recording gets transcribed
2. AI analyzes it with context from my entire [Obsidian](https://obsidian.md) vault (previous meetings, competitive intel, project status)
3. Generates structured notes, action items, and CRM updates
4. Everything gets validated and conflict-checked before updating systems

This sounds simple but took a while to get right. Early versions would miss context, generate vague action items, or overwrite existing CRM data. I had to build tons of validation logic and error handling.

AI needs way more structure and babysitting than you'd expect. But when you get it right, it's incredibly powerful because it has access to all your historical context.

### Strategic Messaging for LightForge Works

For our startup (we're only 60 days old with 4 employees), I can iterate on positioning and messaging incredibly fast now. Feed AI all our competitive research, customer conversations, and strategic thinking from [Obsidian](https://obsidian.md). It generates positioning angles, tests messaging variations, creates full HTML email campaigns with dynamic fields.

What used to take weeks with agencies now takes hours. But only because Claude has access to all our accumulated strategic thinking. Without that context, it just generates generic marketing fluff.

The workflow: Competitive intel → Strategic framework → Messaging variations → Campaign creation → [SendGrid](https://sendgrid.com) execution → [Attio](https://attio.com) tracking. All automated but with validation at each step.

This speed is crucial for a new company - we can test market positioning, iterate on messaging, and launch campaigns faster than competitors who are still doing this manually or fighting with legacy marketing systems.

### Requirements Development as Business Strategy

Building MCP connectors and micro-apps isn't really technical work anymore - it's strategic capability development. When I need a new integration (meeting transcripts ↔ project management, competitive intel ↔ sales workflows), I'm having strategic conversations with AI about what business processes need optimization.

The AI understands our business model, competitive situation, and operational constraints. So technical decisions become strategic decisions. But this only works because I've fed it business context through [Obsidian](https://obsidian.md).

## The Technical Stuff That Makes Business AI Reliable

### TDD Saves Your Ass (When AI Breaks Things)

Test-driven development isn't just good practice; it's essential when AI is managing business-critical workflows.

AI will confidently generate code that looks right but fails in edge cases. Or worse, it'll work fine in testing but break when it hits real customer data.

```python
def test_crm_contact_enrichment():
    meeting_data = load_test_transcript()
    contacts = extract_contacts_with_ai(meeting_data)
    assert len(contacts) &gt; 0  # AI sometimes returns empty results
    assert contacts[0].email is not None  # AI forgets required fields
    assert contacts[0].priority_score &lt;= 1.0  # AI doesn't respect bounds
```

Before TDD discipline: "Why did my CRM get corrupted again?"
After TDD discipline: AI can still mess up, but tests catch it before it matters.

### Hooks and Quality Gates (Because AI Doesn't Check Its Work)

Every AI workflow gets validated through pre-commit hooks:
- Content validation (is this email campaign actually coherent?)
- Business logic checks (does this CRM update make sense?)
- Integration testing (will this actually work with our systems?)
- Rollback capabilities (can we undo this if it goes wrong?)

This sounds like overkill until AI sends a broken email to your biggest prospect or corrupts your customer database. Then it feels essential. To be fair, it still does not always work and we have to keep a close eye on things, and not everything is totally automated, but we are getting there.

### Multi-Agent Coordination (When You Keep Them Simple)

The agent approach works, but not how I originally expected. It's not about AI collaboration - it's about keeping each AI focused on problems it can actually solve. The Claude subagents were a big reveal on how to use them, but it requires Claude hooks to enforce behaviors you want. I have a number of different agents with different purposes, and still struggle to get them to stay in their own lane (and working directory) but again, it's a work in progress.

Each agent has narrow, bounded responsibilities. When I try to make agents handle complex multi-step reasoning across different domains, they get confused and make bad decisions.

## The Stuff That's Still Frustrating

### UI/UX Work Is Still Painful

Building interfaces through the terminal is rough. Even with screenshots and detailed mockups, getting styling and interactions right takes forever. AI understands React conceptually but struggles with the visual details that matter.

I can get backends working reliably. Frontend work still feels like fighting with a very stubborn junior developer who can't see what they're building.

### Complex Business Rules

AI is great at following patterns and templates. When business logic gets complex - multiple edge cases, conflicting requirements, nuanced decision trees - AI starts making confidently wrong choices.

I've learned to keep business rules as simple as possible and validate everything twice. Sometimes three times.

### Deployment and DevOps Beyond GitHub → Vercel

The only deployment model I trust is [GitHub](https://github.com) → [Vercel](https://vercel.com). It works consistently. Our team has more sophisticated AWS deployment processes, but that's beyond my current capabilities. (I'm still figuring out basic networking concepts, honestly.)

## Process Insights That Actually Matter

### Structure First, Automation Second

Biggest mistake early on: trying to automate messy processes. AI just makes messy processes messier, faster.

I had to clean up my note-taking systems, standardize CRM workflows, and document decision-making processes before AI could help optimize them. AI amplifies whatever processes you already have - good or bad.

Starting from zero with LightForge Works was actually an advantage here - we are designing processes that work well with AI from the beginning instead of trying to retrofit AI onto broken human processes. And not just processes. For example, AI struggles in UX with modal pop ups and which page to refresh, and when. So, while modal pop ups are a normal UX design pattern, we are avoiding those and only opening full pages.

### Context Management Is Critical (And Hard)

The more business context you give AI, the better it performs - until suddenly it doesn't. Too much context and AI starts focusing on irrelevant details or contradicting earlier decisions.

I'm constantly tuning what context to include, how to structure information, and when to start fresh sessions. Context poisoning is real - if AI gets stuck in a troubleshooting loop, everything in that context becomes equally important to the actual work.

### Waterfall Actually Works Better (Counterintuitively)

This goes against modern development practices, but with AI, a more waterfall approach seems to work better. Requirements → Architecture → Implementation → Testing → Deployment.

AI handles ambiguity and changing requirements poorly. Better to spend time getting requirements right upfront than trying to iterate through uncertainty. (Though I'm wondering if this will change as models get better at reasoning.)

## The Honest Assessment

Five months in since starting with Claude Code CLI, I can build functional software and manage complex business workflows with AI assistance. Not elegant software. Not perfectly optimized workflows. But stuff that solves real problems and doesn't fall apart under normal usage.

AI is incredibly powerful when you build enough structure around it. Without that structure, it's just expensive autocomplete that occasionally breaks your stuff.

For LightForge Works, this means I can iterate on competitive positioning, generate marketing materials, and build workflow automation in hours instead of weeks. This speed advantage is crucial for a 60-day-old startup with 4 people - we can move faster than competitors who are still doing this stuff manually or fighting with legacy systems.

The clean slate advantage is real. Established organizations have to work around existing technical debt, legacy processes, and "the way we've always done things." We get to design everything around what actually works with AI.

![Gemini Generated Portrait](/images/writing/gemini-generated-portrait.png) *Still not that good looking*

I don't know if this approach scales to larger teams or more complex systems. I don't know if I'm building technical debt that'll bite me later. But I do know that having AI as a strategic thought partner with access to years of business context is genuinely transformative.

The real competitive advantage isn't the AI tools themselves - it's the integrated system that makes strategic thinking faster and immediately actionable. Competitors can copy individual tools, but they can't replicate years of accumulated business intelligence and workflow optimization.

And honestly, most of this acceleration has happened in just the last 3-4 months as MCP capabilities rolled out and my understanding of how to structure AI workflows improved. The rate of change is pretty disorienting.

***
*This post was written with Claude Code handling some of the structural editing while I focused on getting the actual experiences and insights right.*</description>
    </item>
    <item>
      <title>I think I am AI-engineering</title>
      <link>https://setearth.io/writing/i-think-i-am-ai-engineering/</link>
      <guid>https://setearth.io/writing/i-think-i-am-ai-engineering.md</guid>
      <pubDate>Wed, 03 Sep 2025 00:00:00 GMT</pubDate>
      <description>![](/images/writing/vibe-vs-ai.png) *Thanks, nano banana*
# I think I'm AI-engineering

## Where I Left Off (And What I Skipped Over)

In my [previous posts](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) about vibe coding and multi-agent development, I ended up focused on the AutoGen framework and GitHub-as-messaging-bus ideas. Then I sort of... stopped writing about the process for a few months.

Not because I stopped working. Because I was deep in the weeds figuring out what actually works and moving from haphazard "vibe coding" to something much more rigorous (even if it's not as rigorous as it needs to be yet). Something much more akin to AI supported engineering. I figured out GitHub actions and workflows, then moved on.

![](/images/writing/screenshot-2025-09-05-at-2.20.18-pm.png) *A lot of messy GH actions*

BTW - next post is my config at the moment.
## The Reality Gap in vibe coding

With "vibe coding" as a phrase raging (and I really hope is retired soon), people still wrongly believe that you can enter a prompt in a chatbot and an app will pop out, ready to go. Or that you can just stitch together a "bunch of agents" and tell them some vague idea - essentially abdicating your thinking to the agents - and they'll read your mind and build the app of your dreams.

This is silly.

What I've learned (am learning): AI is a powerful development accelerator. But only when you do the hard work of thinking through what you want to build and putting control structures and processes in place. The agents aren't magic. They're really good at executing well-defined tasks. They're terrible at reading your mind or making strategic decisions for you.

The real breakthrough isn't the AI doing your thinking. It's the AI doing the tedious implementation work while you focus on architecture, requirements, and business logic.

## The Stuff That Mostly Works

### Test-Driven Development (TDD) Saves My A**

I mentioned in my earlier post how some smart developer people I know introduced me to TDD. I cannot overstate how much this changed everything.

Before TDD: "Claude, make this work." *Three hours later* "Why is everything broken?"

After TDD: Write the test first. Make it fail. Then implement. If it passes, I know it works. If it fails, Claude can fix it.

The agents love TDD too. Give Claude a failing test and it will methodically work toward making it pass. No more endless troubleshooting loops.

```python
# This simple pattern has saved me (eh hem) hundreds of hours
def test_user_authentication():
    user = create_test_user()
    result = authenticate_user(user.email, user.password)
    assert result.is_authenticated == True
```

Write test. Run test. Watch it fail. Implement. Run test. Watch it pass. Move on.

### Hooks and Pre-commit Hooks Are Non-Negotiable

My flow now requires that nothing gets committed unless it passes (and even in between commits):
- Linting (flake8, ESLint)
- Type checking (mypy, TypeScript strict mode; Claude spits out tons of Typescript errors)
- Tests (pytest, jest)
- Code formatting (black, prettier)

This sounds like overkill, but it prevents the agents from going off the rails. Before hooks, Claude would write code that "looked right" but was actually garbage. Now if it doesn't pass the gates, it doesn't get saved.

![](/images/writing/screenshot-2025-09-04-at-4.21.21-pm.png)*It's a little hard to tell here, but Claude is running hooks before and after each tool call in a multi-agent sequence Gives much needed controls over what the orchestrating agent is doing. Bonus - tmux over ssh setup!*

The agents understand these constraints and work within them. It's like guardrails for AI development.

I was doing these in GitHub while using the Claude GitHub Actions, but have since starting adding hooks into the settings.json /hooks within Claude Code cli, which I find is faster (and uses my Max account rather than the API, so it's "cheaper"). The only downside is that I don't see under the covers as easily as when monitoring GH actions and issue work, and if I get tired or lazy, things can get fouled up.

### Multi-Agent Coordination (When Done Right)

The key insight from months of experimentation: agents need clear, bounded responsibilities. This is harder done than said.

What doesn't work:
- "Claude, build me an e-commerce site"
- Agents that try to do everything
- Complex inter-agent communication protocols (early I was doing it manually, which was fun, but tedious, time consuming and ultimately didn't control things well)

What does work (or is at least getting better and hooks and /agents help a ton):
- PM Agent: Requirements, coordination, status tracking only
- Backend Agent: API endpoints, data models, business logic only
- Frontend Agent: UI components, user interactions only
- Testing Agent: Test coverage, quality validation only

*These are example agents for a standard project, but I am finding increasing value in project specific agent prompts - particularly with structured sequences and shared, formatted outputs. dB integration is likely next*

Each agent has a narrow focus and clear handoff points. No overlap, no confusion about who does what. I try to get them to write status to a central tracking (json) but I am not consistent with this yet.

## The Stuff That Doesn't Work Well (Yet)

### UI/UX Development Is Still rough.

I can get backends working reliably. APIs, databases, business logic - the agents handle this well because it's deterministic.

But UI work? Still a nightmare. Building UX in the terminal is tough - even if you add screenshots for interpretation. The agents can write React components, but getting the styling right, making interactions feel smooth, handling responsive design - it requires too much back-and-forth iteration. It took me two hours to get Claude to write a Gartner Magic Quadrant. Then I did a mock up in PPT and it got it, once I told it to dumb down and use HTML and CSS (huh?).

![](/images/writing/screenshot-2025-09-03-at-5.16.50-pm.png) *Ugly and not at all what I specified*

v0 is much better, but introduces other challenges. For example, when you have your mockup most of the way there, you download the code and then have to refactor for your API layer. Annoying.  We've been experimenting with using agents to reverse engineer the UX code into functional and technical requirements, which is kind interesting, but also super annoying.
### Complex State Management

Complex React state patterns - the agents understand them conceptually but struggle with implementation details. They'll create stores that work in isolation but break when integrated.

I've learned to keep state management as simple as possible. Local component state where feasible, simple context for global state, avoid complex patterns until absolutely necessary. I am starting to look at using dB for state management

It seems there is a way to do this, maybe with the OTS code, but that is currently beyond my capabilities. Not my strength....yet.

### Deployment and DevOps

The only consistent deployment model I have at the moment is GitHub -&gt; Vercel. That is rock solid. Our team has a robust AWS deployment model, but also beyond my capabilities.

![[verceldeploy 3.png]] *Works well, but does it scale? No idea.*

## Process Insights That Surprised Me

### Waterfall Works Better Than Agile

This goes against most modern development practices, but with AI agents, a more waterfall-like approach seems to work better.

Requirements → Architecture → Implementation → Testing → Deployment

The agents need clear, complete requirements upfront. They don't handle ambiguity or evolving requirements well. Better to spend time getting the requirements right than trying to iterate through uncertainty.

If I am mocking something up in v0.app, I need to make sure the features are 90% of the way there before I dump it out (after asking for a clean architecture refactor). Kind of as noted above.

### Context Window Management Is Critical

The deeper into a session you get, the more Claude forgets your earlier decisions. I've learned to:
- Keep sessions focused on single features
- Use TodoWrite extensively to track state
- Start fresh sessions for major new features
- Document decisions immediately in the project's CLAUDE.md

There is a lot more To this, then just simply keeping an eye on what you put in your context window.  There's this notion of context poisoning in which things that show up in your context window that are irrelevant to what you want to do actually misguide the LLM such that it goes off and focuses on things that are not important.  The LLM really doesn't have a sense of what's important. So, for example, if it gets into a troubleshooting loop, everything inside the troubleshooting loop is equally important as the actual code that it's working on.  And that just causes a mess. So it's better to kill your context window and start over.

The down side of that is having to remember to clean up the mess of starting over often.

## The Honest Take

Five months in, I can build working software with AI assistance. Not elegant software. Not efficient software. But software that solves real problems and doesn't fall apart.

I don't know if this approach scales to larger teams or more complex systems. I don't know if I'm building technical debt that will bite me later.

But I do know that I can take an idea from concept to working prototype faster than I ever could before. And for someone who couldn't code at all six months ago, that feels pretty remarkable.

The key is accepting that this is a different discipline than traditional software development. It has different constraints, different patterns, different failure modes.

Once you stop trying to make it look like human development and start optimizing for what actually works with AI agents, it becomes much more productive.

![](/images/writing/gemini_generated_image_9plx7q9plx7q9plx-1.png) *What Gemini thought of my post. I'm not that good looking.*

***
*This post was written with Claude Code's assistance as part of documenting my ongoing AI development journey, but I did rewrite a ton of it manually.</description>
    </item>
    <item>
      <title>I think I built strategic AI intelligence</title>
      <link>https://setearth.io/writing/i-think-i-built-strategic-ai-intelligence/</link>
      <guid>https://setearth.io/writing/i-think-i-built-strategic-ai-intelligence.md</guid>
      <pubDate>Wed, 03 Sep 2025 00:00:00 GMT</pubDate>
      <description>![](/images/writing/vibe-vs-ai.png) *Thanks, nano banana*
# How I'm integrating AI into my workflow for business acceleration

## Where I Left Off (And What Changed Everything)

In my [previous posts](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) about vibe coding and multi-agent development, I ended up focused on the AutoGen framework and GitHub-as-messaging-bus ideas. Then I sort of... stopped writing about the process for a few months.

Not because I stopped working. Because everything changed in April when I started using Claude Code CLI with file system access, and I've been deep in the weeds figuring out what actually works.

I'd been using ChatGPT and Claude in browsers since 2023 - mostly for writing assistance and research. But Claude Code CLI with file system access was a completely different beast. Suddenly AI could read my entire project structure, modify files directly, run commands, and maintain context across my whole workspace.

The last 4-5 months have been this rapid evolution - first figuring out basic development workflows, then MCP integrations started rolling out, and now I've got this integrated system where AI manages most of my operational workflows. But it's only been through using formal development processes (TDD, hooks, quality gates) that any of this has become reliable enough to trust with real business operations.

![](/images/writing/screenshot-2025-09-05-at-2.20.18-pm.png) *A lot of messy automation*

The thing is, what I ended up building isn't really about coding anymore. It's become this integrated workflow where AI manages most of my operational stuff - meeting notes turn into CRM updates, competitive research becomes marketing campaigns, requirements conversations become actual applications. But it took months of debugging and process development to make it work consistently.

## The Clean Slate Advantage

One thing that's probably important to mention: our new company, LightForge Works, is starting from zero. No legacy systems, no existing technical debt, no "that's how we've always done it" constraints.

This is a massive advantage that I don't think most established organizations appreciate. When you're building AI workflows from scratch, you can design everything around what actually works with AI rather than trying to retrofit AI onto existing broken processes.

Most companies are trying to layer AI on top of systems that were built 10+ years ago, with processes that were optimized for human workflows, not AI workflows. We get to build everything AI-native from day one.

## The Stuff That's Actually Working (After 4 Months of Trial and Error)

### Meeting Intelligence Pipeline (That Doesn't Corrupt My CRM, tasks or Obsidian notes)

Every meeting I have flows through this process now:
1. Recording gets transcribed
2. AI analyzes it with context from my entire Obsidian vault (previous meetings, competitive intel, project status)
3. Generates structured notes, action items, and CRM updates
4. Everything gets validated and conflict-checked before updating systems

This sounds simple but took a while to get right. Early versions would miss context, generate vague action items, or overwrite existing CRM data. I had to build tons of validation logic and error handling.

AI needs way more structure and babysitting than you'd expect. But when you get it right, it's incredibly powerful because it has access to all your historical context.

### Strategic Messaging for LightForge Works

For our startup (we're only 60 days old with 4 employees), I can iterate on positioning and messaging incredibly fast now. Feed AI all our competitive research, customer conversations, and strategic thinking from Obsidian. It generates positioning angles, tests messaging variations, creates full HTML email campaigns with dynamic fields.

What used to take weeks with agencies now takes hours. But only because Claude has access to all our accumulated strategic thinking. Without that context, it just generates generic marketing fluff.

The workflow: Competitive intel → Strategic framework → Messaging variations → Campaign creation → SendGrid execution → Attio tracking. All automated but with validation at each step.

This speed is crucial for a new company - we can test market positioning, iterate on messaging, and launch campaigns faster than competitors who are still doing this manually or fighting with legacy marketing systems.

### Requirements Development as Business Strategy

Building MCP connectors and micro-apps isn't really technical work anymore - it's strategic capability development. When I need a new integration (meeting transcripts ↔ project management, competitive intel ↔ sales workflows), I'm having strategic conversations with AI about what business processes need optimization.

The AI understands our business model, competitive situation, and operational constraints. So technical decisions become strategic decisions. But this only works because I've fed it business context through Obsidian.

## The Technical Stuff That Makes Business AI Reliable

### TDD Saves Your Ass (When AI Breaks Things)

Test-driven development isn't just good practice; it's essential when AI is managing business-critical workflows.

AI will confidently generate code that looks right but fails in edge cases. Or worse, it'll work fine in testing but break when it hits real customer data.

```python
def test_crm_contact_enrichment():
    meeting_data = load_test_transcript()
    contacts = extract_contacts_with_ai(meeting_data)
    assert len(contacts) &gt; 0  # AI sometimes returns empty results
    assert contacts[0].email is not None  # AI forgets required fields
    assert contacts[0].priority_score &lt;= 1.0  # AI doesn't respect bounds
```

Before TDD discipline: "Why did my CRM get corrupted again?"
After TDD discipline: AI can still mess up, but tests catch it before it matters.

### Hooks and Quality Gates (Because AI Doesn't Check Its Work)

Every AI workflow gets validated through pre-commit hooks:
- Content validation (is this email campaign actually coherent?)
- Business logic checks (does this CRM update make sense?)
- Integration testing (will this actually work with our systems?)
- Rollback capabilities (can we undo this if it goes wrong?)

This sounds like overkill until AI sends a broken email to your biggest prospect or corrupts your customer database. Then it feels essential. To be fair, it still does not always work and we have to keep a close eye on things, and not everything is totally automated, but we are getting there.

### Multi-Agent Coordination (When You Keep Them Simple)

The agent approach works, but not how I originally expected. It's not about AI collaboration - it's about keeping each AI focused on problems it can actually solve. The Claude subagents were a big reveal on how to use them, but it requires Claude hooks to enforce behaviors you want. I have a number of different agents with different purposes, and still struggle to get them to stay in their own lane (and working directory) but again, it's a work in progress.

Each agent has narrow, bounded responsibilities. When I try to make agents handle complex multi-step reasoning across different domains, they get confused and make bad decisions.

## The Stuff That's Still Frustrating

### UI/UX Work Is Still Painful

Building interfaces through the terminal is rough. Even with screenshots and detailed mockups, getting styling and interactions right takes forever. AI understands React conceptually but struggles with the visual details that matter.

I can get backends working reliably. Frontend work still feels like fighting with a very stubborn junior developer who can't see what they're building.

### Complex Business Rules

AI is great at following patterns and templates. When business logic gets complex - multiple edge cases, conflicting requirements, nuanced decision trees - AI starts making confidently wrong choices.

I've learned to keep business rules as simple as possible and validate everything twice. Sometimes three times.

### Deployment and DevOps Beyond GitHub → Vercel

The only deployment model I trust is GitHub → Vercel. It works consistently. Our team has more sophisticated AWS deployment processes, but that's beyond my current capabilities. (I'm still figuring out basic networking concepts, honestly.)

## Process Insights That Actually Matter

### Structure First, Automation Second

Biggest mistake early on: trying to automate messy processes. AI just makes messy processes messier, faster.

I had to clean up my note-taking systems, standardize CRM workflows, and document decision-making processes before AI could help optimize them. AI amplifies whatever processes you already have - good or bad.

Starting from zero with LightForge Works was actually an advantage here - we are designing processes that work well with AI from the beginning instead of trying to retrofit AI onto broken human processes. And not just processes. For example, AI struggles in UX with modal pop ups and which page to refresh, and when. So, while modal pop ups are a normal UX design pattern, we are avoiding those and only opening full pages.

### Context Management Is Critical (And Hard)

The more business context you give AI, the better it performs - until suddenly it doesn't. Too much context and AI starts focusing on irrelevant details or contradicting earlier decisions.

I'm constantly tuning what context to include, how to structure information, and when to start fresh sessions. Context poisoning is real - if AI gets stuck in a troubleshooting loop, everything in that context becomes equally important to the actual work.

### Waterfall Actually Works Better (Counterintuitively)

This goes against modern development practices, but with AI, a more waterfall approach seems to work better. Requirements → Architecture → Implementation → Testing → Deployment.

AI handles ambiguity and changing requirements poorly. Better to spend time getting requirements right upfront than trying to iterate through uncertainty. (Though I'm wondering if this will change as models get better at reasoning.)

## The Honest Assessment

Five months in since starting with Claude Code CLI, I can build functional software and manage complex business workflows with AI assistance. Not elegant software. Not perfectly optimized workflows. But stuff that solves real problems and doesn't fall apart under normal usage.

AI is incredibly powerful when you build enough structure around it. Without that structure, it's just expensive autocomplete that occasionally breaks your stuff.

For LightForge Works, this means I can iterate on competitive positioning, generate marketing materials, and build workflow automation in hours instead of weeks. This speed advantage is crucial for a 60-day-old startup with 4 people - we can move faster than competitors who are still doing this stuff manually or fighting with legacy systems.

The clean slate advantage is real. Established organizations have to work around existing technical debt, legacy processes, and "the way we've always done things." We get to design everything around what actually works with AI.

![](/images/writing/gemini_generated_image_9plx7q9plx7q9plx-1.png) *Still not that good looking*

I don't know if this approach scales to larger teams or more complex systems. I don't know if I'm building technical debt that'll bite me later. But I do know that having AI as a strategic thought partner with access to years of business context is genuinely transformative.

The real competitive advantage isn't the AI tools themselves - it's the integrated system that makes strategic thinking faster and immediately actionable. Competitors can copy individual tools, but they can't replicate years of accumulated business intelligence and workflow optimization.

And honestly, most of this acceleration has happened in just the last 3-4 months as MCP capabilities rolled out and my understanding of how to structure AI workflows improved. The rate of change is pretty disorienting.

***
*This post was written with Claude Code handling some of the structural editing while I focused on getting the actual experiences and insights right.*</description>
    </item>
    <item>
      <title>My Development Setup: tmux, Tailscale, and Claude Agents</title>
      <link>https://setearth.io/writing/my-development-setup-tmux-tailscale-claude/</link>
      <guid>https://setearth.io/writing/my-development-setup-tmux-tailscale-claude.md</guid>
      <pubDate>Wed, 03 Sep 2025 00:00:00 GMT</pubDate>
      <description># My Development Setup: tmux, Tailscale, and Claude Agents

Five months ago I mentioned in ["The CLI LLM Agent Journey So Far"](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) that tmux felt "wildly daunting." Well, turns out I was wrong. tmux is now the backbone of my entire development workflow.

## The Multi-Agent Setup That Actually Works

Remember my original ["Vibe Coding"](/writing/my-vibe-coding-process-atm/) approach with multiple Claude Code CLI instances? The manual markdown coordination was killing me. Now I run everything through tmux sessions.

Here's what I typically have running:

### Session Architecture
```bash
# Main coordination session
tmux new-session -d -s "coord" "claude-code"

# Specialized agent sessions
tmux new-session -d -s "impl" "claude-code" # Implementer agent
tmux new-session -d -s "arch" "claude-code" # Architect agent
tmux new-session -d -s "qual" "claude-code" # Quality agent
tmux new-session -d -s "test" "claude-code" # Testing focus
```

The beauty? I can switch between contexts instantly with `tmux attach -t impl` or monitor multiple agents simultaneously with tmux's split panes. No more copy-paste hell between CLI instances.

## Remote Development Revolution

This is where Tailscale changed everything. I can code from anywhere - my MacBook, my iPad with a keyboard, even my phone in a pinch (don't judge). All my development sessions persist on my main machine while I connect remotely.

### The Workflow
1. **Morning**: SSH into my development machine via Tailscale
2. **Resume sessions**: `tmux list-sessions` shows all my active work
3. **Context switching**: Jump between different projects/agents instantly
4. **Evening**: Detach and keep everything running

The psychological effect is huge. I'm not losing context when I switch locations or devices. My development "state" just persists.

## Agent Coordination That Actually Works

My previous approach had agents writing markdown messages to each other. Cute, but inefficient. Now I use:

### Shared Context Files
Each tmux session monitors shared files:
- `/project/status.md` - Overall project state
- `/project/coordination.md` - Inter-agent communication
- `/project/todos.md` - Task tracking (TodoWrite integration)

### Real Communication Pattern
Instead of AI agents pretending to talk to each other, I orchestrate the handoffs:

1. **Architect agent** designs the system in `arch` session
2. I review, then switch to **Implementer agent** in `impl` session
3. **Quality agent** reviews implementation in `qual` session
4. **Testing agent** validates in `test` session

Human coordination, AI execution. Much cleaner.

## The LFW Business Context

This setup supports real client work now. My LFW business is at $2,500/month per application, and I need systems that scale. Can't afford context window disasters when clients are paying.

### Quality Gates Everywhere
Every session has the same quality standards:
- Pre-commit hooks must pass
- Tests must pass
- TypeScript strict mode enforced
- &gt;90% test coverage required

The tmux approach means I can monitor quality gates across multiple agents simultaneously. Game changer.

## Configuration That Matters

### tmux.conf Essentials
```bash
# Enable mouse support (controversial, I know)
set -g mouse on

# Better prefix key
unbind C-b
set-prefix C-a

# Session management
bind r source-file ~/.tmux.conf \; display "Reloaded!"
bind | split-window -h
bind - split-window -v
```

### Tailscale Setup
Pretty standard installation, but the magic is in the SSH config:
```bash
Host dev-machine
    HostName 100.x.x.x  # Your Tailscale IP
    User braydon
    Port 22
    ServerAliveInterval 60
```

## What I Got Wrong Before

In my earlier posts, I was fighting context window management manually. Turns out the solution isn't more sophisticated AI coordination - it's better human tooling.

The agents don't need to be smarter about communication. I need better tools to manage them efficiently.

## Current Challenges

### Session Management
Still figuring out optimal session organization. Do I create new sessions per project? Per agent type? Per client? Currently using a hybrid approach.

### Resource Usage
Running 4-5 Claude Code instances simultaneously hits token limits faster. Working on better session lifecycle management.

### Context Bleeding
Sometimes agents in different sessions reference each other's work without explicit handoff. Need better isolation.

## What's Next

Exploring automation of the session creation itself. Maybe a script that:
1. Creates tmux sessions for a new project
2. Initializes each with appropriate agent context
3. Sets up shared coordination files
4. Connects to project's GitHub repo

Also considering GitHub Codespaces integration. Remote tmux + Claude agents + Codespaces could be interesting.

## Real Impact

This setup delivered three client applications in the past month. The coordination overhead that was killing my previous workflow is mostly gone. I can focus on architecture and requirements while the agents handle implementation.

Still experimental. Still learning. But finally feeling like I have sustainable tooling for AI-assisted development.

---

*This development setup continues evolving. Next post will dive into the actual processes and workflows that make this coordination effective.*

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude &lt;noreply@anthropic.com&gt;</description>
    </item>
    <item>
      <title>My agentic model at the end of June 2025</title>
      <link>https://setearth.io/writing/the-agentic-model-for-the-moment/</link>
      <guid>https://setearth.io/writing/the-agentic-model-for-the-moment.md</guid>
      <pubDate>Mon, 30 Jun 2025 00:00:00 GMT</pubDate>
      <description>### Some context on my agentic coding usage

It's a little disorienting how fast things are changing in the agentic coding space. Even just using the words "agentic coding" is a shift that represents a new underlying model and framework for thinking about using llms for software development.  "Vibe coding" just feels so passé May.

I realize I was starting to frame it as agents in [My vibe coding process atm](/writing/my-vibe-coding-process-atm/) and [The CLI LLM Agent Journey So Far](https://dbmcco.github.io/2025/05/30/The-CLI-LLM-Agent-Journey-so-far/) but the process has certainly evolved.  The original goal of multiple Claude Code CLI instances was context window management - I had noticed that too many different directions in a single context window just leads to mayhem. But the manual model became onerous to manage the markdown interactions between instances. And whereas before was thinking I would build an [Autogen](https://github.com/microsoft/autogen) to do handoffs between instances as a way to reduce managing my communication load, instead I went in a different, better direction.

A couple of guys in the coding WhatsApp mentioned letting [GPT Codex](https://chatgpt.com/codex) or [Claude GitHub actions](https://docs.anthropic.com/en/docs/claude-code/github-actions) (GHA) trawl through GitHub issues.  That sounded crazy to me and maybe solved my "messaging bus" issues. After exploring a bit and a bunch of trial and error (in the age of AI, trial and error meant about 4 hours), I realized that rather than developing an AutoGen and hand tooling the quality gates, I could just stick almost everything in GitHub. And when TDD or GitHub pre-commit workflows don't catch all the quality issues, any other errors come out in the Vercel console during PR-&gt;main merges.  (not being a trained developer I feel a little like I'm an imposter on another planet when I use terms like that; c'est la via).

That said, I have not gotten the pre-work and planning into GitHub.  I wonder if that's a good idea.  Theoretically I could have a planning repo that builds/decomposes a Product Requirements Doc PRD into requirements (functional, architecture and technical) and then into prioritized, dependent and sequenced issues for work in GitHub, but I have not tried it; not sure I will.  At the moment, I have a mini-autogen hand off process that takes the PRD and does the full decomposition to markdown. After Jesse suggested using Claude Code SDK and I started using it and starting getting better at using it, I may sunset the autogen and just use SDK - and SDK uses my Max subscription which is cheaper than using Autogen with API.  That said, Autogen also allows me to challenge decomposition with different models. More on that below. Hmm.

*Just a note - I'm mainly working on building (and "building feels more appropriate than "developing") end-user web/app style products and app-to-app API connectors for workflow improvements. And a further note - all this process development effort is geared toward a single goal: operational readiness for our stealth custom software shop.*

### For the moment, here is my work process:  I know it's over-engineered and somewhat painful, not fully deterministic and fraught with problems.  It does actually deliver functioning applications.  _shrug_

- **Idea dev:** Use GPT o3 or Claude Opus, usually in a browser or app interface.  Work out as much of the logic as possible.  Copy and paste to a markdown file. I hate copy and paste, but here we are.

![](/images/writing/prd-gen.png) *Generating a PRD (or at least a general app definition and requirements doc) using Claude desktop.  I like to try to hash out workflow and logic here, not just definition of what it is, also how it works. This one is a two player dice game I came up with a few years ago.*

- **Repo start:** Initialize a local repo with my over-engineered [Claude Structure](https://github.com/dbmcco/claude-workspace). Create/connect a GitHub Repo.  Initialize the [GitHub repo with yml workflows and TDD/lint/pre-commit-hooks templates](https://github.com/dbmcco/github-tdd-template) (templates Claude created - just a side note - often Claude claims it's not following the TDD templates, but when I compare, they are exact.  So, maybe it is or not; not sure?). The GHA workflows step is really important to get right and test that it's working.  Then Create a Vercel instance (if appropriate), add in Neon for Postgres (if needed). Drop the PRD into the project directory.

![](/images/writing/init-dir.png)*Initializing a local repo.  This screenshot doesn't pick up creating .git but that's in there too.*

- **Requirements/Mock-up:** This is where things are shifting as I write up this process:  I had been doing mostly requirements dev but I'm recognizing the importance of doing mock ups before full requirements documentation. In my experience, buyers struggle to understand something until they see and touch a working prototype or mock up.  Giving them a mockup is super important when building for end-users and aligning to their needs. It also helps with satisfaction, buying motivation and roadmap development. That said, you also have to be careful you don't mock up something that is impossible to build within cost constraints.

	- **Requirements dev:**  Use Autogen to decompose the PRD into functional requirements, architecture requirements (with reference to our claude-imposed-tech-stack) and technical requirements; in that order. All output to markdown. Then I run it again (or Claude Code CLI) to challenge the requirements - what did we miss, what should we take out, what needs improvement.  This is important since I find Claude really, really, really, really likes to over-engineer things.  You have to explicitly tell it to watch out for over-engineering and to simplify.  Of course, then it goes to too far.  It's a dance.
		- I am starting to move to using Claude Code SDK for this process.  I tell Claude Code CLI " We are decomposing our PRD into requirements. Spawn N Claude Code SDK agents.  One set should develop functional requirements. One set should create architecture requirements and one should create technical requirements.  All agents need to adhere to our requirements templates and output to markdown.  You are the manager, monitor for quality."   It's not quite right yet.  I am trying a more sequenced approach with an "inspector agent" that gets mad a the agents when they don't behave correctly. More on that in a subsequent post.
	- **Mock up:** Use v0 and/or Claude Code CLI in a sub-directory in the local repo.
		- Once the mock up is where I want it, I use Claude Code CLI to review the notes and mock up to develop a combination of PRD and UX requirements, again all in markdown.  Then go back to AutoGen for decomposition.
			- Thinking of adding mermaid in but have not gotten there yet.  Goal is a "visual language" that a LLM can understand in text that does not use multi-modal capabilities due to context window flooding.
		- Unfortunately I am bad at remembering I need to use the TDD/linting/pre-commit hooks model even with basic HTML mockups.  I get impatient and just want to try to mock up locally, but invariably, everything goes down the tubes about 2 hours into a mock up project.  Does't seem terrible, but when AI allows you to move a mach speed, 2 hours is forever. And a mess is just a mess and throws any new context window into a tizzy. Be smart Braydon, use the process.

![](/images/writing/v0-mockup.png)  *Experimenting with v0. I prefer Claude Code CLI for visibility but I am wondering if v0 has more controls built in and so reduces overhead for mockups.*

- **Issues development:**  Work with Claude Code CLI to decompose issues.   Unfortunately, from this stage on, my lack of coding experience and skills requires me to put tighter and tighter boxes around the AI to check itself since I can't do that alone.  Thus:
	- I ask Claude to "review all foundational architecture and technical requirements, and create detailed issues for development using TDD/linting/pre-commit hooks and quality gates.  Pay attention to and document dependencies. No issue should be larger than 15 minutes of LLM development time."  I have no idea if it knows how long it would take to develop something; this guidance is intended mostly to keep the issues super small. Then I have it challenge those again for over-engineering. Claude LOVES to over-engineer. It seems to help. I need to be more consistent in following my process.
	- One thing I'm unsure about:  I currently have TDD tests in the same issue as the development.  I am not sure if I should break out the tests separately, or at least have the development in an issue comment.  Another hmm.
	- My work process here is not perfect or fully repeatable yet.  Sometimes I forget to have it write to local markdown and just have it start pushing issues to GH. That's dumb. Always follow the process Braydon.
		- One thing I need to nail down: do I create ALL issues at one time or iteratively as the project progresses?  Recently I experienced something I am calling "template drift" where the TDD template I had stopped working for the issues we were developing. I don't know why.  Maybe a context window issue?  This issue implies a need for more iterative issue management, but I'm not sure.

- **Project Management Gap:**  I need a better project management model.  Some of the guys create a markdown project plan doc that Claude CLI uses.  I had hoped having the GitHub issues as my central planning space would suffice; it does not.  I have recently started exploring using GitHub projects since it's supposed to be fully integrated; it's not - and more importantly Claude doesn't seem to know what to do with it. May have to just use the markdown project file way of doing it - something similar had been working for me when I was manually controlling different Claude Code CLI instances.

- **Total-ish AI Coding:** At the command line I have Claude CLI begin to add @claude to issues for development. The yml workflows handle quality gates.  I have it run as many in parallel as I can based on the dependencies.  It's fun to watch the GitHub console light up with the work going on.  Caveats:
	- I do have to add a little human intelligence here since it will do things like think that since the DataBase architecture is different than the middleware it can do both at the same time.  Which in principle this is possible, I find things just don't wire up well if you let it all run too far down the path.  And I have not figured out how to keep the two sets of issues in sync. Claude CLI does not seem thoughtful enough to handle that type of inter-dependent management.  Or maybe it's just me.
	- Since Claude CLI can't listen for events, to keep it rolling on issues, I tell it to "monitor ongoing issues with sleep every 90 seconds. Once the issue is complete, review for quality; if passed, PR and start the next issue. Merge once Epic is ready". 90 seconds seems to be a sweet spot since Claude appears to have a 2-minute timeout waiting for anything to run.  It will eventually give up after N cycles (not sure if this is intentional or not).  This way of working is hit or miss for completion. I am open to any ideas on how to keep Claude monitoring and running on multiple, sequenced issues.  Cron job?  Tmux (I don't think I can get this to work since Claude is a CLI app, not actually the CLI and I don't trust Claude to spit out headless Claude with appropriate instructions, although that it cool in principle. Ugh.
	- Even with TDD and instructions for linting and pre-commit hooks, @Claude GHA messes up and the issues break.  Claude CLI has to instruct @claude GHA to go and fix it.

![](/images/writing/gha-actions.png) *Watching Claude GHA work through actions is satisfying until it's not. GHA totally wrecked Google Authentication integration and I had to do a massive roll back. Then something in the context got further wrecked and now I have a mess on my hands.*

- **Pushing to "production:"** When Claude PR and merges to main, Vercel automatically picks up the commit and deploys either to a preview or production.  I think if we PR to a branch, it is a preview, if it's to main it's a merge.  I have not looked closely to see what my config is - need to do that.   If something doesn't work in the Vercel deploy, I can either manually copy the logs to the Claude CLI to add a comment to the appropriate issue for correction, or I can ask Claude to monitor the Vercel logs for errors. I've started to refrain from doing this since it adds mess to the context window.

![](/images/writing/vercel-deploymets.png) *Vercel deployments from GitHub is super slick and the logging console is a last line of defense against quality issues.*

### Some other notes on context window management.

Context windows are the boon and bane of LLM development. Based on how LLMs work, full context gets passed at each turn. This seems dumb to me, but it's an inherent limitation to how these tools function at the moment. Thus, keeping an ultra-clean and tight context window is proving to be critical. But balancing that with what you need for project and process specifics is tough.

I am using the recursive Claude memory capability with modular @ calls in projects and for parent directories.  It sometimes loads everything and sometimes does not.  If it does, that loads too much into the context window.   I have not gone into each of my /.claude files to see if they are consistent and are what is causing variability, but will.  I also instruct Claude to "update your claude.md project memory with where we are and what is next".  This has been my mechanism for ensuring consistently between context switches or compacts. But unless I go in an prune the Claude file, it can get unwieldy with status updates (wow does Claude like to congratulate itself how well it's doing).  This slop messes up the context window.

If Claude gets into a troubleshooting loop, this is a death spiral for context window management. I will stop and start a new interim window for analysis troubleshooting, and when that's complete, start a fresh context window to get development back on track.   GitHub actions has far less of this, but sometimes spins out of control.

And, if Jesse's [LACE](https://github.com/obra/lace) CLI has its way, a LOT of these issues will go away.  Get it done!</description>
    </item>
    <item>
      <title>The CLI LLM Agent Journey So Far</title>
      <link>https://setearth.io/writing/the-cli-llm-agent-journey-so-far/</link>
      <guid>https://setearth.io/writing/the-cli-llm-agent-journey-so-far.md</guid>
      <pubDate>Fri, 30 May 2025 00:00:00 GMT</pubDate>
      <description>---

At the moment, I'm building a multi-agent autogen, waterfall-style dev structure using [Claude code CLI](https://github.com/anthropics/claude-code) (with env for Codex and Ollama, and maybe [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code/sdk)). The goal is to keep Claude code CLI (or Codex or Ollama) inside a pretty tight box so it has to follow TDD, stick to the requirements, and keep the architecture sane on more complex projects. Since I'm not a trained developer, but I'm deeply familiar with process and infrastructure, the real goal is to use these structures to prevent the AI agent from things it thinks are smart and that I would never know if it is or not.

## The Beginning; six weeks ago

But - how I got here: I started off "vibe coding" in early April with [Replit](https://replit.com), which, while simple and helpful, as I attempted more complex workflows, quickly bogged down in endless troubleshooting and would break.

Then Claude CLI came out, with local file access, and my world opened up to being able to code in python and js (which I can't do myself) and suddenly everything was different. I was writing small programs to help me do basic things. And then I was writing more complex workflows that I couldn't get done in Replit.

## Context window issues (or maybe it's just me)

However, there were major issues: the context window would often get messy and confused (and spiral into endless troubleshooting loops) as I went in different directions and developing UX/UI was fraught with problems since I would need to standup local servers. I still don't really have an answer for the UX/UI dev. And frankly some of the first may have been due to my less well structured planning out of the gate.

## Multi-Agent Approach

But rather than delve into my own structural thinking issues, to solve the first problem, I started using multiple Claude instances - layering a somewhat traditional software dev team: product/project manager, architect, developer model. I wanted to see if a project manager might coordinate things better and also keep the context windows cleaner.

And this model helped a LOT with the context windows issue (and resulted in fewer auto-compacts, that would often wreck everything), but it presented a different challenge: there was no way to get the CLI instances to really talk to each other - you can't pipe i/o from one session to another (I tried. I have not tried TMUX, but that feels wildly daunting to me at the moment). So, I developed an async, markdown driven model, in which each instance would write updates back and forth.

![](/images/writing/screenshot-2025-05-31-at-4.45.44-pm.png)
*So many messages back and forth.*

This was WILD to read. In addition to the technical updates, each AI instance would write to the other instances as though they were on a team, using formal update language and encouraging words like "Great progress today developer!" and would give me updates similarly: "we are way ahead of schedule and making great progress!". It was pretty funny.

![](/images/writing/backend.png)
*The team would go back and forth complementing each other, even when they are totally wrong or didn't bother to inspect. Sounds like some real human teams.*

## Workflow Refinement

But initially they were making lots of errors. Meaning: one of the developers would claim to have written something that worked, but when I actually tested it, it was a total mess. And I would have to have the manager assign an analyst to go figure out what went wrong (this was meant to prevent the endless troubleshooting loop, and it did reduce it). And second, it is extremely tedious for me to constantly copy and paste into each context window CLI "go check the /[path to update doc] and give me the next prompt." I still do a bunch of this and am hoping Autogen (below) helps with this tedium.

I've recently had the lucky opportunity to WhatsApp hang with some incredibly smart, senior sw dev hackers who are pushing vibe coding way beyond what is seen commercially. They introduced me to [TDD](https://www.agilealliance.org/glossary/tdd/), [Linting](https://www.perforce.com/blog/qac/what-is-linting) and pre-commit hooks. Before this, I had a github account but never used it. And I had no idea what any of those things were. And I didn't have any idea of how to use git or github. But Claude Code CLI understood. I changed my model, and this changed everything. Again.

## Implementing TDD+Lint+Hooks

First, I had to retool my workflow and ensure the project manager followed a strict TDD+Lint+Hooks structure and forced all the sub-devs to use it in conjunction with our "communication_policy.md" And second, I had to make sure I stuck to it too - since sometimes, particularly when I was tired, I would just let them all go do whatever they wanted - I just wanted them to go finish the damn thing - but this always resulted in a mess.

At the same time I was moving to this model, Claude 4 came out, and CLI introduced ToDowrite as a tool. Both of these were enormous improvements in keeping Claude focused and successful. Between those changes and the new workflow, the error rate dropped a lot (anecdotally anyway; I didn't measure). And, at the same time, I started attempting to reduce the verbosity of the communication, and the proliferation of communication documents (this is still problematic once you get deep into a context window). I found that having a central coordination.md doc with tasks and updates in it is more effective than many time stamped, dev_1_udpate-2025-05-28-1425.md docs. Keep it simple - less context window confusion and filling, less wondering where the communcation updates live.

## Memory Structure Improvements

Then, since I have multiple projects underway in my local repo, taking a page from [Jesse Vincent](https://blog.fsck.com/) and Harper, I retooled a multi-project, modular claude.md memory structure so that memory would flow well between projects - and ideally my claude cli would adhere to my TDD rules. It's ok; not awesome. As usual, the deeper into the context window you get, the more Claude forgets. But using their "always call me [name]" it gives hints into how Claude is doing memory context wise.  Here's my [repo](https://github.com/dbmcco/claude-workspace)

![](/images/writing/screenshot-2025-05-31-at-10.28.04-am.png) *This cracks me up. I have explicitly stated in my claude.md, "don't blow smoke up my ass."  Clearly Claude is not listening. See "Bray.Doc"? That's what I force Claude to call me so I can assess how well it's remembering things. Since I have a modular claude structure, I am not sure how well the memory flows through to the other modules.*
## Exploring AutoGen

Around the same time, I encountered [Microsoft AutoGen](https://github.com/microsoft/autogen) framework, and I realized I might be able to pass messages between instances using API calls rather than CLI typed commands. So, using this TDD model, I began setting this up via python scripting. Unfortunately I keep realizing things I missed or could be improved: 1. using second pass LLM review/challenge/refine of functional requirements and 2. adding in a UX/UI requirements dev step (more on this particularly thorny issue) and 3. adding in a deployment step in the end. This framework is still underway. Claude tells me we're 80% of the way there. But who knows what that even means.

## Current Development Models

So now I have two development models (autogen style still not really ready yet): "Conversational" and "Unified Agent". The conversational one is where I am interacting with Claude CLI at the command line and still doing a lot of copy/paste of "you're the developer, here is your next prompt". And the Autogen one is a script based model that I review the outputs (via markdown and json) and let it run.

## What's old is new

All this is heading toward a somewhat waterfally-style dev approach (borrowed from amac's [recent thinking](https://www.bricoleur.org/2025/05/some-current-ai-coding-thoughts.html)) , but with some feedback loops in there. An interesting thing about working with LLM dev: you can just start over, throw out thousands of lines of code, and it doesn't matter. With that in mind, water fall is great. And, I have not been able to see how I can structure an agile model (other than some minor feedback loops). I actually am staring [Claude code CLI](https://github.com/anthropics/claude-code) (with env for codex and ollama, and maybe [Claude Code SDK](https://docs.anthropic.com/en/docs/claude-code/sdk)). The goal is to keep Claude code CLI (or Codex or Ollama) inside a pretty tight box so it has to follow TDD, stick to the requirements, and keep the architecture sane on more complex projects. Since I'm not a trained developer, but I'm deeply familiar with process and infrastructure, the real goal is to use these structures to prevent the AI agent from things it thinks are smart and that I would never know if it is or not.

## The Beginning; six weeks ago

But - how I got here: I started off "vibe coding" in early April with [Replit](https://replit.com), which, while simple and helpful, as I attempted more complex workflows, quickly bogged down in endless troubleshooting and would break.

Then Claude CLI came out, with local file access, and my world opened up to being able to code in python and js (which I can't do myself) and suddenly everything was different. I was writing small programs to help me do basic things. And then I was writing more complex workflows that I couldn't get done in Replit.

## Context window issues (or maybe it's just me)

However, there were major issues: the context window would often get messy and confused (and spiral into endless troubleshooting loops) as I went in different directions and developing UX/UI was fraught with problems since I would need to standup local servers. I still don't really have an answer for the UX/UI dev. And frankly some of the first may have been due to my less well structured planning out of the gate.

## Multi-Agent Approach

But rather than delve into my own structural thinking issues, to solve the first problem, I started using multiple Claude instances - layering a somewhat traditional software dev team: product/project manager, architect, developer model. I wanted to see if a project manager might coordinate things better and also keep the context windows cleaner.

And this model helped a LOT with the context windows issue (and resulted in fewer auto-compacts, that would often wreck everything), but it presented a different challenge: there was no way to get the CLI instances to really talk to each other - you can't pipe i/o from one session to another (I tried. I have not tried TMUX, but that feels wildly daunting to me at the moment). So, I developed an async, markdown driven model, in which each instance would write updates back and forth.

This was WILD to read. In addition to the technical updates, each AI instance would write to the other instances as though they were on a team, using formal update language and encouraging words like "Great progress today developer!" and would give me updates similarly: "we are way ahead of schedule and making great progress!". It was pretty funny.

![](/images/writing/screenshot-2025-05-31-at-10.28.04-am.png) *This cracks me up. I have explicitly stated in my claude.md, "don't blow smoke up my ass."  Clearly Claude is not listening. See "Bray.Doc"? That's what I force Claude to call me so I can assess how well it's remembering things. Since I have a modular claude structure, I am not sure how well the memory flows through to the other modules.*
## Workflow Refinement

But initially they were making lots of errors. Meaning: one of the developers would claim to have written something that worked, but when I actually tested it, it was a total mess. And I would have to have the manager assign an analyst to go figure out what went wrong (this was meant to prevent the endless troubleshooting loop, and it did reduce it). And second, it is extremely tedious for me to constantly copy and paste into each context window CLI "go check the /[path to update doc] and give me the next prompt." I still do a bunch of this and am hoping Autogen (below) helps with this tedium.

I've recently had the lucky opportunity to WhatsApp hang with some incredibly smart, senior sw dev hackers who are pushing vibe coding way beyond what is seen commercially. They introduced me to [TDD](https://www.agilealliance.org/glossary/tdd/), [Linting](https://www.perforce.com/blog/qac/what-is-linting) and pre-commit hooks. Before this, I had a github account but never used it. And I had no idea what any of those things were. And I didn't have any idea of how to use git or github. But Claude Code CLI understood. I changed my model, and this changed everything. Again.

## Implementing TDD+Lint+Hooks

First, I had to retool my workflow and ensure the project manager followed a strict TDD+Lint+Hooks structure and forced all the sub-devs to use it in conjunction with our "communication_policy.md" And second, I had to make sure I stuck to it too - since sometimes, particularly when I was tired, I would just let them all go do whatever they wanted - I just wanted them to go finish the damn thing - but this always resulted in a mess.

At the same time I was moving to this model, Claude 4 came out, and CLI introduced ToDowrite as a tool. Both of these were enormous improvements in keeping Claude focused and successful. Between those changes and the new workflow, the error rate dropped a lot (anecdotally anyway; I didn't measure). And, at the same time, I started attempting to reduce the verbosity of the communication, and the proliferation of communication documents (this is still problematic once you get deep into a context window). I found that having a central coordination.md doc with tasks and updates in it is more effective than many time stamped, dev_1_udpate-2025-05-28-1425.md docs. Keep it simple - less context window confusion and filling, less wondering where the communcation updates live.

## Memory Structure Improvements

Then, since I have multiple projects underway in my local repo, taking a page from [Jesse](https://blog.fsck.com) and [Harper](https://harper.blog/2025/02/16/my-llm-codegen-workflow-atm/), I retooled a multi-project, modular claude.md memory structure so that memory would flow well between projects - and ideally my claude cli would adhere to my TDD rules. It's ok; not awesome. As usual, the deeper into the context window you get, the more Claude forgets. But using their "always all me [name]" it gives hints into how Claude is doing memory context wise.

My modular Claude Code CLI memory [repo](https://github.com/dbmcco/claude-workspace)

## Exploring AutoGen

Around the same time, I encountered [Microsoft AutoGen](https://github.com/microsoft/autogen) framework, and I realized I might be able to pass messages between instances using API calls rather than CLI typed commands. So, using this TDD model, I began setting this up via python scripting. Unfortunately I keep realizing things I missed or could be improved: 1. using second pass LLM review/challenge/refine of functional requirements and 2. adding in a UX/UI requirements dev step (more on this particularly thorny issue) and 3. adding in a deployment step in the end. This framework is still underway. Claude tells me we're 80% of the way there. But who knows what that even means.

## Current Development Models

So now I have two development models (autogen style still not really ready yet): "Conversational" and "Unified Agent". The conversational one is where I am interacting with Claude CLI at the command line and still doing a lot of copy/paste of "you're the developer, here is your next prompt". And the Autogen one is a script based model that I review the outputs (via markdown and json) and let it run.

## What's old is new

All this is heading toward a somewhat waterfally-style dev approach (borrowed from amac's [recent thinking](https://www.bricoleur.org/2025/05/some-current-ai-coding-thoughts.html)) , but with some feedback loops in there. An interesting thing about working with LLM code dev: you can just start over, throw out thousands of lines of code, and it doesn't matter. With that in mind, water fall is great. And, I have not been able to see how I can structure an agile model (other than some minor feedback loops). I actually am staring to think that we have to rethink (or maybe regress) how we develop with LLM Agents - it's NOT human coding - it's something else entirely. Another post for another day.

## What's next - a new messaging bus?
In addition to finishing AutoGen.... 10+ years ago one of my first co-founders had done some kind of model where he used the Twitter API as a messaging bus for a different application.  The high throughput and small message size allowed for some effective controller applications (although now I don't recall what it was exactly). At that time Twitter allowed this kind of thing, but he wound up hitting it too hard and they cut him off. C'est la vie.

Recently there have been a bunch of new AI tools sitting on top of Github - [OpenAI's Codex](https://openai.com/index/introducing-codex/) being a really strong and interesting one. And Claude Code now has Github actions. To that end, it occurred to me that, for my multi-agent model I might be able to treat Gihub as a kind of old-twitter-esque messaging bus using Issues, tags and comments;  ito think that we have to rethink (or maybe regress) how we develop with LLM Agents - it's NOT human coding - it's something else entirely. Another post for another day.

## What's next - a new messaging bus?
In addition to finishing AutoGen.... 10+ years ago one of my first co-founders had done some kind of model where he used the Twitter API as a messaging bus for a different application.  The high throughput and small message size allowed for some effective controller applications (although now I don't recall what it was exactly). At that time Twitter allowed this kind of thing, but he wound up hitting it too hard and they cut him off. C'est la vie.

Recently there have been a bunch of new AI tools sitting on top of Github - [OpenAI's Codex](https://openai.com/index/introducing-codex/) being a really strong and interesting one. And Claude Code now has Github actions. To that end, it occurred to me that, for my multi-agent model I might be able to treat Gihub as a kind of old-twitter-esque messaging bus using Issues, tags and comments;  in which we have our PRD and requirements as a doc set, our issues/comments as instructions (depending on the tags associated with each) and code, is code.

If that works, then I can also have a docker creator agent and push straight to Render.com from Github.  That is where I want to get to.</description>
    </item>
    <item>
      <title>My 'Vibe Coding' Process ATM</title>
      <link>https://setearth.io/writing/my-vibe-coding-process-atm/</link>
      <guid>https://setearth.io/writing/my-vibe-coding-process-atm.md</guid>
      <pubDate>Wed, 28 May 2025 00:00:00 GMT</pubDate>
      <description># My "Vibe Coding" Process ATM

I've been experimenting with an approach I call "vibe coding" using multiple Claude Code CLI instances for complex projects. The goal is to create a more "repeatable, scalable and predictable" development process.

## Multi-Agent System

I use specialized agents with defined roles:

1. **Project Manager** - Coordination and planning
2. **Backend Developer** - Server-side implementation
3. **Frontend Developer** - UI/UX development
4. **Data Service Developer** - Data layer and APIs
5. **Data Analyst** - Analysis and insights
6. **Business Analyst** - Requirements and strategy
7. **Tester** - Quality assurance and validation

## Communication Flow

The workflow follows a "Request-Response-Next" pattern:
- Manual coordination between agents
- Structured directory management
- Emphasis on status tracking and todo management
- Clear handoffs between specialized roles

## Current Challenges

### Agent Coordination Issues
- Agents creating redundant scripts
- Inconsistent process following
- Context window management across sessions
- Asynchronous work coordination complexity

### Technical Limitations
- Managing state across multiple CLI instances
- Ensuring consistent project understanding
- Balancing autonomy with coordination

## Future Directions

I'm exploring several improvements:

### Orchestration Platforms
- **Microsoft AutoGen** for better agent orchestration
- **Headless Claude Code CLI** for programmatic control
- **Hybrid AI model approach** for specialized tasks

### Integration Enhancements
- Better pre-commit hooks integration
- Automated testing workflows
- Enhanced state management between agents

## Repository

The experimental setup is available at: https://github.com/dbmcco/claude-workspace

## Lessons Learned

This approach provides an in-depth look at AI-assisted software development, highlighting both current practices and areas for improvement. The key is finding the right balance between agent autonomy and coordinated execution.

The "vibe" aspect comes from letting the AI agents flow naturally while maintaining structure through defined roles and communication patterns.

---

*Originally published on [Substack](https://dbmcco.substack.com/p/my-vibe-coding-process-atm) on May 28, 2025. Migrated to this blog on May 29, 2025.*</description>
    </item>
    <item>
      <title>Building an Obsidian to Jekyll Workflow</title>
      <link>https://setearth.io/writing/obsidian-to-jekyll-workflow/</link>
      <guid>https://setearth.io/writing/obsidian-to-jekyll-workflow.md</guid>
      <pubDate>Sun, 25 May 2025 00:00:00 GMT</pubDate>
      <description># Building an Obsidian to Jekyll Workflow

After years of trying different note-taking and blogging systems, I've finally found a setup that works: **Obsidian for writing, Jekyll for publishing**.

## Why This Combination Works

**Obsidian Benefits:**
- Excellent writing environment with vim keybindings
- Powerful linking and graph features
- Local files in plain markdown
- Extensible with plugins

**Jekyll Benefits:**
- Static site generation
- GitHub Pages integration
- Flexible theming
- Great performance

## The Sync Process

My workflow is straightforward:

1. **Write** in Obsidian at `bvault/blog/`
2. **Sync** with a simple script that copies posts with front matter
3. **Publish** via git push to GitHub Pages

The magic is in the front matter - only files that start with Jekyll front matter get synced:

```yaml
---
layout: post
title: "Your Title"
date: 2025-05-25 10:00:00 -0500
categories: your categories
tags: [tag1, tag2]
---
```

## Next Improvements

I'm planning to enhance this with:
- Automatic image optimization
- Tag-based organization
- Draft management
- Automated publishing schedules

The goal is to make publishing as frictionless as possible while maintaining full control over the content.</description>
    </item>
    <item>
      <title>Addressing AI Anthropomorphism with clients</title>
      <link>https://setearth.io/writing/addressing-ai-anthropomorphism/</link>
      <guid>https://setearth.io/writing/addressing-ai-anthropomorphism.md</guid>
      <pubDate>Tue, 02 Apr 2024 00:00:00 GMT</pubDate>
      <description># Addressing AI Anthropomorphism with Clients

In our enterprise client work implementing Generative AI, the recurring challenge is the understanding gap between technical and non-technical stakeholders: what AI is and what it can do.

## The Perception Divide

Chat interfaces are now open to everyone, and misunderstandings about AI's capabilities have spread with them. Two perspectives have emerged:

### AI Anthropomorphism
- Non-technical users often attribute human-like qualities to AI systems
- Users interact with chatbots using human-centered language ("Can you please evaluate...")
- Creates unrealistic expectations about AI capabilities
- Triggers workplace replacement fears at individual and organizational levels

### AI Prudence
- Technical experts recognize AI's potential while remaining vigilant about limitations
- Understanding that AI only mimics human qualities without possessing them
- Recognition that increasingly powerful systems may have unexpected impacts
- Awareness of both technical limitations and integration challenges

## The Organizational Impact

These divergent perspectives create confusion among stakeholders and influence how organizations develop, implement, and perceive AI. In one client example, their dedicated team developing an internal domain-specific LLM works alongside general staff concerned about AI's impact on their daily responsibilities.

## Balancing Strategies

Organizations have to work toward a shared view through open discussion and policy guidance. The approaches we recommend, with AI-specific considerations:

### 1. Tailored Education
- Train all groups on AI's specific capabilities and limitations
- Develop interactive workshops with real use cases
- Provide "behind-the-scenes" data on how AI systems actually work
- Address misconceptions directly to enable better collaboration

### 2. Concrete Governance Guidelines
- Develop clear guidelines addressing bias, privacy, job impact, and wellbeing
- Explain the rationale behind guidelines and how they incorporate diverse perspectives
- Appoint dedicated leadership to oversee governance and address emerging concerns
- Create frameworks that balance innovation with responsible implementation

### 3. Transparent Feedback Channels
- Establish cross-functional working groups including both technical and non-technical staff
- Implement regular surveys and open forums for sharing insights and challenges
- Discuss specific implementation cases and how concerns were addressed
- Create psychological safety for expressing both enthusiasm and concerns

### 4. Aligning Values and AI Solutions
- Leadership must consider all perspectives equally when determining AI applications
- Craft solutions that balance technical potential with ethical implications
- Ensure alignment between AI implementation and company mission/values
- Develop flexible frameworks that can adapt as AI capabilities evolve

## Moving Forward

What reactions are you observing within your organizations? Are you implementing business frameworks (beyond IT governance) that recognize AI's transformative potential while maintaining implementation flexibility?

If you've addressed this perception gap in your organization, I'd like to hear what worked.</description>
    </item>
    <item>
      <title>The healthcare AI training data problem (and why your old EMR data is actually gold)</title>
      <link>https://setearth.io/writing/training-data-considerations-for-implementing-genai-llms-in-healthcare/</link>
      <guid>https://setearth.io/writing/training-data-considerations-for-implementing-genai-llms-in-healthcare.md</guid>
      <pubDate>Thu, 04 Jan 2024 00:00:00 GMT</pubDate>
      <description>I've been working with healthcare organizations on AI implementation for the past year, and there's this one problem that keeps coming up in every conversation: training data.

Everyone wants to build AI systems that understand their specific patient populations, clinical workflows, and organizational context. But when they look at the available training datasets, they're all generic, often outdated, and definitely not representative of their actual patient base.

And then someone in the room always says, "But we have decades of our own clinical data sitting in our EMR system. Can't we use that?"

That's when it gets concrete.

## The problem with public healthcare datasets

Most healthcare AI systems are trained on datasets like MIMIC-III, eICU, or various clinical trial datasets. These are great for research, but they have some pretty significant limitations when you're trying to build AI that works in real healthcare settings:

**They're not representative** - MIMIC-III is mostly data from Beth Israel Deaconess Medical Center. If you're a rural health system in Texas, your patient population probably looks very different.

**They're old:** A lot of these datasets are from 5-10 years ago. Healthcare changes fast, especially post-COVID. Treatment protocols, medication options, and patient care pathways have evolved.

**They're limited in scope** - Most public datasets focus on specific conditions or care settings. But healthcare AI needs to understand the full complexity of patient care across multiple conditions and touchpoints.

I was working with a health system last year that tried to implement a sepsis prediction model trained on one of these public datasets. The model performed great in testing, but when they deployed it in their ICU, the false positive rate was astronomical.

Turns out their patient population had different risk factors, their clinical documentation patterns were different, and their lab timing protocols didn't match what the model had been trained on.

## Why your archived data is actually perfect (and why you're not using it)

Here's what I keep explaining to healthcare CIOs: You already have the best possible training dataset for your organization. It's sitting in your EMR system right now.

You have years (sometimes decades) of clinical notes, lab results, diagnostic imaging reports, medication records, and outcome data. All specific to your patient population, your clinical workflows, and your documentation practices.

Nobody's using it for AI training;

**"It's messy"** - Real clinical data is messy. But that's actually a feature, not a bug. AI systems trained on messy, real-world data perform better in messy, real-world environments than systems trained on clean research datasets.

**"We don't have the technical expertise"** - This one's more legitimate. Most healthcare organizations don't have teams that know how to process clinical data for AI training. But this is a solvable problem.

**"Compliance and privacy concerns"** - Also legitimate, but there are established frameworks for using internal clinical data for AI development while maintaining HIPAA compliance.

## What I'm seeing work in practice

The healthcare organizations that are getting good results from AI are the ones that figured out how to use their own data effectively.

One health system I'm working with built a clinical decision support tool using 8 years of their own EMR data. The model can predict which patients are likely to need additional care coordination, which medications are most likely to cause adverse reactions in their specific patient population, and which discharge plans are most likely to lead to readmissions.

The key insight? They didn't try to build a general-purpose AI system. They built AI that understands their specific environment, patient base, and clinical workflows.

Another organization used their archived radiology reports to train a model that can flag imaging studies that might need expedited review. Not because the AI is making diagnostic decisions, but because it learned to recognize patterns in their radiologists' language that indicate urgency.

## The technical approach that's working

Here's the process that seems to be most effective:

**Start with a specific use case** - Don't try to build general-purpose medical AI. Pick one workflow or decision point where you have good data and clear success metrics.

**Use your EMR archive systematically** - Most EMR systems have been collecting structured and unstructured data for years. That's your training corpus.

**Focus on your organization's specific patterns** - The goal isn't to build AI that works everywhere. It's to build AI that works really well in your environment.

**Maintain human oversight** - These AI systems should augment clinical decision-making, not replace it. The models work best when they're designed to help clinicians be more effective rather than make autonomous decisions.

The health system with the sepsis prediction model? They eventually rebuilt it using their own EMR data. The new version has a much lower false positive rate and actually gets used by their clinical teams because it understands their specific patient population and care patterns.

## Why now

Healthcare organizations are under pressure to improve efficiency and outcomes while controlling costs. AI can help with all of that, but only if it's trained on data that reflects the actual environment where it's going to be deployed.

The organizations that figure out how to use their archived clinical data are going to have an advantage. Not because their AI is smarter, but because it's trained on data that actually represents their real-world challenges and patient populations.

And the ones that keep waiting for perfect public datasets or off-the-shelf solutions? They're going to keep struggling with AI systems that work great in research papers but don't translate to their actual clinical environment.

## The implementation reality

This isn't easy work. You need people who understand both clinical workflows and AI development. You need robust data governance processes. And you need leadership that's willing to invest in building internal AI capabilities rather than just buying vendor solutions.

But the organizations that are making this investment are seeing real results. Better clinical outcomes, more efficient workflows, and AI systems that actually get adopted by clinical teams because they're designed around real-world data and workflows.

Your EMR archive isn't just historical data - it's the foundation for AI systems that can actually improve patient care in your specific environment. The question is whether you're going to use it or keep waiting for someone else to solve this problem for you.</description>
    </item>
    <item>
      <title>Mixture of Experts models and why healthcare AI is about to get way more interesting</title>
      <link>https://setearth.io/writing/expanded-llms-in-life-science-and-health/</link>
      <guid>https://setearth.io/writing/expanded-llms-in-life-science-and-health.md</guid>
      <pubDate>Tue, 18 Jul 2023 00:00:00 GMT</pubDate>
      <description>I've been following the development of Mixture of Experts (MoE) language models for the past few months, and I think we're about to see some pretty significant breakthroughs in healthcare AI applications.

Most people are focused on general-purpose AI getting bigger and more capable. But MoE architectures solve a different problem - they let you build AI systems that are simultaneously very large and very specialized.

And that's exactly what healthcare needs.

## What Mixture of Experts actually means (and why it matters)

Traditional language models use all their parameters for every task. If you have a 175 billion parameter model, all 175 billion parameters are involved in every response, whether you're asking about poetry or protein folding.

MoE models work differently. They have multiple "expert" networks, each specialized for different types of tasks. When you ask a question, the model routes it to the most relevant experts and only uses those parameters.

So you might have one expert for clinical reasoning, another for drug interactions, another for medical imaging interpretation, and another for regulatory compliance. Each expert can be much smaller than a full-scale model, but together they can handle a much wider range of specialized tasks.

## Why this is perfect for healthcare applications

Healthcare AI has this fundamental challenge: you need models that understand both general medical knowledge AND very specific domain expertise.

A model that's great at general medical Q&amp;A might be terrible at interpreting radiology reports. A model that's excellent at clinical decision support might not understand pharmaceutical regulatory requirements.

But with MoE architectures, you can have both. You can build models that route cardiology questions to cardiology experts, route drug interaction queries to pharmacology experts, and route regulatory questions to compliance experts.

I've been working with a health system that's experimenting with this approach. They have different expert models for:

- **Clinical documentation** - Trained on their specific EMR templates and documentation patterns
- **Drug interactions** - Specialized in their formulary and prescribing protocols
- **Diagnostic reasoning** - Focused on their patient population and common conditions
- **Care coordination** - Understanding their referral networks and care pathways

The routing system sends each query to the most relevant expert, and the results are significantly better than what they were getting from general-purpose medical AI.

## The technical stuff that makes this work

The breakthrough isn't just the MoE architecture - it's that you can now train these expert models on much smaller, more focused datasets.

Instead of needing millions of general medical texts, you can train a cardiology expert on a few thousand high-quality cardiology cases. You can train a radiology expert on annotated imaging reports from your specific institution.

And because each expert is smaller, you can iterate and improve them much faster than you could with a massive general-purpose model.

One pharmaceutical company I'm working with has built MoE systems for different stages of drug development. They have experts for:

- **Early research** - Trained on scientific literature and patent databases
- **Clinical trials** - Specialized in protocol design and regulatory submissions
- **Manufacturing** - Focused on chemistry, manufacturing, and controls documentation
- **Commercial** - Understanding market access and health economics

Each expert uses different training data and optimization approaches, but they all work together through the same interface.

## Real-world applications that are working now

The most interesting implementations I'm seeing aren't trying to replace human expertise - they're augmenting it by routing queries to AI systems that understand specific domains really well.

**Clinical decision support** - Route patient cases to expert models based on chief complaint, primary diagnosis, or clinical specialty. A chest pain case goes to the cardiology expert, a medication question goes to the pharmacology expert.

**Medical communications** - Different experts for different types of content. Scientific writing goes to one expert, patient education goes to another, regulatory submissions go to a third.

**Research and development** - Route questions about mechanisms of action to the pharmacology expert, questions about clinical trial design to the biostatistics expert, questions about regulatory strategy to the compliance expert.

The key insight is that routing can be much more sophisticated than just "medical vs. non-medical." You can route based on clinical specialty, type of question, intended audience, regulatory context, or any other dimension that matters for your use case.

## Why this approach is winning

Traditional healthcare AI tries to build one model that's good at everything medical. But medicine isn't one domain - it's dozens of highly specialized domains that happen to work together.

MoE architectures let you build AI systems that reflect that reality. You can have deep expertise in multiple areas without the computational cost and complexity of training massive generalist models.

And because each expert is smaller and more focused, you can train them on proprietary data that's specific to your organization. A health system can train experts on their own clinical data. A pharmaceutical company can train experts on their research pipeline.

The resulting AI systems understand both general medical knowledge and the specific context where they're being deployed.

## What's coming next

I think we're going to see MoE become the dominant architecture for enterprise healthcare AI over the next 2-3 years.

Not because it's technically superior to other approaches, but because it maps so well to how healthcare actually works. Medical expertise is specialized, data is domain-specific, and use cases require deep knowledge in narrow areas.

The healthcare organizations that are moving fastest on this are the ones that:

1. Started with specific use cases rather than trying to build general-purpose medical AI
2. Invested in training expert models on their own data and workflows
3. Built routing systems that understand the context and intent of different types of queries
4. Focused on augmenting human expertise rather than replacing it

And they're seeing results that are much better than what they got from general-purpose AI tools, even very sophisticated ones.

## The implementation reality

This isn't plug-and-play technology yet. Building effective MoE systems requires understanding both the technical architecture and the specific domain you're trying to address.

But the organizations that are investing in this approach are building AI systems that their competitors can't easily replicate. Because the real value isn't in the MoE architecture itself - it's in the expert models that are trained on proprietary data and optimized for specific organizational contexts.

That's a sustainable competitive advantage in a way that using off-the-shelf AI tools isn't.

---

*If you're working on healthcare AI implementation or thinking about MoE architectures for your organization, I'd be interested to hear what approaches you're considering. The technical landscape is changing fast, but the fundamental need for specialized expertise seems pretty consistent.*</description>
    </item>
  </channel>
</rss>
