Unlocking the True Potential of AI Beyond Code
The Hidden Friction of Team Coordination
I have worn many hats in my software engineering career, from a machine language coder in 1975 to an AI agentic orchestrator in 2025. I have worked alone, I have worked in teams, I have managed teams, and I noticed one common thread:
“Writing code is only a fraction of what it takes to ship software”
Developers spend only 11% to 25% of their time writing code, the remaining 75%+ is swallowed by meetings, setup, reviews, and context-gathering. Restricting AI to code generation leaves the majority of your development costs completely unoptimized.
So how can we give some of that 75% back to our engineers?
To find the answer, we have to look at where that 75% goes: the rituals, meetings, and manual updates designed to keep teams aligned. Most of these ceremonies were built for a different era of software engineering.
First let us analyse the typical day’s work of software engineers.
The Hidden Work Behind Software
In almost every engineering organization, a significant amount of cognitive energy is consumed by what can only be called “WORKING ABOUT WORK.”
Consider the typical day of a senior engineer or engineering manager:
- Writing and reading status updates
- Updating ticket states across Jira, Linear, or GitHub
- Chasing reviewers for pull request sign-offs
- Attending refinement and estimation meetings
- Explaining progress to non-technical stakeholders
- Drafting release notes and changelogs
- Documenting decisions that are already visible in code or commits
None of this work is inherently bad. It exists for a valid historical reason: humans working in complex systems require synchronization. But as implementation speeds up, this administrative overhead becomes a disproportionate bottleneck.
Working about work is rapidly becoming a larger problem than the work itself.
Scrum Solved Yesterday’s Problem
To understand where we are going, we have to respect where we came from.
Agile frameworks like Scrum emerged at a time when engineering teams suffered from a severe lack of visibility. In that environment, the daily stand-up was an elegant solution. Synchronizing information once every 24 hours provided just enough structure to keep teams aligned without burying them in documentation.
Scrum solved the coordination problem of its time.
Nothing about those practices has suddenly become “wrong.” Rather, the underlying environment has changed. When implementation took days or weeks, a 24-hour information cycle was adequate. When implementation happens in hours or minutes, a daily meeting becomes a latency bottleneck.
AI Changed One Station in the Factory
In The Phoenix Project, Gene Kim adapted Eliyahu M. Goldratt’s Theory of Constraints to software delivery. If you view software tickets—not developers—as items flowing through a manufacturing system, a clear principle emerges:
Optimizing a non-bottleneck station does not increase overall system throughput; it merely accumulates inventory in front of the next constraint.
AI has dramatically accelerated one specific station in the software factory: implementation.
[ Planning ] ──> [ Implementation ] ──> [ Review ] ──> [ Coordination ] ──> [ Deployment ]
▲
(AI Accelerated)
By adding high-throughput automation to implementation alone, we haven’t eliminated bottlenecks—we have shifted them downstream. Code gets written rapidly, but it then sits waiting for review, waiting for ticket linkage, waiting for architectural alignment, and waiting for release coordination.
AI changed one station in the factory. The bottleneck is now coordination.
From Time-Driven to Event-Driven Coordination
Historically, engineering coordination has been time-driven:
Time-Driven Coordination (Legacy): Engineer Works → Next Morning’s Stand-up → Status Collected → Action Taken
This model introduces unnecessary coordination latency. Information is held until the next scheduled meeting, regardless of when the event occurred.
Event-Driven Coordination (Future): Engineering Event → AI Evaluates Significance → Requires Attention? → Notify Human → Decision
In this model, AI is not making engineering or product decisions. It is acting as a low-latency coordination layer, converting raw system telemetry into actionable awareness so humans can act precisely when needed. Modern engineering ecosystems continuously emit digital events. Every tool in a modern toolchain is constantly generating signals:
- Git commits and branch pushes
- Merge requests opened or updated
- Continuous integration pipeline passes and failures
- Static analysis and security scanning results
- Architectural dependency checks
- Deployment events and feature flag toggles
These events are not merely audit logs for post-mortems. They are real-time telemetry describing the true health and state of engineering work.
Developers Are the Internal Customers
Platform Engineering succeeded because it treated developers as internal customers. Golden Paths replaced rigid approval processes, and self-service infrastructure replaced ticket queues.
We must apply this exact philosophy to coordination.
The primary goal of engineering coordination should not be enforcing administrative compliance. The goal is making the easiest workflow also the most coordinated workflow.
If developers routinely bypass a coordination process, the process has failed—not the developers.
When coordination happens ambiently around the engineer’s natural workflow, compliance stops being a chore and becomes an automatic byproduct of doing the work.
Automating Coordination Toil
Just as Continuous Integration automated manual build steps, AI agents can automate routine coordination toil:
- Automatically linking commits and pull requests to relevant specification items
- Intelligent reviewer routing based on code ownership and historical context
- Detecting unannounced architectural cross-dependencies early
- Highlighting blocked reviews before stand-up meetings
- Drafting release notes and user-facing changelogs directly from merged changesets
- Maintaining documentation synchronization alongside code modifications
Developers continue doing what they do best: engineering solutions. The coordination layer quietly keeps the rest of the organization aligned in the background.
Human Leadership Becomes More Valuable
Eliminating coordination toil does not make engineering leaders or managers obsolete. It makes them significantly more valuable.
Status meetings exist because information used to be expensive to collect. Today, information is cheap, but human judgement remains rare and expensive.
When engineering leaders stop spending their days gathering status updates and maintaining task boards, they unlock time for high-leverage activities:
- Mentoring and coaching engineers
- Refining system architecture and long-term technical strategy
- Nuanced prioritization and tradeoff decisions
- Navigating organizational dynamics and cross-team alignment
- Fostering psychological safety and team culture
AI supplies awareness; humans supply judgement and empathy.
Continuously Coordinated Software Engineering
The next generation of AI-enabled engineering will not be defined by who generates code the fastest. It will be defined by who coordinates engineering most effectively.
Developers build software. Agents coordinate software. Leaders lead people.
Developers shouldn’t spend their days proving they are making progress. Their work should prove it for them. The best engineering processes are almost invisible to the engineers using them.
As AI continues to lower the cost of implementation, the organizations that win will be those that eliminate the friction surrounding implementation. By shifting from time-driven manual reporting to ambient, event-driven coordination, we can free developers to engineer and leaders to lead.