<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Jason Waldrip</title>
    <description>The latest articles on DEV Community by Jason Waldrip (@imacto).</description>
    <link>https://dev.to/imacto</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F2550107%2F119c2b03-47bd-4672-b337-db032d1e797e.jpg</url>
      <title>DEV Community: Jason Waldrip</title>
      <link>https://dev.to/imacto</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/imacto"/>
    <language>en</language>
    <item>
      <title>Build the Tracks</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Sat, 07 Nov 2026 21:00:11 +0000</pubDate>
      <link>https://dev.to/imacto/build-the-tracks-16b9</link>
      <guid>https://dev.to/imacto/build-the-tracks-16b9</guid>
      <description>&lt;p&gt;I’ve hedged my career on building the tracks: the infrastructure that lets a team move software from an idea into production quickly and safely.&lt;/p&gt;

&lt;p&gt;For a long time, I thought of those tracks as starting where the code was written. Build pipelines. Test suites. Deployment automation. Make the thing an engineer produces safe to release, and make releasing it cheap enough to do whenever it’s ready.&lt;/p&gt;

&lt;p&gt;I still believe in that work. But the tracks start earlier now. They start where the idea forms.&lt;/p&gt;

&lt;h3&gt;
  
  
  the competition can come from anywhere
&lt;/h3&gt;

&lt;p&gt;In early October, software engineer Brandon Thomas released &lt;a href="https://getartcraft.com/apps" rel="noopener noreferrer"&gt;ArtCraft&lt;/a&gt;, a collection of open-source applications built with AI that take aim at seven Adobe products, including Photoshop, Illustrator, and Premiere. The initial versions appeared within days of the first code being committed, according to an &lt;a href="https://www.softwareimprovementgroup.com/blog/artcraft-adobe-clone-ai-code-quality/" rel="noopener noreferrer"&gt;analysis of the project’s public history&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;They’re early software. Thomas himself said the apps were &lt;a href="https://news.ycombinator.com/item?id=49958850" rel="noopener noreferrer"&gt;“not anywhere close to ready”&lt;/a&gt;, and the PhotoCraft project says it isn’t yet a Photoshop replacement for daily professional work. Matching Adobe’s depth, compatibility, and reliability remains a much bigger job than producing a first version.&lt;/p&gt;

&lt;p&gt;But a competitor doesn’t need to match every feature your product has. They need to solve enough of a customer’s problem to give that customer a reason to leave.&lt;/p&gt;

&lt;p&gt;And the competitor might not be another software company.&lt;/p&gt;

&lt;p&gt;Imagine your customer has asked for the same report or workflow for months. Your team has a roadmap, a backlog, and a release cycle. Their finance manager has a weekend, access to an AI agent, and a clear understanding of what the department needs.&lt;/p&gt;

&lt;p&gt;If that person can build a tool that handles their part of the job, how much of your product do they still need?&lt;/p&gt;

&lt;p&gt;The finance manager may never reproduce the whole platform. They don’t have to. They only have to replace the piece their team uses and decide that maintaining it themselves is worth more than waiting for you.&lt;/p&gt;

&lt;h3&gt;
  
  
  what feeds the factory?
&lt;/h3&gt;

&lt;p&gt;Look at the route an idea can take through a software company. Someone hears a customer’s problem and brings it to product. Product puts it on a roadmap. A product manager writes a brief. Design makes mockups. The work moves through review, gets turned into tickets, and eventually reaches engineering.&lt;/p&gt;

&lt;p&gt;Each person can add something valuable. Each handoff also makes the idea wait.&lt;/p&gt;

&lt;p&gt;You can give your agents the capacity of a massive lake. If ideas reach them through a narrow stream of briefs, mockups, and tickets, the lake never fills. You’ve built a factory that can produce more than your organization knows how to ask it to make.&lt;/p&gt;

&lt;p&gt;Adding AI to each step doesn’t fix the shape of that process. The designer makes a mockup faster, then hands it to product. Product writes the spec faster, then hands it to engineering. Engineering writes the code faster. The work still waits at every boundary.&lt;/p&gt;

&lt;p&gt;In &lt;a href="https://jasonwaldrip.com/writing/the-agnostic-builder/" rel="noopener noreferrer"&gt;The Agnostic Builder&lt;/a&gt;, I wrote about the understanding people already carry beyond their job titles. A designer has heard the API discussions. An engineer has seen the places customers struggle. A product manager understands tradeoffs that never make it into the ticket. Agents give each of them a way to act on more of that knowledge.&lt;/p&gt;

&lt;p&gt;Bring those perspectives together when the idea forms. Give the agents the customer’s problem, the decisions already made, the design system, the technical boundaries, and a way to exercise the result. Let the people with the expertise shape the work across disciplines instead of waiting for the artifact to reach their part of the org chart.&lt;/p&gt;

&lt;p&gt;The tracks begin there: at the point where an idea has enough context to become something someone can try.&lt;/p&gt;

&lt;h3&gt;
  
  
  a release cycle is still a queue
&lt;/h3&gt;

&lt;p&gt;Once the work is ready, it has to reach the customer.&lt;/p&gt;

&lt;p&gt;If your release cycle takes weeks, or even days, you’re moving too slowly. Agents can write code that can be verified and released multiple times a day. A company built to do that can put improvements in customers’ hands sooner and respond to problems sooner, too.&lt;/p&gt;

&lt;p&gt;Think about what happens when a customer reports a bug. An agent can investigate, reproduce the failure, write a fix, and run it through the release process. With the right tracks in place, that fix doesn’t have to sit in a batch waiting for the next release window.&lt;/p&gt;

&lt;p&gt;A human can review the change, but requiring a person to inspect every line makes that person the release mechanism. As agents produce more work, the review queue grows.&lt;/p&gt;

&lt;p&gt;Engineering teams need to build a different mechanism. Tests need to exercise behavior that matters. Agents need environments where they can run the software, find failures, and correct them. Security controls need to enforce the boundaries people have decided on. Deployment systems need to detect failures, stop bad releases, and support recovery.&lt;/p&gt;

&lt;p&gt;That is engineering work. It takes the judgment that used to be applied one change at a time and puts it into the system carrying those changes.&lt;/p&gt;

&lt;h3&gt;
  
  
  the tracks have to earn the speed
&lt;/h3&gt;

&lt;p&gt;The train can only move as fast as the tracks it’s built on.&lt;/p&gt;

&lt;p&gt;I’ve also written that &lt;a href="https://jasonwaldrip.com/writing/the-tracks-were-never-the-limit/" rel="noopener noreferrer"&gt;the tracks are what keep the train on the ground&lt;/a&gt;. That still holds. The difference here is where they begin: a safe release path needs a way for the right work to reach it.&lt;/p&gt;

&lt;p&gt;I’ve spent my career arguing that the tracks matter. Now I think they’re table stakes. If your company doesn’t have the infrastructure to move fast, stop and focus on building it. Until you do, every new AI tool you add is feeding work into the same constrained process.&lt;/p&gt;

&lt;p&gt;Those tracks run from the first idea through the moment a customer uses the result. They carry the context an agent needs to understand the problem, the expertise that shapes the solution, and the controls that determine whether it’s ready to release.&lt;/p&gt;

&lt;p&gt;This is the direction of a dark factory: humans bring the ideas, expertise, and judgment. They define the outcomes and build the controls. Agents carry the work through production.&lt;/p&gt;

&lt;p&gt;Getting there takes more than turning on an AI coding tool. A test suite that passes everything is no better than a reviewer who approves everything. A deployment pipeline that can’t detect a broken release delivers the failure faster. The tracks have to earn the speed.&lt;/p&gt;

&lt;p&gt;Your customer doesn’t care which department owns the ticket if it takes you longer to solve their problem than it takes them to build something themselves.&lt;/p&gt;

&lt;p&gt;Written with AI assistance. The argument and direction are mine; AI helped draft the essay and find the sources linked above.&lt;/p&gt;

</description>
      <category>infrastructure</category>
      <category>devops</category>
      <category>agents</category>
      <category>cicd</category>
    </item>
    <item>
      <title>The Agnostic Builder</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Fri, 06 Nov 2026 21:00:10 +0000</pubDate>
      <link>https://dev.to/imacto/the-agnostic-builder-4n76</link>
      <guid>https://dev.to/imacto/the-agnostic-builder-4n76</guid>
      <description>&lt;p&gt;A designer sits through a product review and hears why a customer keeps getting stuck. She knows what needs to change. She also knows the route that idea will take: a conversation with product, a spec, a design, a ticket, and a wait for an engineer to pick it up.&lt;/p&gt;

&lt;p&gt;She’s been in enough technical discussions to understand the constraints. She’s watched the team make tradeoffs between the interface and the API. She has an idea for both. The part she couldn’t do was make them work.&lt;/p&gt;

&lt;p&gt;Now she can sit down with an agent and try.&lt;/p&gt;

&lt;p&gt;What she gets back may be wrong. The agent might misunderstand a business rule, miss a security boundary, or produce a screen that looks right and falls apart when someone uses it. She’ll still need to direct it, exercise the result, and bring in other people when the work reaches beyond what she understands.&lt;/p&gt;

&lt;p&gt;But she no longer has to wait for a handoff to find out whether her idea works.&lt;/p&gt;

&lt;h3&gt;
  
  
  the box on the org chart
&lt;/h3&gt;

&lt;p&gt;We organized software teams around the difficulty of implementation. Writing production code took a set of skills. Designing an interface took another. Product management connected the customer’s problem to the work those people could do.&lt;/p&gt;

&lt;p&gt;Each discipline developed expertise worth having. Each also became a box on an org chart, with a handoff at the edge.&lt;/p&gt;

&lt;p&gt;I described the agnostic builder as someone who can see across those boxes and act on that understanding. AI has made that idea more practical than it was when I first wrote about it. An agent can read a codebase, make changes, run tests, open the application, and use a browser to exercise what it built. Give it access to the right tools and it can investigate a failure, change course, and try again.&lt;/p&gt;

&lt;p&gt;OpenAI described &lt;a href="https://openai.com/index/harness-engineering/" rel="noopener noreferrer"&gt;one internal product team’s experience&lt;/a&gt;: its agents wrote application code, tests, documentation, and tooling. The engineers made the application, logs, and metrics accessible to those agents so they could inspect their own work. The team also made clear that its results depended on that environment. Giving an agent a task is not the same as giving it a way to know whether it succeeded.&lt;/p&gt;

&lt;p&gt;That distinction matters to the designer in the product review. She can direct an agent across the interface, API, and tests. Whether the result deserves to ship depends on the context and feedback available to both of them.&lt;/p&gt;

&lt;h3&gt;
  
  
  you already know more than your title says
&lt;/h3&gt;

&lt;p&gt;The designer has sat through the API discussions. The engineer has watched customers struggle with an interface. The product manager has spent years hearing why a technically plausible idea won’t work for the business.&lt;/p&gt;

&lt;p&gt;None of them automatically knows everything about the other disciplines. But each has learned things outside the work their title says they own. For a long time, acting on that knowledge meant finding someone with the implementation skill and enough room in their queue.&lt;/p&gt;

&lt;p&gt;The designer can now ask an agent to change the API and show her the result in a running product. The engineer can explore the interface with the same tools. The product manager can take a customer’s workflow, build a version, and discover where the original request left questions unanswered.&lt;/p&gt;

&lt;p&gt;That changes the conversation between them. Instead of handing off a description and waiting, they can work on the same problem together, with something in front of them that can be exercised and changed.&lt;/p&gt;

&lt;p&gt;The expertise still matters. A designer can see where a flow fights the person using it. An engineer can recognize a boundary the proposed change would break. A product manager can explain why the customer needs the exception that looks unnecessary in the spec. The builder has to know enough to use those perspectives, and enough to know when to ask for one.&lt;/p&gt;

&lt;h3&gt;
  
  
  the work is holding the whole picture
&lt;/h3&gt;

&lt;p&gt;I wrote in &lt;a href="https://jasonwaldrip.com/writing/still-the-painter/" rel="noopener noreferrer"&gt;Still the Painter&lt;/a&gt; that your capability didn’t go down when generation got cheap. It went up. The judgment you used to express through the work of your own hands can now reach further.&lt;/p&gt;

&lt;p&gt;The same applies across a software team. Your expertise is still yours. You can use it to direct work that used to stop at the edge of your discipline.&lt;/p&gt;

&lt;p&gt;The designer’s eye helps choose between working alternatives. The product manager’s understanding helps decide which problem deserves to be solved. The engineer’s experience helps shape a system that can keep working as it changes. An agent can help each of them explore the parts they couldn’t previously implement themselves.&lt;/p&gt;

&lt;p&gt;That comes with a responsibility. Once you can make a change across the whole system, you have to care about more of the system. The interface, the data it exposes, the business rule behind it, and the path it takes to production are connected whether your title acknowledges them or not.&lt;/p&gt;

&lt;p&gt;And agents are capable of getting the connections wrong. In &lt;a href="https://arxiv.org/abs/2606.07682" rel="noopener noreferrer"&gt;SWE-Marathon&lt;/a&gt;, a research benchmark of 20 long-horizon tasks, the authors found failures involving weak self-verification and premature termination. That is a small, specific set of tasks, not a verdict on every agent. It is enough to make the point that a finished-looking result still needs evidence.&lt;/p&gt;

&lt;h3&gt;
  
  
  the organization has to move too
&lt;/h3&gt;

&lt;p&gt;A person can adapt and still be stopped by the company around them.&lt;/p&gt;

&lt;p&gt;Give a product manager an agent, then require every idea to pass through the same sequential design and engineering queues, and you’ve put the old walls back. Let a designer build a working version, then measure her solely on how many design artifacts she hands off, and you’ve told her where her job ends.&lt;/p&gt;

&lt;p&gt;The way into this can be gradual. A team can use agents inside its existing disciplines while it learns what they can do and where they fail. But the opportunity opens up when people can work across those disciplines together, bringing their expertise to one continuous problem instead of passing artifacts from one queue to the next.&lt;/p&gt;

&lt;p&gt;That also changes what you look for when you hire, develop, and promote people. Depth still has value. So does the ability to understand how a customer’s need, a design choice, and a technical constraint affect one another. A team needs room for both.&lt;/p&gt;

&lt;p&gt;The question I keep coming back to is how much understanding is already sitting inside your company, waiting for permission to cross a line on the org chart.&lt;/p&gt;

&lt;p&gt;Written with AI assistance. The original argument and direction are mine; AI helped revise the essay and find the sources linked above.&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>ai</category>
      <category>agents</category>
      <category>product</category>
    </item>
    <item>
      <title>The Pace Doesn't Ship</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Thu, 05 Nov 2026 21:00:31 +0000</pubDate>
      <link>https://dev.to/imacto/the-pace-doesnt-ship-24j1</link>
      <guid>https://dev.to/imacto/the-pace-doesnt-ship-24j1</guid>
      <description>&lt;p&gt;You finish the engagement on a Friday. The repo is clean, the pipeline is green, the agent guides in it are current, and the runbooks are better than the ones you inherited. You walk the team through all of it and they ask good questions. Three months later their first real change takes eleven days. Nothing is broken. Nobody is lost about where the code lives. They just can't drive the thing at the speed you drove it, and nothing you left behind explains the gap.&lt;br&gt;
I've been on the receiving end of that handoff more than once, and I've written about what it leaves behind: &lt;a href="https://jasonwaldrip.com/writing/one-copy-per-customer/" rel="noopener noreferrer"&gt;per-customer bundles&lt;/a&gt;, &lt;a href="https://jasonwaldrip.com/writing/no-code-is-a-loan/" rel="noopener noreferrer"&gt;backends stranded in a visual builder&lt;/a&gt;. Both times I read the problem as architecture, because architecture is the part you can see in a repository. The architecture was downstream. Every one of those customizations was a fast yes, arrived at honestly, by someone solving the problem in front of them. Not one of them came with a way for the next person to deliver the next one.&lt;br&gt;
I'd like to look at that straight now, because I'm the one delivering fast.&lt;/p&gt;

&lt;h3&gt;
  
  
  go count what actually transfers
&lt;/h3&gt;

&lt;p&gt;Take the platform I'm building at &lt;a href="https://jasonwaldrip.com/works/" rel="noopener noreferrer"&gt;Phoneware&lt;/a&gt; and sort it into two piles.&lt;br&gt;
The first pile ships. A TypeScript monorepo is a repository, and a &lt;a href="https://jasonwaldrip.com/writing/a-monorepo-is-a-context-boundary/" rel="noopener noreferrer"&gt;monorepo is a context boundary&lt;/a&gt; that a new team can load as easily as I can. &lt;a href="https://jasonwaldrip.com/choices/gitops/" rel="noopener noreferrer"&gt;Terraform and GitOps&lt;/a&gt; mean the infrastructure and the deploy path are files in that repo. Canary targeting is configuration. The agent guides are checked in. The workboard the fleet tracks has a URL the client owns. All of it conveys on the last day, and most of my case for doing the work this way is that it does.&lt;br&gt;
The second pile is a folder of 36 rules that my fleet loads before it does anything, and &lt;a href="https://jasonwaldrip.com/writing/thirty-six-refusals/" rel="noopener noreferrer"&gt;25 of them have a dated failure recorded next to them&lt;/a&gt;. I wrote that up recently and the conclusion was that you can't use mine: a constraint adopted out of somebody else's incident report has no weight behind it, so the first time following it costs you an afternoon you'll make an exception, and you'll be right to.&lt;br&gt;
I published that and stopped. Read it one more step and it says something I didn't go looking for. The asset that makes me fastest is the one I'm structurally unable to deliver.&lt;br&gt;
Picture the alternative honestly. I hand a team 36 files. They read them, agree with all 36, and nod at the two that sound like hard-won wisdom. Then a release is late and rule 14 is in the way, and nothing in anyone's memory is attached to rule 14. What I actually handed over was a document.&lt;/p&gt;

&lt;h3&gt;
  
  
  the amplifier conveys just fine
&lt;/h3&gt;

&lt;p&gt;This isn't a theory I need to defend alone. DORA's &lt;a href="https://cloud.google.com/blog/products/ai-machine-learning/announcing-the-2025-dora-report" rel="noopener noreferrer"&gt;2025 report&lt;/a&gt; puts it in four words under a heading called AI, the great amplifier: "AI doesn't fix a team; it amplifies what's already there." Strong teams get better. Struggling teams find their existing problems intensified.&lt;br&gt;
Two more findings from the same report, and they matter in this order. AI adoption now shows a positive relationship with delivery throughput, which reverses &lt;a href="https://jasonwaldrip.com/writing/the-tracks-were-never-the-limit/" rel="noopener noreferrer"&gt;the 2024 result I built an essay on&lt;/a&gt;. And it still shows a negative relationship with delivery stability, for a reason stated plainly: an increase in change volume leads to instability unless there is a control system underneath it. DORA's own recommendation is to invest in the internal platform, and they report a direct correlation between platform quality and getting any value out of AI at all.&lt;br&gt;
So the amplifier conveys. The rails convey, because rails are files. What doesn't convey is the judgment that tells somebody when the amplifier is about to make their week worse.&lt;br&gt;
&lt;strong&gt;I can hand over the amplifier. I can't hand over what it amplifies.&lt;/strong&gt;&lt;br&gt;
&lt;strong&gt;A pipeline is a file. The reflex that tells you a green pipeline is lying to you is not.&lt;/strong&gt;&lt;br&gt;
That reflex is the whole thing, and it has exactly one supplier.&lt;/p&gt;

&lt;h3&gt;
  
  
  the part you can't pre-buy
&lt;/h3&gt;

&lt;p&gt;The deliverable was never the platform. It's the team's capacity to keep making calls at that pace once I stop making them, and that capacity gets built the way mine did: by being wrong in a specific way on a specific afternoon and writing it down while still annoyed about it.&lt;br&gt;
Which means a handoff plan has to include room for them to be wrong. Not a tabletop exercise, not a postmortem of my incident. A real failure with real consequences on their watch, while I'm still close enough to help them read it.&lt;br&gt;
&lt;a href="https://jasonwaldrip.com/writing/the-grind-was-the-teacher/" rel="noopener noreferrer"&gt;The grind was the teacher&lt;/a&gt; ended on a question I didn't answer: if the fleet now does the boring painful work that used to manufacture judgment, where does the next engineer's judgment come from? This is the closest I've got. Somebody has to decide which grinding to keep. Not the parts that only taught patience. The parts that taught you what breaks, and who it breaks on.&lt;/p&gt;

&lt;h3&gt;
  
  
  this reads like malpractice until you price the alternative
&lt;/h3&gt;

&lt;p&gt;A client is paying me for speed, and I've just described a plan where I knowingly don't prevent something I can see coming. That's a hard sell and it deserves to be. Two things make it defensible.&lt;br&gt;
The blast radius is a design parameter, so set it. Canary targeting means a bad change reaches one domain instead of every reseller. &lt;a href="https://jasonwaldrip.com/choices/feature-flags/" rel="noopener noreferrer"&gt;Feature flags&lt;/a&gt; mean a bad release dies by toggle instead of by rollback. &lt;a href="https://jasonwaldrip.com/writing/autonomy-is-infrastructure/" rel="noopener noreferrer"&gt;Autonomy is infrastructure, not trust&lt;/a&gt;: the same rails that let a fleet move without asking are what make a team's first real mistake survivable. I'm not arguing for letting anybody get hurt. I'm arguing for letting them get the lesson at a price I capped before they paid it.&lt;br&gt;
And some failures never go on the table. Anything that leaks a person, loses money, or can't be reverted. A credential is &lt;a href="https://jasonwaldrip.com/writing/a-door-not-a-keyring/" rel="noopener noreferrer"&gt;a door, not a keyring&lt;/a&gt;, and you don't teach judgment with somebody else's customer data. That exclusion list is shorter than it feels when you write it out, which is the uncomfortable part. Most of what we instinctively shield a new team from is survivable, and we shield them from it because watching is harder than doing.&lt;/p&gt;

&lt;h3&gt;
  
  
  what I'd actually do
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Rails before features, every time.&lt;/strong&gt; At CommercialTribe I shipped features I've since forgotten. What I'd defend now is moving to GCP and Kubernetes and collapsing a weeks-long release cadence into hours, across onsite engineers and a remote team in Argentina. That's the only part of that job a team could still use after I left, and it made everything after it cheaper to hand off.- &lt;strong&gt;Let their incidents stay theirs.&lt;/strong&gt; The instinct when the page fires is to take it. Take it and you've bought the outcome and sold the lesson. &lt;a href="https://jasonwaldrip.com/writing/teach-the-principle-not-the-patch/" rel="noopener noreferrer"&gt;Unblock, don't carry&lt;/a&gt; is easy to say in a one-on-one and genuinely hard at 2am.- &lt;strong&gt;Make them write the rule, in their words, in their repo.&lt;/strong&gt; My sentence in their rulebook is decoration. Theirs is a constraint. At Brandfolder the durable thing wasn't the Go zip pipeline; it was that &lt;a href="https://jasonwaldrip.com/choices/write-it-down/" rel="noopener noreferrer"&gt;the reason it was in Go got written down&lt;/a&gt; where the next person would find it.- &lt;strong&gt;Measure the month after you stop.&lt;/strong&gt; What they shipped without you, and what they caught without you. Not what we shipped together. The second number flatters everyone in the room and predicts nothing.### back to the Friday
The repo is clean and you should be proud of it. That was never the question.
The question is what happens the first time something breaks and you aren't in the channel. If the only honest answer is that somebody calls you, then you didn't finish. You became &lt;a href="https://jasonwaldrip.com/writing/the-load-bearing-wall/" rel="noopener noreferrer"&gt;load-bearing&lt;/a&gt; somewhere nobody can see it, inside a company that isn't yours, and you did it while shipping the best work of your career.
So before the next engagement ends: which failure are you planning to let them have?
&lt;strong&gt;Jason Waldrip&lt;/strong&gt; is a builder, entrepreneur, and technologist. He takes on fractional CTO and CAIO work through &lt;a href="https://thebushido.co" rel="noopener noreferrer"&gt;The Bushido Collective&lt;/a&gt;, for founders drowning in AI-generated code and teams scaling past the leadership that got them here. Flat retainers, measured on what ships and what gets prevented. If a fleet is delivering at a pace your team won't be able to hold the day the engagement ends, that's the conversation. &lt;a href="https://thebushido.co" rel="noopener noreferrer"&gt;Work with me&lt;/a&gt;.
Written with AI assistance; the frame, the rulebook, the CommercialTribe and Brandfolder calls, and the judgments about what matters are mine. The DORA quotations and findings come from Google Cloud's announcement of the 2025 report, linked above.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>leadership</category>
      <category>ai</category>
      <category>agents</category>
      <category>management</category>
    </item>
    <item>
      <title>Your API is your agents' hands</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Fri, 17 Jul 2026 02:00:06 +0000</pubDate>
      <link>https://dev.to/imacto/your-api-is-your-agents-hands-3bk4</link>
      <guid>https://dev.to/imacto/your-api-is-your-agents-hands-3bk4</guid>
      <description>&lt;p&gt;Build the open API first, dogfood it, then invite others in. That used to be a pure growth bet: every team that integrates makes the product bigger than you could grow it alone.&lt;br&gt;
There's a second payoff now. The surface you built for outside developers is the same one your agent fleet drives. At Phoneware I put MCP servers over the platforms underneath so the fleet operates them like any other client.&lt;br&gt;
Design it once, for humans and agents both. Skip that and you're writing a second interface for the machines later.&lt;br&gt;
Originally published at &lt;a href="https://imacto.com/writing/your-api-is-your-agents-hands" rel="noopener noreferrer"&gt;https://imacto.com/writing/your-api-is-your-agents-hands&lt;/a&gt;. Written with Claude Opus 4.8.&lt;/p&gt;

</description>
      <category>api</category>
      <category>agents</category>
      <category>mcp</category>
      <category>llm</category>
    </item>
    <item>
      <title>The Story of Ownership</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Thu, 16 Jul 2026 21:00:06 +0000</pubDate>
      <link>https://dev.to/imacto/the-story-of-ownership-1dpn</link>
      <guid>https://dev.to/imacto/the-story-of-ownership-1dpn</guid>
      <description>&lt;p&gt;"Owner" is the cheapest word a company hands out, it costs nothing. Read the four pages after it: the vesting schedule, the cliff, the paragraph about what happens to shares you've earned if you leave, the ninety-day window to buy them with cash you may not have, then the tax bill on paper gains you can't sell to cover it. Nobody reads those pages at signing. That's the design.&lt;br&gt;
Call someone an owner and they stay late, they carry the bug home, they treat the thing like it's theirs. That behavior is worth a lot, which is exactly why the word gets used to buy it instead of the real asset underneath it.&lt;br&gt;
The move I actually watch for: is the grant real? Is the window humane? Was the person in the room when the call that moved the value got made? Give someone a real stake and they act like it. Give them a story and eventually they read the four pages and act like that instead.&lt;br&gt;
If I call someone an owner, I mean the cap table, the window, and the room. If I'm not willing to mean all three, I use an honest word instead.&lt;br&gt;
Originally published at &lt;a href="https://imacto.com/writing/the-story-of-ownership" rel="noopener noreferrer"&gt;https://imacto.com/writing/the-story-of-ownership&lt;/a&gt;. Written with Claude Opus 4.8.&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>startup</category>
      <category>career</category>
      <category>management</category>
    </item>
    <item>
      <title>Scale Is a Design, Not a Dial</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Wed, 15 Jul 2026 04:00:03 +0000</pubDate>
      <link>https://dev.to/imacto/scale-is-a-design-not-a-dial-1740</link>
      <guid>https://dev.to/imacto/scale-is-a-design-not-a-dial-1740</guid>
      <description>&lt;p&gt;The dashboard says forty instances, up from twelve this morning. The autoscaler did its job: it saw latency climb and threw hardware at it. And latency got worse. Not flat. Worse. You're paying for three times the compute to serve a slower product.&lt;br&gt;
Somewhere under all forty of those boxes is a single thing they're all waiting in line for, and every instance you add makes the line longer. Horizontal scaling multiplies work that doesn't have to coordinate. The instant the work does have to coordinate, more instances make it slower. Amdahl wrote this down in 1967: the serial fraction of a job sets a hard ceiling on how much faster you can go, no matter how much hardware you throw at the parallel part. Neil Gunther's Universal Scalability Law goes further: past a certain point, the cost of nodes coordinating with each other bends the curve back down. Add capacity, get less throughput.&lt;br&gt;
That ceiling was not set by the autoscaler, and it will not be moved by the autoscaler. It was set a long time before this morning, in a room, by whoever decided where the state lives and who has to touch it at the same instant.&lt;br&gt;
Now hand the service to a fleet of agents. It writes you something that looks built to scale: stateless handlers, a tidy repo, green tests, a canary that bakes fine at 1% traffic. Every gate you trust says ship it. And the bottleneck is sitting right there in the design, invisible to all of it, because the mistake isn't in the lines, it's in the shape. You cannot catch a shape problem by reading a diff.&lt;br&gt;
Name the hot state before you pick a framework. Where does the contended state live, and which requests touch it at the same instant? Answer that out loud, before anyone opens an editor. The tool is downstream of that answer, every time.&lt;br&gt;
Originally published at &lt;a href="https://imacto.com/writing/scale-is-a-design-not-a-dial" rel="noopener noreferrer"&gt;https://imacto.com/writing/scale-is-a-design-not-a-dial&lt;/a&gt;. Written with Claude Opus 4.8.&lt;/p&gt;

</description>
      <category>architecture</category>
      <category>systemdesign</category>
      <category>performance</category>
      <category>infrastructure</category>
    </item>
    <item>
      <title>Ownership Theater</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Tue, 14 Jul 2026 21:00:06 +0000</pubDate>
      <link>https://dev.to/imacto/ownership-theater-3hdd</link>
      <guid>https://dev.to/imacto/ownership-theater-3hdd</guid>
      <description>&lt;p&gt;"Act like an owner." You heard it in your first week, maybe in the offer, dressed up as equity. Then you read the paperwork: four-year vest, one-year cliff, a 90-day window to buy your own shares after you leave, or forfeit them. Most people can't scrape together that check, so they walk away from stock they were told made them an owner. That's not a loophole. It's the standard deal.&lt;br&gt;
Say you make it anyway. You vest, you exercise, the company sells. The money doesn't split by who owns what. It splits by who holds a liquidation preference, and the people who wired in the capital wrote themselves to the front of that line. On a great exit there's still real money for common stock. On the far more common exit, the preference stack eats the number and the people who were told to act like owners get a rounding error.&lt;br&gt;
I call this ownership theater: the rituals a company performs to get owner-behavior out of people it carefully arranged not to make owners. Equity engineered, through cliffs and windows and preferences, to be worth the least it plausibly can while still counting as a line in the recruiting deck.&lt;br&gt;
You can't inspire owner-behavior out of people you've structured as renters. They'll act like renters eventually. Not because they're cynical. Because they're paying attention.&lt;br&gt;
I run my work on real ownership, not the story of it: stake that vests like a promise instead of a trap, terms a person can actually read and keep. If you tell someone they're an owner, mean the cap table, not the poster on the wall.&lt;br&gt;
Originally published at &lt;a href="https://imacto.com/writing/ownership-theater" rel="noopener noreferrer"&gt;https://imacto.com/writing/ownership-theater&lt;/a&gt;. Written with Claude Opus 4.8.&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>startup</category>
      <category>career</category>
      <category>management</category>
    </item>
    <item>
      <title>"Add AI" is not a roadmap item</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Wed, 01 Jul 2026 15:00:20 +0000</pubDate>
      <link>https://dev.to/imacto/add-ai-is-not-a-roadmap-item-3o33</link>
      <guid>https://dev.to/imacto/add-ai-is-not-a-roadmap-item-3o33</guid>
      <description>&lt;p&gt;Watching teams bolt a chatbot onto a product with no idea what problem it solves.&lt;br&gt;
"Add AI" isn't a roadmap item. AI is a tool, not a strategy. If you can't say what gets faster or cheaper or better, you're not building a feature. You're shipping a press release.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>softwareengineering</category>
      <category>programming</category>
      <category>product</category>
    </item>
    <item>
      <title>A Monorepo is a Context Boundary</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Tue, 23 Jun 2026 15:00:10 +0000</pubDate>
      <link>https://dev.to/imacto/a-monorepo-is-a-context-boundary-1993</link>
      <guid>https://dev.to/imacto/a-monorepo-is-a-context-boundary-1993</guid>
      <description>&lt;p&gt;The monorepo debate used to be about tooling overhead and org preferences. Those tradeoffs are real.&lt;br&gt;
But there's a second argument now that flips the calculus.&lt;br&gt;
When a fleet of agents has to reason over a change, can they see the whole system? Split repos mean split context. A fix in service A that quietly breaks service B goes undetected because nothing is looking at both.&lt;br&gt;
One repo isn't a preference. It's the context boundary the whole system needs, for humans and agents both.&lt;/p&gt;

</description>
      <category>devops</category>
      <category>infrastructure</category>
      <category>agents</category>
      <category>softwareengineering</category>
    </item>
    <item>
      <title>Real Ownership, Not the Story of It</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Mon, 22 Jun 2026 15:00:10 +0000</pubDate>
      <link>https://dev.to/imacto/real-ownership-not-the-story-of-it-24mi</link>
      <guid>https://dev.to/imacto/real-ownership-not-the-story-of-it-24mi</guid>
      <description>&lt;p&gt;When a founder says "we're all owners here," the word is doing a lot of work.&lt;br&gt;
The stock option plan and grant notice are where you find out if they mean it.&lt;br&gt;
Three terms that tell you the truth: cliff at transaction (shares don't pay out unless you're still there at exit), clawbacks (they can buy back your vested shares at cost — Skype did this to engineers when Microsoft acquired them for $8.5B), and golden handcuffs (any term whose only job is making leaving expensive).&lt;br&gt;
A founder who builds those terms is using the language of partnership to buy your nights and weekends at a discount. Calibrate accordingly: don't accept equity as compensation if it's wrapped in clawbacks. Don't sacrifice past the deal you actually have.&lt;br&gt;
Full piece: &lt;a href="https://imacto.com/writing/real-ownership-not-the-story-of-it" rel="noopener noreferrer"&gt;https://imacto.com/writing/real-ownership-not-the-story-of-it&lt;/a&gt;&lt;/p&gt;

</description>
      <category>leadership</category>
      <category>career</category>
      <category>softwareengineering</category>
      <category>startup</category>
    </item>
    <item>
      <title>The Tests Are Green</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Fri, 19 Jun 2026 15:00:10 +0000</pubDate>
      <link>https://dev.to/imacto/the-tests-are-green-3h9k</link>
      <guid>https://dev.to/imacto/the-tests-are-green-3h9k</guid>
      <description>&lt;p&gt;The merge train was green. Canary baked six hours. Dashboards: healthy.&lt;br&gt;
Friday morning, customers can't get through checkout.&lt;br&gt;
Error rate: normal. Latency: normal. Nothing in the exception tracker. The system is healthy. The feature is broken.&lt;br&gt;
Tests verify code paths. That's the job. But "does this function do what I said" is a different question from "is checkout working right now for real people." These fail independently. A team that trusts the first to answer the second has its confidence in the wrong place.&lt;br&gt;
I walked into Brandfolder to a product going down on a memory leak. Suite was green the whole time. Once we could watch the process behave under real load, the fix came fast. Before that, we were tightening bolts that weren't loose.&lt;br&gt;
When a fleet opens dozens of clean PRs a day, nobody's reading every diff with the right fear in their gut. The only honest source of truth is the running system.&lt;br&gt;
Instrument outcomes, not just exceptions. A user who didn't finish a flow is a signal, even when nothing threw. A 200 with an empty body is the happiest-looking failure in your whole system.&lt;br&gt;
Full essay: &lt;a href="https://imacto.com/writing/the-tests-are-green" rel="noopener noreferrer"&gt;https://imacto.com/writing/the-tests-are-green&lt;/a&gt;&lt;/p&gt;

</description>
      <category>testing</category>
      <category>devops</category>
      <category>softwareengineering</category>
      <category>monitoring</category>
    </item>
    <item>
      <title>The context your agents don't have</title>
      <dc:creator>Jason Waldrip</dc:creator>
      <pubDate>Thu, 18 Jun 2026 15:00:42 +0000</pubDate>
      <link>https://dev.to/imacto/the-context-your-agents-dont-have-22ol</link>
      <guid>https://dev.to/imacto/the-context-your-agents-dont-have-22ol</guid>
      <description>&lt;p&gt;An undocumented codebase has always been a tax on new hires. In the agent era it's a different problem.&lt;br&gt;
Agents don't go quiet when they hit a gap in context. They fill it. Confidently, and wrong. The architectural decision everyone knows because they were in the room? That doesn't exist to the fleet. They'll reverse it, or build on top of it in ways that silently invalidate it.&lt;br&gt;
Write down why the system is the way it is. Not for the humans. For the context window.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>llm</category>
      <category>documentation</category>
    </item>
  </channel>
</rss>
