An operating model for AI-assisted engineering

The Agent Drives, I Navigate

How I run a team of AI developers with XP discipline

Autonomous execution, not autonomous approval.

Agents plan, implement, test, and integrate; humans decide what ships.

Contents
  1. The idea
  2. My role
  3. How work starts and who does what
  4. Test-first, in a complete running system
  5. Rotating between initiatives
  6. A PR is a tested handoff
  7. Review and the team’s process
  8. Delivery continues after merge
  9. The workflow, step by step
  10. Retrospectives built the fleet
  11. How XP maps onto this
  12. How this differs from sub-agent orchestration
  13. In practice
  14. Questions people ask
  15. What others can adopt

INTRODUCTIONThe idea

Most teams have figured out how to get AI agents to write code. The harder problem is trusting what they write. Writing a better prompt or a more detailed spec helps, but it only covers the start. My answer is to stay in the loop the whole way, and to make the agents verify intended behavior in a running system before anyone reviews it.

I no longer write most of the code myself, but I’m still hands-on in engineering. I discuss architecture, clarify requirements, follow the work, review pull requests, make technical decisions, and remain accountable for delivery. The AI agent drives; I navigate.

I work with AI agents as an engineering team rather than as a code-generation feature. Depending on the initiative, I work directly with a terminal agent that coordinates developers, or have it start a dedicated manager for larger or longer-running work. I run one, two, or three initiatives at a time, depending on how much attention each needs for me to stay in the loop.

The guiding principle is autonomous execution, not autonomous approval. Agents plan, implement, test, and integrate; humans decide what ships.

The approach draws on years of practicing Extreme Programming (XP) across multiple teams. It is an adaptation of XP, not a claim that every XP practice is enforced automatically.

Where it came from

This is a personal way of working, not one company’s process. I’ve used it at more than one company and on my own projects. The current fleet is the latest stage of work I started in early 2025.

  1. A board the agents walked themselves. My first orchestration used Jira tickets with dependencies, aider agents as developers, and n8n as the manager. Once I started a sprint, the agents worked the board on their own, moving tickets across the columns. When a ticket reached review, I reviewed it and gave feedback. Either the agent took it back to in progress, or I merged it, “tested” it, and moved it to done. I had each agent hand me a markdown plan of what it would do instead of code. A few wrote code anyway, but nothing I’d have shipped. “Testing” meant judging whether the plan would work, not running anything. I was proving the process, not the work. Watch the first demo (14 min). It was recorded late at night and rate-limited, and the agents start working the board at 1:24. A later live demo showed the agents responding to PR review comments.
  2. Real work, verified on my machine. Once agents could write real code, I eventually worked with three to five at a time on a company’s real codebase. Each coordinated its own sub-agents rather than running on its own compute, and the end-to-end verification ran against the entire system on my own machine.
  3. Agents that check their own work. Around the same time, I built my own agents to run the same loop. One of them ended up in the browser, where it could validate its work against the running application.
  4. Parallel, test-first, end to end. That grew into multiple agents in separate browser tabs, each on its own branch, doing test-first work validated end to end. That work continues, and it can build and validate full-stack applications.
  5. The fleet. The current fleet applies the same process in a different environment: separate compute instances, on a laptop or in the cloud, instead of browser tabs.

One thing stayed constant through every stage: human direction, agent execution, human review, merge. What changed is the agents. As they got better at implementation, the same loop could carry real work, and testing moved from me judging a plan on paper to agents validating working software in the running system before I ever see it.

I carried forward the process, not the architecture. Each implementation is built for its environment and belongs where it was built; the process is what I bring with me. In every stage since the agents could do real work, I started simple, used the approach on real software, and improved it through retrospectives (see §9). The fleet’s infrastructure wasn’t planned upfront; it grew out of that loop.

§ 1My role: accountable, involved, and not necessarily typing

I usually work at the initiative level (epics, not individual tickets or stories), and I own the outcome. I direct the effort, understand how the system works, and can explain its progress and technical choices to colleagues. The agents do the implementation; I stay close enough to challenge assumptions, review decisions, and respond to problems.

The pairing metaphor is useful but imperfect. In XP, the navigator watches every change as it happens. Usually I don’t: once an agent is underway, I step away to another initiative and come back for results and decisions. Most of the time, the approach borrows pairing’s division of labor (one partner operates the tools, the other holds direction and design) without its continuous attention. When the work is hard enough, I go back to real pairing (see §4). In practice my role sits somewhere between navigator and tech lead.

This isn’t unattended code generation, and it doesn’t remove human review. It expands execution capacity while keeping technical ownership with a person.

§ 2How work starts and who does what

Breaking an epic into tickets and PRs is part of the work the agents and I do together. Work on an initiative usually starts one of two ways:

The terminal agent decides whether an initiative needs one developer, several in parallel, or a dedicated manager. A manager is useful for long-running work because it keeps monitoring even when my laptop sleeps; for shorter work, the terminal agent coordinates developers directly. A manager is an option, not a mandatory layer.

I favor small, end-to-end, verifiable slices of value over disconnected changes that can’t be meaningfully tested.

RoleResponsibility
Human engineering owner (me)Own the outcome, set priorities and architecture, review work, decide how to handle failures, approve release progression.
Terminal agentCollaborate on requirements and design, organize the initiative, choose direct developers or a manager, help with review and deployment.
Dedicated manager (when used)Plan and delegate subtasks, launch and monitor developers, coordinate parallel work, summarize outcomes.
Development agentImplement an assigned change in a complete working environment, validate it, hand off a reviewable PR.
Manager or designated developerIntegrate and test multiple PRs together when work spans changes or repositories.
Human engineering teamNormal peer review and merge.

When something fails, the manager reports the problem and waits for my direction rather than quietly deciding how to recover. I want to know what’s happening, not just receive a final success claim.

That instinct extends to situations nobody planned for. One manager recently finished its work and shut down its four fleet instances, then noticed two more running that weren’t its own. Instead of treating them as leftovers and shutting them down too, it asked me who had started them. I told it I’d check with the other manager, and that I’d started that work myself. Agents managing parallel work only see their own part; I’m the one who sees all of it.

§ 3Test-first, in a complete running system

Each development agent gets more than a checkout and a prompt. Every fleet instance gets an isolated, complete development environment with a fully working version of the system, including the dependencies and test tooling its task needs. The only exceptions are the agents I work with directly on my laptop.

Agents practice test-first development: they write tests for the intended behavior, then implement until those tests pass. Early on, I verified this by watching agent logs as they worked and seeing them follow the instruction. Test-first is now part of every development agent’s prompt, and a RED check confirms the new tests fail before implementation begins.

Passing tests is not the definition of done. The agent must exercise its change in the complete, running system: start the application, use the affected functionality, inspect any failures, and confirm the behavior works end to end.

Environments are reproducible and disposable. Before work starts, the environment refreshes the relevant code and rebuilds changed components, so the agent isn’t unknowingly testing stale software. A freshness check blocks work if a required checkout is behind its intended branch.

Working state lives on persistent storage separate from the compute instance, so a stopped agent can resume where it left off rather than rebuilding from scratch. I’ve rarely needed this, but it’s cheap insurance.

The infrastructure is replaceable: local machines, VMs, containers, or cloud instances all work. What matters is a runnable, testable system, not a particular vendor or stack.

§ 4Rotating between initiatives

I work with an agent or manager until we’ve agreed on the next objective and it starts implementing, delegating, testing, or monitoring. Then I switch to the next initiative, discuss its work, and set it in motion. I return as results arrive or decisions are needed.

This is my adaptation of XP pair rotation. The agent’s execution time is what frees me to work on another initiative; without it, I couldn’t stay closely involved in several at once.

The hard part is context switching, especially the next morning. I give terminals descriptive titles so I can tell initiatives apart, and when I reconnect I usually ask:

What are we working on? What’s next?

The agent restores the current state and next actions, backed by tickets, PRs, and persisted execution state. I still need to understand the engineering decisions, but I don’t try to memorize every detail of every session.

The real limit on parallelism is my own attention, not agent capacity. Three initiatives is about my limit while staying closely connected to what’s going on. I’ve become more efficient over time, but staying connected matters more than adding initiatives.

Not every initiative gets equal attention. I vary it with uncertainty. Routine work gets a check-in when results arrive. When an implementation is particularly difficult, I let the other sessions wait and focus on the one that needs me, and for work that demands it, I drop down to one-on-one pairing with a single agent. On occasion that has lasted an entire day.

§ 5A PR is a tested handoff, not just a diff

Each developer validates its own work before handing it off. It self-reviews and corrects its changes first, then runs end-to-end tests in the real system. The pull request records what was tested and what the results were, alongside implementation notes, so the reviewer has evidence to check rather than claims to trust.

Agents also update tickets as they go: progress, implementation notes, validation results, and saved-state information. That matters because development instances usually shut down when their work is done (the manager may first ask whether I want one kept running for manual inspection). Two kinds of record survive:

Testing the whole solution: PR bundles

Passing individual tests doesn’t prove several changes work together. For multi-PR or multi-repository work, the fleet supports PR bundle testing:

  1. Select the relevant PRs and pin their exact revisions.
  2. Apply them together in a working development environment.
  3. Rebuild and run the integrated system.
  4. Run the available integration and health checks.
  5. Reject or roll back incomplete combinations rather than testing a partial bundle.

When an initiative produces several PRs, I ask the manager whether they were all tested together end to end. Usually they were. When they weren’t, the manager either explains why or offers to run the bundle test, and I usually say yes. I sometimes exercise a running bundle myself. A body of work isn’t ready for team review just because every agent reports that its own task is done. Because the whole bundle runs in a complete copy of the system, the team doesn’t have to wait for a deployment to see whether the work actually does what it should. We can check the result before anything merges.

§ 6Review and the team’s existing process

When all the developers have finished, the manager reports what happened, with a link to each PR. How I review those PRs changed after one hard sprint.

This approach produces more PRs than one engineer typically would, and my colleagues review them. To avoid overloading the team with reviews, my tickets were kept in the backlog, outside the sprint board. Even so, over one two-week sprint, while running two or three initiatives at once, I ended with about 20 PRs still waiting for review, even after merging approved ones throughout the sprint. Writing code was no longer the bottleneck; reviewing and verifying it was.

That sprint also showed me something useful: if PRs were going to wait for review anyway, I had time to put more into each one. So I changed how I build them, to make them easier to validate for the team and for me:

Review has become more efficient as a result, and it still catches real problems.

That careful review matters because working with an AI agent is like working with an extremely talented engineer who doesn’t know the domain. The code is usually good. What slips through is what only someone who knows the domain would catch: a business rule, an unstated expectation, a reason things are done a certain way. As the tech lead, I review each PR for exactly what a newcomer wouldn’t know.

Recently an agent widened a change, adding a new parameter to functions that shouldn’t have had it. I reviewed the shape of the change and missed it; a teammate who knew which functions belonged caught it, and it was reverted before release. We added code guardrails to catch that case, added rules to the agents’ environment, and I now slow down and read every line.

Findings from my review go back to fleet instances, which fix them and test each PR end to end again. Only then do I post the PR links in the team channel. Team findings go through the same loop, and when everything is approved, we merge.

My AI developers don’t use a separate process. They contribute through the same pull requests, reviews, approvals, merges, and deployments as everyone else. They respond to review comments, and they review other people’s PRs, sometimes checking out a colleague’s change and testing it in their own complete environment rather than just reading the diff.

Their contributions flow through work assigned to me, and I’m accountable for everything submitted. None of this should be hidden. I make sure colleagues and management know how I work, and I share the tooling, demonstrate the workflow live, and record walkthroughs so others can try it. Disclosure and attribution should follow the policies of whatever organization uses the approach.

§ 7Delivery continues after merge

My terminal agent helps coordinate deployment and uses the fleet to validate the software at each stage:

The CI/CD pipeline handles progression; I keep authority over the approval gates.

§ 8The workflow, step by step

  1. Describe the work. I tell my terminal agent what I want done for an initiative, either from its existing tickets or through a discussion that produces new ones. The terminal agent acts as the manager itself or launches one.
  2. Implement and test. The manager assigns the work to fleet instances. Each one implements its change, then tests it end to end in its own complete running system.
  3. Report. The manager waits for every instance to finish, then reports what happened, with links to the PRs. If something fails along the way, it reports the problem and waits for my direction.
  4. My review. Fleet agents review the PRs and point out where I should focus. I look at every PR myself.
  5. Fix and retest. The manager has fleet instances address the findings on each PR, and each PR is tested end to end again.
  6. Test together. For multi-PR work, I ask whether all the PRs were tested together end to end. If they weren’t, the manager explains why or offers to run the combined test, and I usually say yes.
  7. Team review. I post the PR links in the team channel. Findings from the team go back through steps 5 and 6.
  8. Merge and deliver. Once everything is approved, we merge and validate in dev, QA, and production, with me approving the production gate.
The workflow as a flowchart
Describe the work: ticket or discussion
Terminal agent or manager plans
Fleet instances implement, then test end to end in their own full system
On failure or blockerManager reports and awaits my direction, then planning resumes.
Manager waits for all; reports results and PR links
Fleet review highlights where to focus
I review every PR
Fleet addresses findings; each PR retested end to end
Multi-PR work tested together?
If noManager explains why or offers a combined test. Usually: run the combined end-to-end test. Otherwise, continue.
Post PR links for team review
Team findings?
If yesBack to “Fleet addresses findings; each PR retested end to end.”
Merge
Validate in dev
QA gate and validation
I approve the production gate
Production verification

Orange outline: a step where I act. Dashed outline: a decision.

It’s a lot of testing. It’s also how I worked when I wrote the code myself, and that work rarely came back to me. The fleet follows the same discipline; the difference is that agents now do the repeated end-to-end retesting that’s easy for a person to cut short.

What a manager update looks like

Here’s a real status message from a manager, with internal identifiers replaced:

Manager status

The dry run passed end to end, with the red check reporting 8 failed and 159 passed against build. I’m posting the results on PR #[A] and noting the branch-resume behaviour in memory.

Commented on PR #[A], read 1 file, ran 1 shell command, wrote 1 memory

The dry-run evidence is on fleet PR #[A], and the follow-up box for #[B] is on the right base: its work tree is cut from [commit], the PR’s head, and it is in the stack-restart phase before the agent starts. That run includes an on-box reproduction of the proxy error before and after the change, so I expect it to take longer than the earlier tickets, roughly forty minutes. I’ll review its stacked PR and run the red check on it when the launcher reports.

In two paragraphs, it shows most of this document at work:

PR #[A] is also on the fleet’s own repository: this is the fleet testing an improvement to itself (see §9).

§ 9Retrospectives built the fleet

The fleet has evolved through one recurring question:

What challenges did you run into during this build session, and what changes in the environment would make things easier for you?

I ask the agents, discuss their answers, decide what to improve, and direct the terminal agent or manager to make the changes. As the fleet matured, it began implementing and testing improvements to its own environment using the same instances and validation workflow it uses for application work: provisioning, code refresh, build scripts, test automation, developer tools, and the AGENT.md and other guidance agents read.

A fix to a shared obstacle helps every future agent, not just the one that hit it. The agents don’t govern their own environment; I start the retrospective, choose the improvements, and direct the work. Each round of work starts from a better baseline.

This is also why my prompts stay short. Each retrospective puts more of what agents need into the environment itself, so the next initiative starts already primed.

§ 10How XP maps onto this

My experience with the full set of XP practices (intensive pairing, rotating partners, frequent integration, multi-team process improvement) shaped how I approach these agents. On one team we coordinated shared-mainline merges with a literal traffic light. The concern then is the same as now: integrate often, keep the system working, and surface conflicts early.

XP practiceHow it shows up here
Pair programmingAI drives implementation; I navigate design, intent, and review. My attention scales with uncertainty, up to full one-on-one pairing for difficult work (see §4).
Pair rotationI switch among AI partners while each works independently, then return for results and decisions.
Test-first developmentAgents write tests for the intended behavior before implementing, then run them in a working system.
Small releasesInitiatives are broken into independently meaningful, verifiable slices.
Continuous integrationChanges are validated individually and as combined PR bundles.
FeedbackAgents exercise changes in the running application and report failures promptly.
Collective ownershipAgents work across services and repositories and review colleagues’ PRs; the integrated result is a shared responsibility.
Simple design and refactoringThe fleet’s own environment grew incrementally from real needs rather than an upfront framework. Agents don’t refactor on their own, so I direct it (see §13).
RetrospectivesAgents are asked what impeded them, and the environment improves in response.
Sustainable paceApplies to the human. Rotating across initiatives trades typing for context switching, so I run one to three initiatives at a time, depending on how much attention each needs.

Test-first development and pair rotation are established in how I work. Other practices are goals I’m still building toward rather than things the tooling enforces.

§ 11How this differs from sub-agent orchestration

Sub-agents are a useful mechanism for delegating tasks, and I use them. But the approach is an operating model, not an agent hierarchy: a human owns the outcome; agents plan and delegate; developers work in complete running environments; every contribution is tested individually and in combination; and everything goes through normal review, merge, and deployment gates.

None of this requires unique technology. A sub-agent system could support the same practices, and for a small task a single agent is often better. What matters is the discipline around the agents, not how many are spawned.

§ 12In practice

Output

The clearest measure I can share without describing the work is pull request volume. In a typical month, I average more than six PRs per working day across more than a dozen repositories, and my own projects run at roughly the same pace.

The PR count is a side effect of how I work: I take on epics, each epic is broken into small, verifiable slices, and each slice becomes a PR. At work, every one goes through the workflow in §8, and most are reviewed and merged by the end of the next day. Volume alone isn’t the point: it matters only because each PR carries the evidence described in §5 and passes the same team review as everyone else’s work.

Small slices also keep each PR small enough to actually review. Over the last 60 days, my median PR was about 150 lines, tests included, across about 4 files. That’s what lets me stay involved: a 150-line PR gets read, while a thousand-line PR tends to get rubber-stamped.

What the PRs add up to

Ticket counts undersell this kind of work, because initiatives often arrive as a single line: integrate with this partner, or build a new platform, assigned as a blank ticket. Turning that into an architecture, a plan, tickets, and PRs is the job. Over a few months, several initiatives were large enough to be broken into dozens of subtasks in the tracker. Others were tracked as a single ticket, whatever their size.

What went wrong: requirements, not code

When I join a new organization or department, I don’t yet know its domain, and I haven’t always interpreted requirements correctly. Agent validation confirms the software does what I specified; it can’t tell me the specification was wrong. Team review has caught these gaps in my domain knowledge, both in a new department and at a new company.

That’s the clearest argument I have for keeping human review in the loop. The agents can verify the software behaves as intended. The people who know the domain tell me whether it’s the right software.

§ 13Questions people ask

What does it cost?

Less than you might expect. My own fleet costs about $70 a month: about $30 for inference, $20 for my Claude Code subscription, and less than $20 for AWS infrastructure. I keep it that low by running the agents on my laptop instead of giving each one its own cloud instance. Running them in the cloud for full isolation would bring AWS to about $200 a month, or roughly $250 in total; inference and Claude Code stay the same. Fleet developers and managers run on glm-5.3-flash. My terminal agent runs in Claude Code, and so does any manager work it does itself. I went without Claude Code for a while but switched back for my terminal agent when shared inference rate limits became a problem.

The process itself can be much cheaper. My browser-based setup runs the same process for about $30 a month, including both the browser agents and the agents that improve the system itself. Cost grows with how much isolation you give each agent, not with the method.

Which tools and models?

Claude Code with Opus 5.5 is my interface. Pi running glm-5.3-flash does most of the work. The process doesn’t depend on either; it has run on very different tools (see “Where it came from”).

What can the agents access?

In development, the full running system. In production, agents test as me, with an ordinary user-level token for the application itself, not a cloud or infrastructure credential. It’s limited to my own account, can’t reach anyone else’s data, and has no admin rights. It’s essentially black-box testing by testers who happen to know a lot about how the system is built.

Do you really understand all of it?

I know it as well as a tech lead who reviews every pull request: well enough to answer questions in meetings about how things work. When I need specifics, I ask my agent, the same way I’d ask the developer who wrote it. And like anyone on a large system, I’m still learning the parts I haven’t worked on.

What do the agents do poorly?

Four things, and all of them need my attention.

Stacked PRs. When one PR builds on another, a merge can collapse the stack into a single commit and lose the work in the PRs above it. I’ve hit this often enough that handling it is now part of the process: the manager backs up the work before touching a stack and no longer deletes branches as it merges.

Drift. Agents drift toward whatever is simplest right now, and they’ll drop things they don’t see a use for, even when I’m building toward something that needs them. I learned this the hard way. One agent removed my Apache Spark and Delta Lake implementation without my noticing, because Postgres handled my small demo dataset fine. I’d built it to show data flowing through the medallion tables and ETL into Postgres, and I never got to give that demo. Agents don’t have the bigger picture unless you give it to them, any more than a junior engineer would. Since then, I watch closely for drift.

Compaction. When an agent’s session runs long, its earlier context gets compressed into a summary, and details are lost. I believe that’s how the Spark and Delta Lake work above disappeared. It loses even simple instructions. If I’m pairing directly with an agent and I’ve told it to commit and push its changes, which triggers a deploy, it can forget that after a compaction. I go on testing what I think is deployed, prompting “...still happening...”, until I find three commits sitting unpushed on my machine. Compaction still worries me.

Abstraction. Agents duplicate code rather than abstract it. Ask for ten similar things on ten separate occasions and you’ll get ten similar implementations; they rarely refactor unless you tell them to. Some concepts are surprisingly hard for them, too: I once had to walk Opus 4.8 through a simple recursion. Refactoring is still a core XP practice here; it just has to be directed. (A teammate once caught exactly this in review; see “How does the team feel about it?”)

There’s also a limit upstream of the agents: they build what I ask for, so when I misunderstand a requirement, they build the wrong thing well (see §12). Beyond these, I haven’t found a kind of engineering work they can’t do. I use them for everything I can, and when one gets blocked, I ask it, “What can I do to unblock you?”

Do agent runs fail or loop?

Rarely. I’ve seen an agent loop maybe twice. Each time, I interrupted and asked, “What are you working on? You keep repeating the same thing.” That was enough to break the loop, and it carried on fine. Occasionally an agent prints a screen of garbled characters; I restart it and give it the work again. Because progress lives in tickets, PRs, and persisted state, a restart costs little.

How do I start?

Try to give your agent everything you would do yourself. When it can’t do something, ask what it needs to be able to. Really, use it for everything. Have it set up the entire system and test its own work end to end. Once that works, ask it how to split the work.

Feel free to ask it anything. For me, worrying about cost was what held me back most. Once I switched to open-weight models, I felt free to ask for anything, even though they were sometimes less capable, and that freedom was good for learning. If you’re learning, I’d start with a low-cost subscription such as OpenCode Go (about $10 a month) and an agent like Pi. Right now I’d pick glm-5.3-flash: it’s capable and inexpensive, and a $10 plan goes a long way with it. Prices and models change quickly, so check what’s current.

How does the team feel about it?

The teams I’ve worked with have been comfortable with it. We’re all experimenting and learning ways to be more productive, sharing what we learn, and growing together.

Team review also keeps me honest. I once asked agents for ten similar things in ten separate sessions, with other work in between. There were enough PRs that a teammate pulled them together to see the bigger picture, then messaged me: “Okay, that’s three of these things. I usually refactor at three.” I replied, “So do I.” Before I could get into the code: “Okay, now there are four.” I wrote back, “Stop the review. Let me take a look.” With days between the PRs, I hadn’t noticed the pattern; across the whole body of work, it was obvious. My agent rules now include “Check for duplication in our code.”

What about learning, especially for junior engineers?

Ask a lot of questions, including asking the agent how you would do it yourself. When I want to learn something hands-on, I ask the agent for a runbook so I can do it myself.

Shouldn’t you stop counting PRs?

Yes. The right measure is vertical slices of value delivered. Most organizations still count PRs, so that’s what I can report for now. At a previous company, I asked engineers to keep pointing stories the same way even after AI made us faster; otherwise we’d have lost our baseline before we had a new metric to replace it.

§ 14What others can adopt

None of this requires my tools or infrastructure; I’ve run the same process on a ticket board, with sub-agents on my own machine, in browser tabs, and on separate compute instances. A team can start with one agent and one working application environment, then add capabilities as real work justifies them:

  1. Treat the agent as a pairing partner and keep a human technical owner.
  2. Give the agent a complete, runnable system. Work test-first, and require the agent to exercise its change in that system, not just pass unit tests.
  3. Keep tasks small enough to validate and hand off as reviewable PRs.
  4. Record coordination, implementation notes, and test evidence in durable work items.
  5. Test related changes together before merge.
  6. Keep human review, failure decisions, and release approvals explicit.
  7. Rotate among AI partners while they work independently; use terminal titles and a quick “what’s next?” to recover context.
  8. Ask agents what slowed them down, improve the shared environment, and repeat.

More agents don’t automatically produce better software.

Engineering discipline, working environments, feedback loops, and accountable leadership are what make parallel AI execution useful.