Build the Tracks

Agents can build and fix software faster than traditional processes can feed and release it. The infrastructure has to carry the idea, the context, and the checks from the beginning.

By Jason Waldrip November 4, 2026 14:01 6 min read

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.

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.

I still believe in that work. But the tracks start earlier now. They start where the idea forms.

the competition can come from anywhere

In early October, software engineer Brandon Thomas released ArtCraft, 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 analysis of the project’s public history.

They’re early software. Thomas himself said the apps were “not anywhere close to ready”, 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.

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.

And the competitor might not be another software company.

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.

If that person can build a tool that handles their part of the job, how much of your product do they still need?

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.

what feeds the factory?

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.

Each person can add something valuable. Each handoff also makes the idea wait.

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.

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.

In The Agnostic Builder, 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.

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.

The tracks begin there: at the point where an idea has enough context to become something someone can try.

a release cycle is still a queue

Once the work is ready, it has to reach the customer.

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.

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.

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.

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.

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.

the tracks have to earn the speed

The train can only move as fast as the tracks it’s built on.

I’ve also written that the tracks are what keep the train on the ground. That still holds. The difference here is where they begin: a safe release path needs a way for the right work to reach it.

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.

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.

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.

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.

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.