AI in the Enterprise: Faster Development Needs Different Processes
AI shortens research, design and implementation. If handoffs, ticket hierarchies and approvals stay the same, the bottleneck just moves – so large companies have to rethink workflow and governance together.
If implementation takes two days instead of five, but the change then waits twelve days for reviews, approvals and a shared test window, the product hardly reaches users any sooner. The local work got faster. The overall process did not.
This is exactly the shift that AI exposes in large companies. A developer can prepare code, tests and a first draft of the documentation in a fraction of the previous time. In research and development (R&D), hypotheses can be tested faster and prototypes shown earlier. At the same time, dependencies between teams, contradictory documentation and long-grown approval rounds stay the same. The bottleneck moves from implementation into the organization.
This is not an argument against large companies. Their formalities rarely came from a pure love of bureaucracy. Regulation, product liability, changing staff, distributed systems and software that has run for decades all need traceability. It becomes a problem when nobody can tell anymore which formality controls a real risk and which one only administers an old uncertainty.
AI amplifies the workflow you already have#
At first glance, the productivity numbers don’t add up. Three field experiments at Microsoft, Accenture and another Fortune 100 company with a total of 4,867 developers found that users of a coding assistant completed about 26 percent more tasks; the effect varied with experience and context. A randomized METR study with experienced open-source developers, on the other hand, found 19 percent longer completion times with early-2025 tools. In February 2026, METR reported signs of better results with newer agentic tools, but itself considered the data too uncertain, due to selection effects, to put a number on the size of the benefit.
The findings contradict each other less than it seems. Task, codebase, experience, tool and acceptance criteria all change the outcome. The DORA Report 2025 sums up the organizational part well: AI acts as an amplifier. Good feedback loops, well-maintained internal data and small changes benefit. Unclear ownership and cumbersome processes get amplified too.
A survey result from the Atlassian State of Developer Experience Report 2025 points in the same direction: developers reported time saved through AI and, at the same time, weekly time lost to organizational friction. Self-reports like these are not a stopwatch. As a diagnosis, they are still useful: faster code does not remove waiting time.
The ticket tree is not the product#
In a large company, a product idea can first become an initiative, below it an epic, several features, stories and subtasks. The business description lives in Confluence, an architecture decision in a comment, the acceptance condition in a ticket and the actual rule in the code. Each level makes sense on its own. Together, they create several truths.
This often leads to a half-agile, half-waterfall approach. The team works in sprints but has to fix the content months in advance for budget, dependencies and committees. Questions end up as ticket comments because the spoken word doesn’t count as reliable. So people write more, without the documentation becoming any more consistent. When several systems are integrated, the number of alignment meetings grows faster than the number of domain decisions.
AI should not fill this apparatus automatically. Otherwise you just get more epics, longer summaries and even more convincing-sounding comments. The better approach starts with a single, small description of the intent. Everything else is derived from it and stays versioned with the change.
change:
id: customer-address-v2
outcome: reduce failed deliveries
constraints:
- preserve existing API clients
- keep customer consent auditable
owners:
product: customer-experience
technical: customer-platform
evidence:
- contract-tests
- migration-report
- rollback-plan
risk: medium
This is not a new mandatory form. It is an example of a small, versioned change artifact that you can have a meaningful argument about. With read access to an indexed body of code and decisions, an agent may use it to gather the affected repositories, earlier decisions, contracts and tests. It may propose a plan, acceptance examples and documentation changes. Outcome, constraints, risk and owners are still decided by the team.
The difference from the ticket tree lies in the direction: people don’t maintain five representations of the same change. The different views are generated from a few versioned sources. The ticket points to the artifact, the pull request shows the diff, and the documentation points to the decision. A summary for management may look different from the technical view, but both have to trace back to the same state.
Integration needs contracts, not more alignment#
AI does not automatically make complex integration simple. An agent can read an unfamiliar service quickly and still miss a domain assumption that only the team running it knows. That is exactly why collaboration should depend less on prose and more on verifiable contracts.
In the example of the changed customer address, the relevant event could exist as a schema:
{
"$id": "CustomerAddressChanged.v2",
"type": "object",
"required": ["customerId", "address", "consentId"],
"properties": {
"customerId": { "type": "string" },
"address": { "$ref": "Address.v2.json" },
"consentId": { "type": "string" }
}
}
The AI can search the code for producers and consumers, write a compatibility report, add contract tests and prepare test data. The compatibility report has to cite repository, revision and location for every statement – for example, that the CRM already delivers consentId, that the shipping service ignores the field and that an old export works with Address.v1. That way, the research can be checked before a decision is based on it.
It doesn’t have to make the decision. Whether an old address may still be processed is a domain question. Whether both versions run in parallel or an adapter is needed is an architecture decision. The agent collects evidence; the teams involved own the contract. This is exactly where ADRs and executable specifications are valuable: they don’t record every conversation, only the result and its reasons.
Documentation is derived, not abolished#
Confluence stays useful for explanations, entry points and overviews. It just shouldn’t be the third manually maintained copy of what the ticket and the code also describe. A page needs a named owner, a verifiable link to a contract, ADR or repository, and a visible update date. If that link is missing, an agent may flag the page as possibly outdated, but must not quietly declare it the truth.
AI can generate different views from an approved change: release notes for users, a technical integration note and a short summary for the portfolio. Each text stays verifiable because it points to the same artifacts. People then don’t have to write every sentence three times. They check whether the derived view is right for its readers. This makes the documentation more consistent and the obligation smaller at the same time: what gets recorded is the decision, the contract and the operational consequence – not every intermediate stage of the discussion.
flowchart LR Idea[Product idea] --> Ticket[Ticket hierarchy] Ticket --> Docs[Separate documentation] Docs --> Meetings[Alignment rounds] Meetings --> Build[Large implementation] Build --> Test[Shared test window] Test --> Approval[External approval] Intent[Versioned intent] --> SmallChange[Small change] SmallChange --> Evidence[Tests, contract and diff] Evidence --> Review[Peer Review] Review --> Release[Release] Release --> Feedback[User and operations signal] Feedback --> Intent
You become agile through the cost of a change#
Agility is not a particular board or a number of meetings. The original Agile Manifesto values working software over comprehensive documentation and responding to change over following a plan. Neither statement calls for carelessness. Both call for new information to actually be able to change the state of the work.
Whether AI shortens research, prototyping or test design in a specific value stream has to be measured there. If it does, the cost of small experiments drops. R&D can then work more with hypotheses: What do we want to learn, which smallest experiment delivers evidence, and which result would change our direction? Product development can use the same rhythm.
The prerequisite is small batches. More code generated in parallel makes the flow worse if review capacity stays the same. The result would be a new kind of inventory – half-finished pull requests instead of half-finished tickets. As with developer productivity, what counts is therefore not typing speed but the time to reliable feedback. DORA metrics help with the diagnosis; they must not become a target for individual employees.
Governance without a blanket queue#
Control is still necessary, but not every change deserves the same path. A text correction, a backward-compatible API extension and a new permission model have different potential for damage. Good governance makes this difference executable. The NIST AI Risk Management Framework follows the same idea at the level of the AI systems themselves: it structures risk management through governance, measurement and ongoing management instead of a single blanket approval.
approval_policy:
- risk: low
requires: [tests, policy-checks, peer-review]
decision: peer-approved
- risk: medium
requires: [tests, contract-checks, owner-review, rollback-plan]
decision: peer-approved
- risk: high
requires: [security-review, compliance-review, business-owner, audit-record]
decision: manually-approved
This YAML file, too, is only a sketch, not a finished policy language. Automated checks produce the same evidence for every change. People review where context, liability or effects that are hard to reverse come into play. DORA recommends replacing heavyweight external change approvals with peer review, continuous testing, monitoring and targeted extra review of risky changes. That means less bureaucracy and more precise control at the same time.
flowchart TD
Change[Change with evidence] --> Risk{Risk class}
Risk -->|low| Guardrails[Automatic guardrails]
Guardrails --> Peer[Peer Review]
Peer --> Release[Release]
Risk -->|medium| Owner[Domain and technical owner]
Owner --> Release
Risk -->|high| Specialist[Security, compliance and business]
Specialist --> Approval{Approval}
Approval -->|yes| Release
Approval -->|no| Rework[Rework or discard]The EU AI Act makes a second distinction important. Article 4 of Regulation (EU) 2024/1689 on AI literacy has applied since February 2, 2025: providers and deployers must take measures to ensure that people who work with AI systems on their behalf have a sufficient level of AI literacy. Annex III, point 4 of the regulation covers – depending on the intended purpose – among other things systems that evaluate or monitor employees or allocate tasks based on individual behavior or personal traits. A productivity ranking built from process data does not automatically fall under it. But if it is used for HR decisions, performance evaluation or task allocation, it sits in a legally particularly sensitive area. Governance should protect the work, not put people under general suspicion.
The organization has to follow the workflow#
A new assistant alone doesn’t change an org chart. In the long run, though, an organization with many handoffs is a poor fit for a way of working that is supposed to learn in short loops. For value streams with frequent cross-team changes, three structures become more important:
- long-lived, cross-functional product teams that own an outcome from idea to operation and can approve small changes themselves
- an internal platform that offers secure access to code, documentation, test environments and approved AI models as the default path
- governance, security and architecture groups that design rules, reference solutions and exceptions instead of waving through every normal change individually
This matches the pattern I already described for simpler design and less process: first make the change small and its expectations explicit, then remove the process step that this makes unnecessary. A locally measured time saving does not replace this architecture work.
For the roles involved, the focus shifts:
| Role | New focus |
|---|---|
| Developers | Slicing tasks, providing context, reviewing generated changes, designing tests and operational signals |
| Architects | Designing system contracts, automated architecture rules, reversibility and safe default paths |
| Product owners | Sharpening outcomes, acceptance examples and user feedback instead of managing the ticket backlog |
| Project management | Reducing dependencies, risks, waiting times and work in progress instead of planning activities in detail up front |
None of these roles disappears. On the contrary: the cheaper it becomes to generate proposals, the more valuable selection, judgment and responsibility become. The result of a single AI power user cannot simply be transferred to an enterprise. Teams need shared review criteria, time to learn and a workflow that makes differences visible.
Start small and measure the whole cycle#
A company-wide transformation program would be a contradictory start. A single value stream with a recurring change whose risk is known works better. There you can map today’s path from request to operation: How long is work being done, how long is it waiting, how often is the same information transferred, and where does rework happen?
A first attempt needs only a few steps:
- define a versioned change artifact and the leading sources
- give the AI read-only access and log its context in a traceable way
- generate tests, contract checks and documentation diffs automatically as evidence
- at first, send only small, reversible changes through the new path
- compare lead time, waiting time, number of handoffs, rework, change fail rate and time to user feedback
I would not measure generated lines of code, closed tickets or individual prompt activity. Numbers like these reward volume. I would measure the inventory of half-finished work, the share of a predefined sample of documents that contradicts a named contract, ADR or repository state, and the time from opening a review request to the first approval or concrete change request. The share of releases that go through the controlled path measures process coverage, not impact.
Conclusion#
The cumbersome processes of large companies are not a law of nature, but they are not just past stupidity either. They preserve ownership, knowledge and control where technical means were long insufficient. AI changes this calculation because it can gather context faster, prepare evidence and support recurring checks.
The gain only materializes when the organization doesn’t fill the freed-up time with more output. Then changes get smaller, contracts replace part of the alignment and versioned artifacts avoid contradictory copies. Approvals follow risk instead of a blanket queue. People keep the decisions where domain knowledge, liability and consequences matter.
That is how AI can actually make development and R&D more agile: not by filling out the old process faster, but by helping to make its detours unnecessary.
Further reading#
- DORA – State of AI-assisted Software Development 2025
- DORA – Capability Catalog
- DORA – Streamlining Change Approval
- DORA – Working in Small Batches
- DORA – Repository
- Microsoft Research – The Effects of Generative AI on High-Skilled Work
- METR – Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
- METR – We Are Changing Our Developer Productivity Experiment Design
- Atlassian – State of Developer Experience Report 2025
- Manifesto for Agile Software Development
- NIST – AI Risk Management Framework
- European Commission – AI Literacy: Questions & Answers
- Regulation (EU) 2024/1689 – Artificial Intelligence Act
Revised and translated from German with the help of AI.