Skip to content

We use Google Analytics to count page views. It sets cookies. Nothing else does, unless you press play on a video.

How we handle your information →
Founding Minds
Let’s talk →
Enterprise AI in Production

AI Can Write the Code. Can Your Engineering System Control the Agent?

Portrait of Praveen R.Praveen R Oct 2026
AI Can Write the Code. Can Your Engineering System Control the Agent?

AI coding tools are moving beyond autocomplete and code suggestions.

The next shift is toward agentic software development: AI systems that can take a requirement, break it into tasks, write code, generate tests, check security, update documentation, and iterate on failures with limited human intervention.

A recent McKinsey article, The AI Revolution in Software Development, describes this evolution as moving from AI-assisted coding toward an “AI agent factory.”

The idea is compelling.

But in enterprise environments, the difficult problem is not whether AI can generate code.

The difficult problem is whether we can give AI enough context, constraints, validation, and governance to let it work safely.

The bottleneck is moving from code to context

A coding agent working on a real enterprise system needs much more than a Jira ticket.

It may need to understand:

  • architecture and service boundaries
  • API contracts and data models
  • business rules
  • security requirements
  • coding standards
  • regulatory constraints
  • existing tests
  • nonfunctional requirements

This changes the importance of engineering documentation.

Architecture diagrams, ADRs, API specifications, domain models, policies, and standards are no longer just documents for humans.

They increasingly become operational context for AI agents.

One of the strongest points in the McKinsey article is that good AI output depends less on clever prompting and more on good context.

I think that is exactly right.

Specifications will need to become much stronger

Software teams have traditionally tolerated ambiguity.

A developer receives a user story, asks questions, makes assumptions, discusses edge cases with QA, and gradually fills in the missing details.

Agents need a more structured environment.

Instead of:

Add supplier invoice validation.

we may need something closer to:

  • Objective: Validate invoices against purchase orders and goods receipts.
  • Rules: Currency must match. Tolerance is ±2%. Duplicate detection must run first.
  • Expected result: MATCHED, REVIEW_REQUIRED, or REJECTED.
  • Constraints: Do not modify the payment workflow.
  • Acceptance criteria: Defined test cases and expected outcomes.

This is not really prompt engineering.

It is closer to contract-driven engineering.

The ability to turn ambiguous business intent into precise, testable specifications may become one of the most valuable engineering skills in an AI-native organization.

Production environments will use multiple specialized agents

The future is unlikely to be one giant coding agent with unrestricted repository access.

A more realistic model could look like this:

  • Planning Agent: Breaks a requirement into implementation tasks.
  • Implementation Agent: Writes or modifies the code.
  • Test Agent: Generates and executes tests.
  • Security Agent: Checks dependencies, vulnerabilities, secrets, and policy violations.
  • Architecture Agent: Validates architectural boundaries and engineering standards.
  • Review Agent: Summarizes the changes and evidence.
  • Human Approval

An orchestration layer controls the workflow.

Tests fail? Return to implementation.

Security policy violated? Stop.

Low confidence? Escalate.

This is the part I think matters most for enterprise AI:

Agent → Evidence → Policy → Validation → Human judgment

Not:

Agent → Production

Deterministic controls become more important

As AI becomes more capable, there may be a temptation to let the model make more decisions.

But many enterprise rules should remain deterministic.

For example:

  • authorization
  • financial thresholds
  • segregation of duties
  • tenant isolation
  • accounting controls
  • deployment approvals
  • regulatory requirements

An LLM can interpret information and propose actions.

It should not silently redefine a financial control because another interpretation sounded reasonable.

The architecture I expect to become common is:

Probabilistic intelligence + deterministic controls.

Agents reason.

Policies constrain.

Tests validate.

Humans handle ambiguity and accountability.

We will need observability for agents

Today we monitor applications.

With autonomous engineering, we will also need to monitor the agents changing those applications.

For meaningful actions, we may need to know:

  • Which model performed the task?
  • What context did it receive?
  • Which tools did it call?
  • What code did it change?
  • Which policies were evaluated?
  • Which tests ran?
  • How many retries occurred?
  • What did the workflow cost?
  • Where did a human intervene?

This will become particularly important in regulated and audit-heavy environments.

“AI generated the code” is not an audit trail.

We need to be able to explain:

What happened, why it happened, what information was used, what controls were applied, and who approved the result.

There is also an AI Financial Operations problem

Agentic development can become expensive quickly.

One task may trigger several agents. Those agents may retrieve large amounts of context, invoke tools, run validations, retry failed steps, and even create subagents.

So the useful engineering metric may not be simply:

How much code did AI generate?

More useful measures could include:

  • cost per completed task
  • cost per accepted pull request
  • agent retry rate
  • human intervention rate
  • defects introduced
  • developer time saved

AI architecture will increasingly include economic architecture as well.

The developer role moves upward

The obvious discussion around autonomous coding is whether we will need fewer developers.

A more useful question is:

What becomes more valuable when producing code becomes easier?

I think the answer includes:

System design. Understanding complex interactions.

Specification. Turning vague intent into precise requirements.

Architecture. Defining safe boundaries for autonomous systems.

Review. Recognizing errors that automated checks miss.

Domain knowledge. Knowing when technically correct software is operationally wrong.

Governance. Deciding what an agent should and should not be allowed to do.

The scarce resource may gradually shift from the ability to produce code to the ability to exercise technical judgment at scale.

Don't start with an agent factory

The destination may be highly autonomous engineering, but the transition should be gradual.

A practical path could be:

  • Stage 1 — AI-assisted development: Developers use AI within their normal workflows.
  • Stage 2 — Bounded agent tasks: Agents handle test generation, documentation, dependency upgrades, or controlled refactoring.
  • Stage 3 — Orchestrated workflows: Multiple agents work together with policy checks, tests, evidence, and human approval.
  • Stage 4 — Selective autonomy: Agents receive greater freedom in areas where the organization has demonstrated sufficient confidence and control.

Some areas may become highly autonomous.

Others—payments, identity, authorization, accounting, tenant isolation—may continue to require stronger human oversight.

Autonomy should be earned, not assumed.

The bigger change is the engineering operating model

The important message from the McKinsey article is not the headline productivity numbers.

The deeper shift is that AI-native development requires changes to the entire engineering system.

Requirements need to become clearer.

Architecture needs to become accessible to machines.

Policies need to become executable.

Testing needs to become continuous.

Agent actions need to become observable.

Costs need to become measurable.

And human approval needs to exist exactly where judgment matters.

Simply giving every developer an AI coding assistant will not create an AI-native engineering organization.

We have spent decades optimizing the production of code.

AI may make code increasingly abundant.

If that happens, the real engineering challenge becomes producing four things:

  • Intent — What should we build?
  • Context — What does the AI need to know?
  • Constraints — What must it never violate?
  • Evidence — How do we know the result is correct?

The question for technology leaders is therefore changing.

It is no longer just:

“Which AI coding tool should our developers use?”

It is:

“Is our engineering system structured well enough for autonomous agents to work inside it safely?”

That is where the real transformation starts.

Source: McKinsey & Company, The AI Revolution in Software Development, April 2026.

About the Author

Praveen R

Praveen R is VP, Software Development at Founding Minds. He leads global software development teams and brings 13+ years of product experience across ERP, CRM and e-commerce. He has built fintech and healthcare products since 2013.

Related reading

More in Enterprise AI in Production.

All sixty-one articles