AI can write the code.
Generate the presentation.
Analyze the data.
Build the prototype.
Draft the proposal.
Run the workflow.
So why isn’t every organization moving dramatically faster?
Because making one part of a system faster doesn’t make the system faster.
It can simply move the bottleneck somewhere else.
And that gives leaders a new job:
Find the bottleneck. Then redesign the system around it.
The Productivity Trap
Consider software development.
Before AI:
Idea → Design → Code → Test → Deploy
Coding might have consumed a significant portion of the cycle.
Now AI can compress coding from days to hours.
Great.
But what happens next?
The team spends more time:
- reviewing generated code
- understanding unfamiliar implementations
- validating architecture
- resolving dependencies
- testing edge cases
- coordinating changes
- deciding what should actually be built
The bottleneck moved.
Code generation accelerated.
Everything downstream became more important.
Don’t Ask “How Much Faster?”
Ask:
Where does the work stop now?
This is the first shift I would make in how organizations measure AI productivity.
Don’t begin with:
“How many hours did AI save?”
Start with:
“What happens to those hours?”
If 20 hours of coding becomes 5 hours, but the team now spends 15 additional hours reviewing, coordinating and correcting the output, the system hasn’t gained 15 hours of productivity.
It has changed its workload.
That’s why task-level productivity can be misleading.
A Better AI Productivity Model
Think of the workflow as:
GENERATION → UNDERSTANDING → DECISION → COORDINATION → EXECUTION → OUTCOME
AI can accelerate generation dramatically.
But value appears only when the entire chain improves.
So the practical question becomes:
Which stage currently constrains the outcome?
That’s the bottleneck.
Step 1: Map the Value Flow
Don’t map every task.
Map the path from:
Customer need → Decision → Work → Outcome
Then measure where time and friction accumulate.
For example:
StageQuestionGenerationHow quickly can we produce an answer?UnderstandingHow long to determine whether it’s correct?DecisionHow long to decide what to do?CoordinationHow long to get dependencies aligned?ExecutionHow long to implement it?OutcomeHow quickly does the customer actually receive value?
This changes the conversation from:
“Where can we add AI?”
to:
“Where is the system constrained?”
Step 2: Measure the New Bottleneck
Once AI accelerates a task, immediately look downstream.
Three signals are particularly useful.
Queue
Where is work accumulating?
If AI produces 100 implementations but reviewers can validate only 20, the bottleneck has moved to review.
Rework
Where are people repeatedly correcting AI-generated output?
That is a signal that generation is outrunning comprehension or quality control.
Waiting
Where does work spend time waiting for another person, system or decision?
That often reveals a coordination or interface bottleneck.
Step 3: Don’t Automate the Bottleneck Blindly
This is where AI programs often go wrong.
They automate whatever is easiest to automate.
But the easiest task to automate isn’t necessarily the most valuable constraint.
Suppose:
Coding = 20% of delivery time
Decision-making = 30%
Coordination = 25%
Testing/rework = 25%
Automating coding completely doesn’t solve the largest constraints.
You have simply optimized a smaller component.
Optimize the constraint, not the task.
Step 4: Redesign the Work Around AI
Once you know where the bottleneck moved, redesign the workflow.
For engineering, that might mean:
AI handles
- boilerplate implementation
- test generation
- code transformation
- documentation drafts
- repository exploration
- repetitive debugging
Engineers focus more on
- system design
- architecture
- trade-offs
- requirements
- validation
- failure modes
- integration
- long-term maintainability
The goal isn’t:
Human + AI doing the same job faster.
It’s:
Human + AI doing a differently designed job.
Step 5: Build the Harness
This becomes particularly important with agentic systems.
If AI can act rather than merely suggest, the system around the model becomes part of engineering.
A useful harness answers:
What can the agent access?
What can it change?
What must it verify?
What requires approval?
How is its work evaluated?
What happens when it fails?
Can the action be reversed?
Can we understand why it acted?
This is where harness engineering becomes more important than simply choosing a better model.
The model provides capability.
The harness determines how that capability behaves inside the system.
Step 6: Protect the Comprehension Layer
This is the part organizations are most likely to underestimate.
If AI generates software faster than engineers can understand it, the organization accumulates comprehension debt.
So make understanding an explicit part of the workflow.
For example:
Generate → Explain → Review → Test → Accept
Not:
Generate → Merge
Architecture documentation, decision records, tests, observability and clear interfaces aren’t bureaucracy.
They are comprehension infrastructure.
Step 7: Measure Outcomes
Finally, stop at the business outcome.
Don’t celebrate:
10× more code.
Ask:
Did customers receive value faster?
Don’t celebrate:
50% more AI-generated content.
Ask:
Did conversion, retention or customer experience improve?
Don’t celebrate:
More automated workflows.
Ask:
Did cycle time, quality or business outcome improve?
The final metric is not:
How much did AI produce?
It’s:
What changed because AI existed?
The Bottleneck Migration Loop
This gives us a simple operating loop:
- Find the bottleneck
↓
- Apply AI
↓
- Measure what changed
↓
- Find where the work now accumulates
↓
- Redesign the workflow
↓
- Repeat
This is important:
AI adoption should be a continuous systems-design exercise, not a one-time automation project.
The System Layer Test
Before deploying AI into a workflow, ask:
What is the current bottleneck?
Then:
If AI removes it, where will the work accumulate next?
And finally:
Have we designed for that next bottleneck?
If you can’t answer the third question, you’re probably not redesigning the system.
You’re just accelerating a task.
The Bigger Shift
The old productivity model was:
Do the same work faster.
The AI model needs to become:
Redesign the work around what machines can now do.
That’s a much bigger shift.
Because when execution becomes cheap, the valuable work moves upward.
From:
Producing
to:
Understanding
From:
Following instructions
to:
Defining the right instructions
From:
Writing code
to:
Designing systems
From:
Completing tasks
to:
Creating outcomes
Closing Thought
AI isn’t the productivity strategy.
AI changes the constraints under which the system operates.
Your job is to find the new constraint.
Then redesign around it.
Because the organizations that get real leverage from AI won’t necessarily be the ones generating the most.
They’ll be the ones that repeatedly answer one question:
Now that AI made this part faster, what’s slowing us down next?
That’s where productivity actually begins.
Next Issue
The Reversibility Principle
The Best Systems Don’t Predict the Future. They Preserve the Ability to Change Their Minds.
Majid Nisar The System Layer
Thinking clearly about products, software, leadership, and AI — by examining the systems beneath them.
Read the full issue on LinkedIn →
The System Layer publishes on LinkedIn. Subscribe here.