Mert 
Avrupa’da endüstriyel robot kullanımında yeni bir dönem başlıyor. Humanoid, Bosch ile yaptığı yeni anlaşma kapsamında HMND 01 insansı robotlarını seri üretime taşıyor.
SpaceX, yeni nesil Starship V3 roketinin Teksas’taki kritik test uçuşunu son saniyelerde iptal etti. Şirket, teknik sorunun ardından yeni denemenin Cumartesi 01:30 TSİ’de yapılacağını açıkladı.
Take-Two, GTA 6’nın çıkışıyla birlikte tarihinin en büyük finansal yılına hazırlanıyor. Şirket, 2027 mali yılı için 8,1 milyar dolara kadar gelir bekliyor. İşte detaylar…
Apple, en azından bir açıdan artık akıllı telefon pazarında lider konumda değil. Şirketin müşteri memnuniyeti puanı %80’e düşerek iPhone 11’den bu yana ilk kez Samsung’un gerisinde kaldı.Tesseract can’t do handwriting. Time to spend money.
AWS Textract. Cloud service, built-in handwriting detection, pay per page. If I’m paying for it, the output should at least be usable.
Textract
import boto3
from pathlib import Path
def extract_document(image_path):
client = boto3.client('textract')
with open(image_path, 'rb') as f:
image_bytes = f.read()
response = client.detect_document_text(
Document={'Bytes': image_bytes}
)
lines = []
for block in response['Blocks']:
if block['BlockType'] == 'LINE':
lines.append({
'text': block['Text'],
'confidence': block['Confidence']
})
return lines
if __name__ == "__main__":
for image_file in sorted(Path("images").glob("*")):
print(f"n--- {image_file.name} ---")
for line in extract_document(image_file):
print(f" [{line['confidence']:5.1f}%] {line['text']}")
Confidence scores are a nice touch. Accuracy is better – maybe 40-60% on a good document.
But “better” isn’t “good enough.” “2 1/4 cups flour” comes back as “2 1/4 c fleur.” “1 tsp baking soda” becomes “1 tso bokrig sado.”
The Real Problem
Even when it gets the words right, Textract doesn’t know what any of it means. Flat text. Lines in reading order. My documents have titles, ingredient lists, instruction paragraphs, notes in margins. Textract sees none of that. Just characters on a page.
So now I’m writing parsers.
import boto3
import json
import re
from pathlib import Path
def extract_document(image_path):
client = boto3.client('textract')
with open(image_path, 'rb') as f:
image_bytes = f.read()
response = client.detect_document_text(
Document={'Bytes': image_bytes}
)
lines = []
for block in response['Blocks']:
if block['BlockType'] == 'LINE':
lines.append({
'text': block['Text'],
'confidence': block['Confidence']
})
return lines
def parse_structured_data(raw_lines):
title = None
items = []
instructions = []
quantity_pattern = r'^(d+[s/]*d*)s*(cups?|tbsp?|tsp|oz|lbs?|g|ml|c)s+(.+)'
for line in raw_lines:
text = line['text'].strip()
match = re.match(quantity_pattern, text, re.IGNORECASE)
if match:
items.append({
'quantity': match.group(1),
'unit': match.group(2),
'item': match.group(3)
})
elif not title:
title = text
else:
instructions.append(text)
return {'title': title, 'items': items, 'instructions': instructions}
if __name__ == "__main__":
for image_file in sorted(Path("images").glob("*")):
print(f"n--- {image_file.name} ---")
raw_lines = extract_document(image_file)
result = parse_structured_data(raw_lines)
print(json.dumps(result, indent=2))
Works on 30% of the documents. The other 70% break at least one assumption. Title not on line one. Quantities written backwards. Abbreviations I’ve never seen. Crossed-out text mixed into the content. Multi-line entries split apart.
Every new document, a new edge case. Every new edge case, another if, another regex.
Saturday Night
Here’s where I’m at:
The parser is now more work than just typing things by hand.
And every time I fix one document’s output, three others break. The heuristics are fragile. Interconnected. Basically untestable because no two documents look alike.
One document has a crossed-out line. Original text scratched out, correction written above. Any person glances at it and reads the correction. Half a second.
Textract returns both lines. Jumbled. My parser doesn’t know what a strikethrough is. Teaching it would mean analyzing the spatial layout of ink strokes. That’s not a text problem anymore. That’s a computer vision problem.
I’m a full day in. The system I’m building reads worse than I do, and the code to make it slightly less bad is growing faster than the documents it’s supposed to process.
Every developer using Claude Code or Cursor has hit the same wall at some point.
You spin up a new project, start vibing with the AI, and for the first hour everything feels like magic. Then slowly things start going sideways. The agent reformats a file it had no business touching. It runs the entire test suite to check a two-line change. It invents a new folder structure that contradicts the one you established three days ago. It adds an abstraction layer you didn’t ask for and now have to maintain.
None of this is the AI’s fault. It’s working with what you gave it.
The uncomfortable truth about AI coding tools
AI agents don’t have opinions. They infer conventions from context. If your project has strict ESLint rules, the agent follows them. If your project has no rules, the agent makes them up – differently every session.
This means the single biggest lever you have over AI code quality isn’t your prompt. It’s your project setup.
I spent months figuring this out the hard way, and the pattern became clear:
Lint rules act as a spec. When ESLint is configured with sonarjs, unicorn, and perfectionist, the agent produces code that passes those rules – or the pipeline rejects it and the agent fixes itself. Either way, low-quality code doesn’t accumulate.
Tests change agent behavior. A project with Jest already configured gets test coverage by default. The agent writes tests because the infrastructure is there. Without it, tests are always “coming later” -and later never comes.
Architecture is contagious. Consistent folder structure and naming conventions propagate. The agent sees the pattern and follows it. An inconsistent codebase produces inconsistent AI output.
Token waste is a setup problem. By default, Claude Code reads everything it can find, runs the broadest possible test suite, and touches adjacent code “just to be safe.” This is expensive and produces
noisy diffs. A well-written CLAUDE.md fixes most of it.
What CLAUDE.md actually changes
CLAUDE.md is a file Claude Code reads at the start of every session. It’s essentially a standing instruction set for the agent – and it has a measurable effect on how the agent operates.
Here’s what made the biggest difference in practice:
Cost Saving Rules
Code Rules
After adding these rules, the diffs got smaller, token usage dropped, and reviews became faster. The agent stopped “helpfully” refactoring things that were working fine.
Rockpack 8.0
I’ve been maintaining Rockpack for several years – a CLI scaffolder for React projects. Version 8.0 is the first release built with AI-assisted development as a
first-class concern.
One command:
npm i -g @rockpack/starter
rockpack my-app
What you get:
Supported project types: React SPA, React SPA + SSR, React Component (npm-ready), UMD Library.
Why this matters now
A year ago, “AI-friendly project setup” wasn’t a thing people thought about. Today it’s the difference between an AI that saves you hours and one that creates extra work.
The tools are good. The gap is the environment they work in.
Rockpack closes that gap in a few minutes instead of a few days.
https://github.com/AlexSergey/rockpack – MIT license.
If you’re actively using Claude Code or Cursor, I’d be genuinely curious what’s in your CLAUDE.md. There’s no established best practice yet and the community is still figuring this out.
The Problem We Were Actually Solving
It was our third server migration in three months, and our newly minted engineer, Alex, was frantically calling me from his desk. “Our server’s lagging, Chris, and it’s all because of the event handling!” His words were laced with panic. The users were complaining about slow response times and dropped events. We’d deployed the standard out-of-the-box event handling configuration from Veltrix, but somehow it wasn’t coping with our rapidly expanding server.
As I analyzed our Prometheus metrics, my anxiety only amplified – we were at 98% CPU utilization, and the error rate for our events service had shot up to 2.5%. We needed to act fast before our users deserted us in droves.
What We Tried First (And Why It Failed)
We decided to opt for the time-tested ‘EventBatching’ approach to alleviate some of the pressure off our CPU. It was a straightforward technique where the client-side events would be batched together before being sent to our server. This would theoretically reduce the number of events we’d need to process, thus cutting down on CPU usage. However, we hit a problem when we realized that this approach was making it difficult for us to identify and tackle the root issues of the problem. Without real-time event processing, we struggled to pinpoint the events that were causing the server to be overwhelmed.
A few days into our experiment, we encountered another problem: the client-side batching introduced an unacceptable delay in event processing, which, in turn, gave us an average latency of around 10 seconds for the events service.
The Architecture Decision
We decided to shift our focus towards more scalable event handling, using an Event Sourcing approach. This allowed us to offload the complex event processing to our storage solution, AWS DynamoDB, and decouple it from the CPU-intensive processing on our server. This approach not only solved our CPU utilization problem but also allowed us to handle an enormous amount of events without incurring significant delays.
We used the AWS DynamoDB streams and Fan-out Queue design pattern to offload the events into batches and eventually process them. This provided us with a seamless real-time experience, without compromising on the high availability and scalability that our users expected from us.
What The Numbers Said After
Our server CPU utilization dropped by 25%, and the error rate for our events service plummeted to 0.2%. This gave us the much-needed breathing room to further optimize our system. The latency for our events service decreased to a whopping 200 ms, allowing users to experience a seamless gaming experience.
What I Would Do Differently
Looking back, I would suggest more comprehensive stress testing for the EventBatching approach before deciding on it as the primary solution. Also, we didn’t initially benchmark the client-side batching, which could have given us a clearer picture of its performance implications.
In hindsight, while the Event Sourcing approach was a resounding success, it would be beneficial to explore other configuration and design patterns, such as ‘Event Meshes’ or ‘Kafka Streams’, that could further improve our system’s performance and scalability. This would help us avoid potential bottlenecks and anticipate future requirements before they become critical issues.
DoSync Concepts — Part 2 of 5
There’s a rule every smart home developer has written at least once:
if motion_detected and time > 22:00:
turn_on(hallway_light)
It works. It’s simple. And it’s the foundation of how every major home automation platform thinks about intelligence today.
The problem isn’t that the rule is wrong. The problem is what happens when you add an AI agent to the system — and why rules, no matter how many you write, are the wrong abstraction for that job.
The rule-writing problem
Rules are commands in disguise. “If X happens, do Y” is just a delayed command — the human still decided what Y should be, they just decided it in advance.
That works perfectly when you can anticipate every scenario, your device set never changes, and the AI’s job is simply to trigger pre-approved responses. None of those assumptions hold in a real AI-augmented environment.
Consider what happens when you add a new device. A smart lock arrives. You register it with your platform. Now you have to go back through every relevant rule and add the lock. Miss one and the system silently does nothing in exactly the scenario where you needed it most.
Or consider an AI that detects unusual temperature patterns in the kitchen — a sensor reading that might mean the fridge compressor is failing. The AI knows something is wrong. But there’s no rule for “fridge compressor anomaly,” because nobody wrote one. The system does nothing.
This is the brittleness problem: hardcoded automations only respond to situations that were anticipated when the rule was written.
Why AI agents make this worse, not better
The intuitive solution is to write more rules, or smarter rules. Use the AI to generate them. Inspect logs and auto-suggest new automations.
But this misses the architectural problem.
An AI agent doesn’t produce rules. It produces understanding. When a vision model detects a fall, it doesn’t know it needs to call phone.call(“911”) and lock.unlock() and alarm.activate(“emergency”). It knows there’s an emergency. The translation from understanding to commands still has to be written somewhere — by someone — in advance.
The more capable the AI, the more situations it can detect. And every new situation the AI can detect is a new set of rules that needs to be written to respond to it. The rule surface grows faster than anyone can maintain it.
What capability-based discovery changes
The alternative is to shift where the knowledge lives.
Instead of centralizing the response logic in rules, distribute it to the devices themselves. Each device declares what it can do and in what contexts it’s appropriate to act:
json{
"device_id": "lock-frontdoor-01",
"tags": ["door-lock", "entrance", "emergency"],
"actuators": [
{ "type": "unlock", "emergency_capable": true }
],
"emergency_capable": true
}
This manifest is not a rule. It’s a declaration. The device is saying: I can unlock. I’m relevant in emergencies. I’m at the entrance.
When the AI fires a semantic intent — ensure_safety / emergency — the resolver reads every registered manifest and asks: which devices declared themselves relevant to this situation? It builds the response at runtime, from what’s actually available.
ensure_safety [emergency]
→ lock-frontdoor-01 unlock (emergency_capable, entrance tag)
→ alarm-main-01 activate (emergency_capable)
→ wiz-living-01..10 turn_on (light tag, full brightness)
→ notifier-sms-01 notify (communication tag)
All in parallel. No rules written for this scenario.
Add the smart lock tomorrow — it participates automatically in every relevant scenario. No rule rewriting. No code changes. The device brought its own knowledge.
The difference that matters
Hardcoded automations are fragile because they encode knowledge in a central place that can’t keep up with change. Every new device, every new scenario, every new AI capability requires human intervention to update the rules.
Capability-based discovery distributes that knowledge to the edges. Devices own their context. The system is resilient to change because adding new capabilities is additive, not a rewrite.
For AI agents specifically, this is the difference between a system that only responds to situations you anticipated and a system that responds to situations the AI can detect — whether you anticipated them or not.
GitHub: https://github.com/giulianireg-spec/dosync-protocol
License: Apache 2.0
DoSync Concepts is a series exploring the ideas behind the DoSync Protocol — the semantic layer between AI agents and physical systems.
The hidden authority of AI agents inside ERP, purchasing, inventory, approvals, and enterprise workflows
TL;DR
The next enterprise AI risk is not that a chatbot writes a bad email. It is that an AI agent quietly enters the operational layer of the company and starts ranking priorities, routing approvals, classifying risk, delaying purchases, escalating tickets, flagging customers, and shaping managerial decisions before anyone calls it management.
Companies still describe these systems as “assistants” because the word sounds harmless. But once a system can trigger action inside an ERP, CRM, inventory platform, purchasing workflow, or finance dashboard, it is no longer merely assisting.
It is participating in management.
The problem is not automation itself. The problem is invisible delegation: authority moves into workflows, prompts, thresholds, model outputs, and software rules, while responsibility remains formally assigned to humans who may only see the final recommendation.
That is how an AI assistant becomes a shadow manager.
Meta Description
AI agents inside ERP, purchasing, inventory, finance, and enterprise workflows are no longer just assistants. They increasingly rank, route, classify, escalate, and shape operational decisions. This article explains how invisible delegation turns AI into shadow management.
*1. The Assistant Myth
*
Everyone calls them AI assistants because “assistant” sounds harmless.
An assistant helps. An assistant supports. An assistant drafts, summarizes, searches, reminds, and organizes.
That language is accurate only while the system remains outside the decision chain.
Once the system can rank leads, block a purchase order, classify a vendor, flag a customer, recommend a reorder quantity, trigger a workflow, escalate a ticket, assign urgency, or prepare an approval path, the term “assistant” becomes misleading.
At that point, the system is no longer just helping a manager.
It is shaping the managerial environment before the manager acts.
This distinction matters because enterprise work is not made only of final decisions. Most corporate power lives in prioritization, routing, classification, timing, and escalation. Whoever controls those layers does not need to sign the final approval to influence the outcome.
A sales manager may still approve the weekly focus list, but if an AI system ranked the leads first, part of the commercial decision has already been made.
A purchasing manager may still approve the order, but if the ERP agent has already recommended the vendor, adjusted the quantity, flagged the risk, and routed the approval path, the decision has already been pre-shaped.
A finance controller may still review the expense, but if an AI classifier has already coded the transaction and assigned its risk level, the human review begins inside a frame built by the system.
That is the assistant myth: the company believes AI is supporting decisions when, in practice, AI is already structuring them.
The human manager remains visible. The automated manager remains embedded.
*2. From Chatbots to Agents
*
The first wave of enterprise AI was easy to understand.
A chatbot answered questions. A writing tool drafted text. A summarizer compressed documents. A search assistant retrieved information.
Those tools could be wrong, but their wrongness usually stayed inside language. A bad answer could be corrected. A weak summary could be rewritten. A hallucinated paragraph could be deleted.
AI agents are different.
An agent is not only a text generator. It receives a goal, consults tools, uses data, plans steps, invokes functions, and may change the state of a system.
That shift changes the risk model.
A chatbot says: “You may want to reorder this item.”
An agent creates a draft purchase order.
A chatbot says: “This customer seems high priority.”
An agent moves that customer to the top of the pipeline.
A chatbot says: “This invoice may be misclassified.”
An agent changes the expense code.
A chatbot says: “This ticket looks urgent.”
An agent escalates it to another department.
The first system produces language. The second system produces operational consequences.
That is the line companies often fail to mark.
The word “assistant” hides the transition from advice to action. But enterprise systems do not care whether a workflow was triggered by a human, a script, a rule, or a model. Once the system state changes, the company has acted.
This is where AI becomes managerial.
Not because it has a job title. Not because it sits in a meeting. Not because it appears on the organization chart.
It becomes managerial because it shapes attention, timing, access, priority, and execution.
*3. Where the Shadow Manager Appears
*
The shadow manager does not appear as a robot boss.
It appears as a workflow.
It appears as a recommendation that nobody questions because it came from the dashboard.
It appears as a priority score.
It appears as a blocked order.
It appears as an automatic escalation.
It appears as a vendor warning.
It appears as a risk label.
It appears as an approval path that feels procedural but was shaped by a model.
This is already visible in ordinary enterprise operations.
In sales, an AI system may rank leads according to predicted conversion. That ranking influences which customer receives attention first. The salesperson may think they are choosing, but the field of choice has already been ordered.
In purchasing, an AI agent may recommend suppliers based on price, delivery history, stock availability, vendor score, payment terms, or risk profile. That recommendation can quietly shift purchasing behavior away from human relationship knowledge and toward model-weighted criteria.
In inventory, an agent may recommend reorder quantities, flag slow-moving items, identify overstocks, and predict demand. If those predictions are wrong, the error does not remain theoretical. It becomes cash tied in stock, delayed sales, missing products, emergency orders, or warehouse friction.
In customer service, an AI system may decide which complaint deserves escalation. That decision affects response time, customer satisfaction, and the perceived seriousness of the issue.
In finance, AI classification may assign expenses, flag anomalies, group transactions, or prepare reports. If the classification is wrong, the error can affect reporting quality, cost-center visibility, departmental accountability, and managerial interpretation.
In operations, AI may summarize performance, highlight bottlenecks, and define what leadership sees first. That is not neutral. The first metric shown often becomes the first problem discussed.
The shadow manager does not need to make every decision.
It only needs to shape the order in which decisions become visible.
**
Traditional corporate authority is usually imagined as a clean hierarchy.
Owner. Executive. Manager. Supervisor. Employee. Action.
Enterprise AI complicates that structure.
The real chain can become:
Policy. System configuration. Data source. Prompt. Model output. Workflow trigger. Dashboard ranking. Human approval. Operational action.
The human remains inside the chain, but not always at the beginning of it.
This matters because responsibility is often assigned at the visible end of the process, while influence may have entered much earlier.
A manager may approve a purchase order without knowing that the recommended quantity was produced by a demand model trained on incomplete seasonal data.
A sales lead may be ignored because a scoring system placed it below the threshold, even though the model failed to capture a relationship or local market signal.
A warehouse adjustment may be flagged as suspicious because the system misread an operational pattern.
An accounts receivable account may be deprioritized because the dashboard over-weighted one indicator and under-weighted another.
In each case, the human did not disappear. But the human arrived late.
That is the key structure.
The visible manager signs, approves, reviews, or accepts. The invisible system has already arranged the options.
This is not the end of human authority. It is the redistribution of authority across software layers.
The company still says “the manager decided.”
But the better question is: who structured the decision before the manager saw it?
*5. Why ERP Makes This More Serious
*
AI inside a document editor is useful.
AI inside an ERP is different.
An ERP is not just software. It is the operational nervous system of the company. It connects sales, purchasing, inventory, accounting, logistics, invoicing, vendor records, customer records, product movement, and reporting.
When AI enters that layer, errors become operational.
A weak paragraph is a content problem. A wrong reorder suggestion is a cash problem. A bad vendor classification is a supply problem. A wrong expense code is a reporting problem. A bad lead ranking is a revenue problem. A wrong delivery priority is a customer problem. A bad inventory signal is a service problem.
This is why enterprise AI cannot be judged only by generic model benchmarks.
A model does not need to be generally “smart” to create damage. It only needs to be wrong at the point where the business acts.
The most dangerous AI in a company may not be the most advanced model. It may be the boring workflow nobody audits.
The purchase recommendation. The lead score. The automatic approval rule. The AR risk flag. The reorder suggestion. The inventory exception. The vendor ranking. The escalation logic.
These systems become powerful because they sit close to action.
They do not merely describe the business. They participate in running it.
This is why companies need a different vocabulary. Calling these systems “assistants” is not enough. In operational environments, an AI system should be classified according to its action rights.
Can it read data? Can it recommend action? Can it trigger action? Can it block action? Can it route approval? Can it change records? Can it reorder priorities? Can it modify system state?
The moment the answer becomes yes, the company is no longer dealing with a passive tool.
It is dealing with delegated operational authority.
6. The Accountability Gap
Most enterprise AI discussions focus on hallucination.
That focus is too narrow.
Hallucination matters when a model invents facts. But in enterprise workflows, the more common danger may be misclassification, over-ranking, under-ranking, false escalation, silent omission, wrong routing, and unexamined recommendation.
The system does not need to hallucinate to create harm.
It can use real data and still produce a bad decision structure.
It can classify an account as low priority because the available data is incomplete.
It can recommend delaying a purchase because it underestimates demand.
It can flag an employee action as unusual because the workflow does not understand local practice.
It can prioritize one customer because the model values transaction size over strategic relevance.
It can mark an item as slow-moving while ignoring a coming seasonal spike.
These are not hallucinations. They are operational distortions.
The accountability gap appears when nobody can answer seven basic questions:
What data did the system use?
What rule or model produced the recommendation?
What threshold was applied?
What alternatives were suppressed?
Who reviewed the output?
Who had authority to override it?
What happened after the recommendation was accepted?
Without those answers, the company has built authority without memory.
A human manager can be questioned. A workflow often cannot. A model output may be overwritten. A system recommendation may leave no readable trace. A dashboard may show the result without exposing the path.
That is not automation maturity. It is managerial opacity.
7. What Developers and Operators Should Log
The solution is not to reject AI agents.
The solution is to stop pretending they are harmless assistants once they touch operational decisions.
If an AI system can influence action, it needs an audit trail.
At minimum, enterprise AI agents should log:
Input source.
Data timestamp.
Prompt or instruction version.
Model version.
Tool used.
External system accessed.
Rule applied.
Threshold used.
Recommendation generated.
Action triggered.
Human reviewer.
Override status.
Final decision.
Business impact.
Error category, if later detected.
This is not bureaucratic decoration. It is the basic condition for operational accountability.
If a purchasing agent recommends a quantity, the company should know why.
If a sales agent ranks a lead, the company should know what signals mattered.
If a finance classifier assigns an expense category, the company should know which rule or model produced the classification.
If an inventory agent flags an item, the company should know whether the signal came from sales history, warehouse movement, vendor delay, forecast variance, or a model-generated probability.
This is how enterprise AI becomes governable.
Not by asking whether the system is impressive.
By asking whether its authority is visible.
The wrong question is:
“Is this AI intelligent?”
The better question is:
“What authority does this AI have?”
That question changes the entire evaluation.
A simple model with access to an ERP approval workflow may have more operational power than a more advanced model trapped inside a chat window.
A mediocre classifier embedded in finance may produce more business risk than a brilliant writing assistant.
A small automation that blocks orders may matter more than a large model that only drafts emails.
Enterprise AI should therefore be evaluated by authority level, not only by capability.
Level 1: It reads information.
Level 2: It summarizes information.
Level 3: It recommends action.
Level 4: It routes action.
Level 5: It triggers action.
Level 6: It blocks action.
Level 7: It changes system state with limited human review.
The higher the level, the stronger the audit requirement.
This framework is simple, but it prevents the core mistake: treating all AI outputs as if they were merely advisory.
They are not.
Some outputs become instructions. Some recommendations become defaults. Some defaults become behavior. Some behavior becomes policy. Some policy becomes authority.
**
Managers should care because AI agents can make them responsible for decisions they did not fully structure.
A manager may be asked why an order was delayed. The real cause may be a workflow rule.
A manager may be asked why a customer was ignored. The real cause may be a lead-ranking model.
A manager may be asked why inventory ran short. The real cause may be a bad demand signal.
A manager may be asked why expenses were misclassified. The real cause may be an automated coding system.
In all these cases, the manager remains accountable while the system remains partially invisible.
That is a bad trade.
AI should reduce operational burden, not create a fog of responsibility.
For managers, the practical rule is direct: never allow an AI agent to influence action without knowing where its recommendation appears, how it is produced, how it can be challenged, and who owns the final decision.
Management cannot be delegated into a black box and then recovered only when something fails.
**
Developers should care because every enterprise AI agent is also a governance system.
A function call is not just a technical event when it changes a purchase order, a customer priority, a stock level, an invoice category, or an approval path.
A ranking algorithm is not just a ranking algorithm when it determines who gets attention first.
A classification model is not just a classifier when departments rely on it for reporting, escalation, or compliance.
A prompt is not just a prompt when it controls how operational language is converted into action.
This means developers are not merely building features. They are designing decision environments.
That does not mean developers become the moral owners of every business outcome. It means technical design choices can create managerial consequences.
What gets logged matters.
What gets hidden matters.
What becomes the default matters.
What can be overridden matters.
What requires human review matters.
What silently moves forward matters.
Enterprise AI development should therefore include one question in every workflow design:
Where does this system acquire practical authority?
That question is more useful than vague debates about whether AI will replace managers. In many companies, replacement is not the first step. Quiet redistribution is.
The job title stays human. The workflow becomes automated. The decision frame becomes synthetic. The responsibility remains unclear.
That is the shadow manager problem.
11. The Core Claim
Stop calling it an AI assistant if it can manage priority, routing, approval, classification, escalation, or execution.
Inside enterprise systems, assistance can become authority without changing its name.
That is the risk.
Not evil AI. Not science fiction. Not a robot CEO. Not a dramatic replacement of human managers.
The real shift is quieter.
AI enters the company as a helper. It gets connected to tools. It receives access to business data. It starts producing recommendations. Those recommendations become defaults. Those defaults shape workflows. Those workflows shape decisions. Those decisions shape the company.
By the time leadership notices, the assistant is already managing part of the business.
The future of enterprise AI will not be decided only by which model writes better emails or produces cleaner summaries.
It will be decided by which systems can act inside companies without making responsibility disappear.
Why It Matters
This matters because modern companies already run through software.
Sales teams follow dashboards. Purchasing follows workflows. Inventory follows system signals. Finance follows classifications. Managers follow reports. Executives follow summaries.
When AI enters those layers, it does not need to dominate the company to change it. It only needs to reorder what the company sees, delays, escalates, approves, or ignores.
The practical danger is not that AI becomes conscious.
The practical danger is that AI becomes procedural.
It becomes part of how the company moves.
And once it moves the company, it must be audited as authority, not described as assistance.
Related Academic Background
This article extends my broader work on how automated language systems redistribute agency, responsibility, and authority through formal structures.
*Related paper:
*
Expense Coding Syntax: Misclassification in AI-Powered Corporate ERPs https://doi.org/10.2139/ssrn.5361952
The paper examines how AI-powered ERP systems can produce misclassification risks when automated language and coding structures convert business events into financial categories. The broader issue is the same: when automated systems classify, route, or encode decisions, they do not merely represent the business. They reshape how the business becomes legible and actionable.
*About the Author
*
Agustin V. Startari is a linguistic theorist, author, and researcher in historical studies. His work examines the relationship between artificial intelligence, syntax, authority, institutional discourse, and the disappearance of agency in automated language systems.
He is the author of Grammars of Power, The Grammar of Objectivity, Suffering Without Perpetrators, The Grammar of Asymmetric Visibility, and Expense Coding Syntax. His research focuses on how language models and institutional systems redistribute responsibility through grammatical, operational, and procedural form.
*Personal website: *https://www.agustinvstartari.com/
*SSRN Author Page: * https://papers.ssrn.com/sol3/cf_dev/AbsByAuth.cfm?per_id=7639915
ResearcherID: K-5792-2016
Authorial Ethos
I do not use artificial intelligence to write what I don’t know. I use it to challenge what I do. I write to reclaim the voice in an age of automated neutrality. My work is not outsourced. It is authored. – Agustin V. Startari
Suggested Tags
AI, Enterprise AI, AI Agents, ERP, Automation, Workflow Automation, Management, Operations, Purchasing, Inventory, Finance, Business Software, AI Governance, Agentic AI, NetSuite, Enterprise Software, Accountability, Decision Systems