A developer should be able to own a production change without personally writing its implementation, its tests, or its first review.

That is the direction I think software engineering should move toward.

The uncomfortable part goes further. AI can also propose the architecture, draft the requirements, investigate the incident, and write the policies governing the other agents. Keeping one of those activities permanently reserved for a human is a choice we should be able to justify.

Experienced engineers have always owned more than code. They have cared about customer needs, releases, failures, and maintainability. What is changing is how much of the execution we can attempt to delegate across that whole lifecycle.

My argument is that developers should invest in making that delegation dependable. Their work increasingly includes the system that produces the software: its objectives, permissions, evidence, feedback, and recovery.

If every routine change needs your personal attention to move forward, you are part of the system's capacity limit.

Sometimes that is the right limit. It should be a deliberate engineering decision.

A human approval is not a test result

Imagine an AI produces a patch, tests, a summary, and a reassuring explanation. A developer skims the explanation and clicks Approve.

What new evidence did that approval add?

Human review can be extremely valuable. A reviewer might identify a missing transaction boundary, challenge a product assumption, or notice that the test never exercises the real failure. Those are concrete contributions.

An approval based mainly on the agent's own account of its work provides a much weaker basis for confidence.

I would ask the same question of a required review step as any other control: which failures does it catch, and what happens if we remove or change it?

For a sensitive authorization change, that may justify detailed human investigation. For an eligible, reversible change with a clear contract and effective checks, it may justify a narrower automatic path, supported by sampling and escalation.

That path has to earn adoption. GitHub's current guidance describes missed problems and incorrect suggestions in Copilot code review and recommends careful human review alongside it. Today's AI reviewer is not evidence that human review can universally be removed. [6]

The claim worth debating is more specific: requiring a person at every stage is a workflow decision, and we should evaluate its value rather than treating the presence of a person as proof of correctness.

Treat the AI team like a software company

An AI team can have an analyst, an architect, implementers, reviewers, and an incident investigator. Those roles can be performed by different models, or by separate sessions with different responsibilities and access.

The developer sets the mandate and connects their work. What are we trying to achieve? Who can resolve a business question? Which changes can proceed automatically? What evidence permits a release? When must the team stop?

That is the useful part of the CEO analogy.

A founder may hold most of those decisions personally. An engineer inside a larger organization operates within authority delegated by product, security, platform, and business owners. Calling the developer a CEO does not grant powers they do not have.

But the analogy exposes a useful challenge: you cannot expand the capacity of an AI team indefinitely by becoming its mandatory operator for every routine task.

If the architect must wait for you to copy its plan into another chat, and the implementer must wait for you to explain a failed test to the reviewer, the handoffs need engineering.

Build the interfaces. Define the evidence. Make uncertainty visible. Give routine decisions a clear path and exceptions a clear destination.

AI can write the guardrails too

There is no requirement that a human personally author every policy, acceptance scenario, CI check, or runbook.

An agent can draft them. Another can challenge them. A developer can evaluate the proposal and authorize its adoption within the team's mandate.

OpenSpec provides a useful structure for keeping requirements, scenarios, design, and implementation tasks connected. Its documentation also explicitly treats specifications as iterative: new understanding can change the proposed solution. [1]

The architect can write Gherkin acceptance scenarios. Other agents can implement the step definitions and run them against the application. The scenarios become executable evidence only when the runner, bindings, fixtures, and assertions actually exercise the relevant behavior. [2]

The critical boundary is who can change the rules used to evaluate a change.

If an implementer can weaken a failing acceptance scenario, disable the required check, and then report success, the process has allowed the agent to move its own goalposts.

Protect those controls through permissions and separately authorized changes. An agent may propose a new policy without automatically gaining permission to adopt it.

The strongest AI team includes a way to prove its architect wrong.

That requires more than adding a second model. It requires customer examples, external constraints, meaningful tests, and observations that can contradict the team's preferred explanation.

Give the team a problem it can actually be wrong about

Consider an illustrative booking product. The customer wants fewer support requests about rescheduling appointments.

An AI analyst can ask about deadlines, ownership, availability, refunds, and notifications. It can distinguish existing policy from unanswered questions and prepare a proposal for the people authorized to resolve them.

The architect can translate the agreed behavior into scenarios. A customer can move their own booking. They cannot move somebody else's. Two competing requests cannot reserve the same slot. A failed attempt preserves the original appointment.

Implementation and review agents can work against that contract. CI can execute the relevant checks. A permitted release can expose the feature gradually while monitoring the customer workflow.

Now imagine that everything passes, but customers abandon the new flow because the deadline explanation is confusing.

The team has delivered the specified behavior and missed the underlying goal.

Its next action should include reconsidering the requirement. AI can analyze feedback, propose a clearer interaction, and design an experiment. The person with product authority can authorize the change.

This is why enforcing a delivery process is only part of the job. The process also needs to discover when it is efficiently building the wrong thing.

Customer observation must be able to change the specification, just as a failing test must be able to challenge an implementation.

Production becomes part of the development process

The same team should be able to respond when the rescheduling feature fails under real traffic.

A production signal identifies the affected service and release. An investigation agent forms a hypothesis. A coding agent reproduces the failure where possible, adds a regression case, and prepares a patch. The patch goes through the established verification and release process. Subsequent observation determines whether the customer workflow recovered.

Parts of that loop are already documented product capabilities. Sentry's Seer Issue Fix API supports investigation, solution proposals, code changes, and PR creation. Sentry also documents iteration on its existing PRs in response to CI failures and review feedback. [3][4]

Datadog's Bits Code uses observability context to prepare changes and can iterate using CI logs and feedback. Its documentation explicitly says it does not automatically merge those changes. [5]

Those capabilities make the proposed workflow plausible. They do not prove that connecting the products creates a reliable autonomous engineering team. The complete loop needs evaluation on the system where it will operate.

It also needs a definition of recovery that reaches beyond the alert.

Suppose a patch removes an exception by returning success before saving the new booking time. The dashboard becomes quieter. The appointment is still wrong.

The team needs evidence about completed reschedules, failed attempts, duplicate reservations, notifications, and customer journeys. It needs sensible baselines and denominators. No meaningful traffic means limited evidence, even when there are no errors.

A preauthorized rollback or feature disablement may be the right immediate response. Data changes and external side effects still need their own recovery plan.

Give automated repair limits on attempts, runtime, and spending. Repeated uncertainty should trigger escalation, not an unlimited stream of speculative patches.

Autonomy has to make economic sense

A ten-agent workflow is not automatically better than one capable agent and a developer.

Maintaining context, resolving conflicting recommendations, operating the integrations, and investigating escalations all consume time. For a small task, the orchestration may cost more than the work.

DORA's analysis describes a similar tension: time saved in generation can move into verification, and higher AI adoption has been associated with increased delivery throughput alongside increased instability. That research does not benchmark the particular operating model proposed here. [7]

I would judge the team by time to a verified release, total cost per accepted change, escaped failures, recovery time, customer outcomes, and human intervention.

Count retries and cleanup. Compare similar changes. Keep the workflow proportionate to the risk and uncertainty.

If routine work repeatedly needs rescue, improve the process or reduce its scope. If a well-defined class of changes consistently produces credible evidence at a lower total cost, give that class more independence.

More autonomy is a result to earn.

You still need to understand the software

Delegation becomes fragile when the developer can assess the system only through summaries written by the same agents that changed it.

Someone needs to recognize that a concurrency test is sequential, that a successful HTTP response proves little about persistence, or that a supposedly local change affects an authorization boundary.

AI can help investigate every one of those questions. The developer still needs a credible route to direct evidence when the explanations are insufficient: running the scenario, examining the transaction, reading the trace, or inspecting the code.

Writing code remains one of the tools available. Sometimes it will be the fastest way to resolve uncertainty. Sometimes designing a better test or improving the workflow will have greater value.

The point is to choose the work according to the outcome it produces, rather than the amount of code you personally authored.

And this model offers no guarantee that every developer becomes an executive. An organization could use more delegation to place a larger scope under fewer people. A new title would not protect a role whose contribution cannot be explained.

The opportunity is to become very good at making the entire engineering system work.

Build a team that earns independence

The first article in this series described an Ultra architect coordinating more economical implementation models. This takes the idea across the lifecycle: customer understanding, specifications, architecture, implementation, review, release, production observation, repair, and ongoing maintenance.

AI can help build and improve the process itself. The developer is responsible for deciding whether that process deserves the authority it receives.

That is the company I mean when I say the developer becomes its CEO: an engineering operation with a purpose, defined decision rights, a budget, evidence, and a way to learn from failure.

It should be able to complete routine work within its mandate. It should be able to challenge its own plan. It should know when its evidence is insufficient and when a decision belongs elsewhere.

Your responsibility is to build a system that earns the right to work without you watching every step.

Which human step improves the outcome, and what would an automated alternative have to prove?

Sources

Product documentation checked on 5 November 2026. The booking example and proposed operating model are illustrative. They are not a report of an implemented autonomous system or measured performance results.

  1. OpenSpec concepts and iterative collaboration model.

  2. Cucumber Gherkin reference.

  3. Sentry Seer Issue Fix API.

  4. Sentry Seer PR iteration update, 21 September 2026.

  5. Datadog Bits Code documentation.

  6. GitHub Copilot agents application card and review limitations.

  7. DORA analysis of AI adoption and software delivery tradeoffs, 10 March 2026.