When the Cleanup Code Becomes the Project

yazar

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:

  • Pre-processing with 6 configurable parameters
  • 200+ lines of regex and heuristics
  • 70% of documents still need a human
  • Accuracy I’m being generous calling 30%

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.

Rockpack 8.0 – A React Scaffolder Built for the Age of AI-Assisted Development

yazar

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

  • Run only affected tests when possible
  • If only one test file was modified, run only that file
  • Read only files relevant to the current task
  • Avoid scanning the entire repository unless necessary

Code Rules

  • Don’t add features or abstractions beyond what the task requires
  • Prefer minimal diffs
  • Avoid reformatting unrelated code
  • Preserve existing architecture and conventions

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:

  • React 19 + TypeScript 6 with strict configuration
  • Webpack 5 – CSR, SSR, library builds, bundle analysis out of the box
  • ESLint 10 flat config – sonarjs, unicorn, perfectionist, no-only-tests, import-lite, Prettier integrated
  • Pre-commit hooks – lint runs before every commit, bad code physically cannot get in
  • Jest pre-configured with TypeScript support
  • Feature-based project structure – consistent from the first file
  • Optimized CLAUDE.md – included in every generated project

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.

Mismanaging the Treasure Hunt Engine in Hytale Servers Will Get You Killed

yazar

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.

Why Hardcoded Automations Fail AI Agents

yazar

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.

Stop Calling It an AI Assistant. It’s Already Managing Your Company

yazar

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.
**

  1. The Hidden Chain of Command**

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.

  1. A Better Test: Authority, Not Intelligence

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.
**

  1. Why Managers Should Care**

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.
**

  1. Why Developers Should Care**

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

Why I built a post-quantum signing API (and why JWT is on borrowed time)

yazar

JWT with RS256/ES256 is everywhere. It’s also going to be broken.

Not today. But the clock is ticking — and the timeline is shorter than most developers think.

The problem with classical signatures

Every JWT signed with RS256 or ES256 relies on RSA or ECDSA. These algorithms are vulnerable to Shor’s algorithm running on a sufficiently powerful quantum computer. NIST finalized the post-quantum replacements in August 2024 — but most developers haven’t started migrating yet.

The threat isn’t just future decryption. Nation-state actors are already harvesting signed traffic today to decrypt and forge once quantum computers arrive. “Harvest now, decrypt later” is a real attack pattern.

What I built

I built FIPSign — a signing API built on ML-DSA-65 (NIST FIPS 204). The idea is simple: you call /sign with any payload, get back a quantum-resistant token. No infrastructure to manage, no keys to generate or rotate, no DevOps. 

const { token } = await pq.sign({
  sub: 'user_123',
  role: 'admin',
  expiresInSeconds: 3600,
})

const { valid, payload } = await pq.verify(token)

Not just for auth

Most post-quantum signing tools focus only on user authentication. FIPSign lets you sign anything — the only required field is sub, any string identifying the entity:

  • sub: "user_123" — user sessions
  • sub: "order_456" — payment intents
  • sub: "doc_789" — document certification
  • sub: "device_iot_001" — IoT firmware

How revocation works

Revocation is built in. When you revoke a token, we store a SHA-256 hash of the ML-DSA-65 signature as a blacklist entry in Cloudflare D1. Every remote /verify call checks that blacklist. Entries expire automatically when the original token would have expired.

Local verification (localVerify: true) runs entirely in memory at ~1ms with no API call — but doesn’t check revocation. Use remote verification for payments and admin actions.

The pricing model

No monthly subscriptions. 10,000 free tokens/month that reset automatically. Each sign, verify, or revoke costs 1 token. For most projects, 10,000 tokens/month is enough to never pay anything. If you need more, token packs never expire and accumulate across purchases.

Why ML-DSA-65 specifically?

ML-DSA-65 is NIST security level 3 — the right balance between security and signature size for API use cases. ML-DSA-44 is faster but lower security. ML-DSA-87 produces larger signatures with no practical benefit for most applications.

The implementation uses @noble/post-quantum — a widely audited library you can verify independently.

Try it

npm install fipsign-sdk

Full guide at fipsign.dev/guide. Free account at app.fipsign.dev — no credit card.

Happy to answer any questions about the cryptography, the architecture, or the migration path from JWT.

Weekend Thought: Frontend Build Tools Suffer From Work Amnesia

yazar

A lot of frontend tooling discussions focus on speed.

Faster startup.

Faster HMR.

Faster builds.

Those things matter — but at scale, they aren’t where most of the cost comes from.

The real problem shows up as work amnesia.

Most build tools treat every run as a fresh start:

  • dependency graphs are rediscovered

  • transformations are repeated

  • valid work is forgotten

That behaviour was fine when frontend apps were small and isolated.

In 2026, frontend applications are:

  • long‑lived

  • graph‑based

  • shared across teams

  • rebuilt continuously in CI

At that point, forgetting becomes expensive.

Build systems stop being scripts and start behaving like systems — whether we design them that way or not.

The next step for frontend tooling isn’t just running faster.

It’s remembering what’s already valid and reacting only to real change.

That’s the problem space Ionify exists in.

Not as another tool —
but as a build intelligence engine that treats frontend builds as systems with memory.

Curious how others here think about build tools once projects grow past “single app” scale.

Şut çekme konusunda çok yetenekli bir insansı robot hazırlandı [Video]

yazar
insansı robot

insansı robotÇin merkezli robot üreticilerinden Booster Robotics, şut çekme konusunda oldukça yetenekli bir insansı robot hazırladı. X’te “T2 Soccer” adıyla paylaşılan ve eylül teslimatı için ön siparişe açıldığı aktarılan robot, birçok benzer seçenekten çok daha etkili vuruşlar gerçekleştirebililiyor olmasıyla dikkat çekiyor. Henüz çok fazla detayın paylaşılmadığı robot, Çinli şirketlerin alanda ulaştığı son seviyeyi gösteren önemli bir örnek daha olmuş durumda. T2 Soccer. We literally got a hole at the ceiling of our lab from this. pic.twitter.com/c9jTe42pTW — Eren Chen (@ErenChenAI) May 22, 2026

Şut çekme konusunda çok yetenekli bir insansı robot hazırlandı [Video] yazısı ilk olarak Teknoloji haberleri – LOG üzerinde yayınlandı.

A 10-Line Playwright Trick That Saved Me Hours on Every Sephora Run

yazar
Fig. 1 — Page weight before vs after the block list. Same DOM, less network.

Most Playwright tutorials teach you to scrape a single page. Real scrapers need to scrape thousands. The thing that kills you isn’t the selector — it’s everything Playwright does before it touches the selector.

By default, Playwright loads a page like a human visiting a website. It downloads CSS, fonts, analytics scripts, A/B testing pixels, hero images, lazy-loaded carousels, and three different chat widgets. On a product catalog page, that’s 4–6 MB of stuff you don’t need. Times 10,000 pages, that’s the difference between a 20-minute run and a 3-hour run.

Here’s the 10-line route handler I drop into every actor: 

const BLOCKED = ['image', 'media', 'font', 'stylesheet'];

await context.route('**/*', (route) => {
  const type = route.request().resourceType();
  const url  = route.request().url();
  if (BLOCKED.includes(type)) return route.abort();
  if (/google-analytics|doubleclick|hotjar|segment|gtm/.test(url)) {
    return route.abort();
  }
  route.continue();
});

That’s it. Two lists: resource types you don’t need, and tracking domains you definitely don’t need.

The 3-item checklist before you ship this

  1. Test that your data is still there. Some sites lazy-load product info into image data- attributes. Aborting images can sometimes break extraction. Run with and without the route handler and diff the output.
  2. Don’t block scripts. Modern sites build the DOM with JS. Aborting scripts will give you an empty page. (CSS and fonts are safe — Playwright doesn’t need them to find selectors.)
  3. Watch for sites that detect this. Some bot-detection scripts check whether you fetched the analytics pixel. If your success rate drops after enabling this, allow the analytics domains back through.

Fig. 1 — Page weight before vs after the block list. Same DOM, less network.

Quick case

On our Sephora product info actor, this single change cut average page load from 4.8s to 1.3s. Across a 5000-product catalog scrape, that’s the difference between 6.5 hours and 1.8 hours. Same selectors, same data, same success rate. We just stopped downloading hero images of moisturizers we never look at.

It also dropped our Apify compute units per run by ~60%, which directly affects what we charge customers. Faster scraper, lower cost, same output. The route handler now ships with the Sephora product info actor and every new scraper after it.

The CTA you didn’t ask for

This route handler ships with our starter actor template. New scrapers get it on day one. Old scrapers got it bolted on the first time we noticed runtime > 1 hour.

The pattern works on any browser-based scraper — Playwright, Puppeteer, Selenium with CDP. The shape is always: tell the browser what not to load, before you tell it what to find.

One quick note for the JS-heavy among you: the same pattern applies to Puppeteer’s page.setRequestInterception(true) — same idea, slightly different API. Same wins.

Drop your slowest scraper’s runtime in the comments. I’ll guess what’s eating your minutes. (Hint: it’s probably hero images.)

Agree, disagree, or have a site where blocking images breaks something subtle? Reply.

Written by **Nova Chen, Automation Dev Advocate at SIÁN Agency. Find more from Nova on dev.to. For custom scraping or automation work, hire SIÁN Agency.

AI Is Changing Engineering Culture More Than We Realize

yazar
Late-night developer workspace with VS Code, terminal windows, and AI assistant panels open

“A grounded look at the technical and psychological realities of modern AI tooling.”

When ChatGPT became mainstream in 2022, most developers had the same reaction:

“This changes everything.”

And honestly, it did.

For the first time, developers could:

  • generate boilerplate instantly
  • debug faster
  • learn unfamiliar stacks quickly
  • prototype products in hours instead of weeks
  • reduce repetitive engineering work dramatically

Then the ecosystem exploded.

Suddenly there was:

  • Claude for deep reasoning and coding
  • Gemini integrated into developer workflows
  • Grok entering the ecosystem
  • autonomous coding agents
  • AI IDEs
  • AI copilots
  • AI PR reviewers
  • AI DevOps assistants
  • browser agents
  • AI-generated full-stack applications

Now every week another “AI-powered developer tool” launches.

But after working with these systems continuously, I think the bigger story is no longer about model capability.

It is about engineering culture.

Because AI is not just changing how developers build.

It is slowly changing how developers think.

Late-night developer workspace with VS Code, terminal windows, and AI assistant panels open

The Shift From “AI Assistance” To “AI Participation”

The first phase of developer AI tools felt balanced.

Developers still:

  • designed architecture
  • reasoned through systems
  • debugged deeply
  • read documentation
  • structured applications manually

AI mostly accelerated implementation.

It handled:

  • repetitive code
  • syntax generation
  • explanations
  • small debugging tasks
  • documentation assistance

The human was still clearly driving the system.

But now the ecosystem is moving toward something very different:

agentic workflows.

And this changes the relationship entirely.

Modern AI systems can now:

  • generate entire applications
  • refactor large codebases
  • operate terminals
  • execute deployment workflows
  • connect APIs
  • browse documentation autonomously
  • generate UI systems
  • run multi-step engineering tasks

That is no longer autocomplete.

That is partial delegation of engineering itself.

And honestly, this is where things become psychologically interesting.

Because the question is no longer:

“Can AI generate code?”

The question is:

“How much engineering participation are developers slowly giving away?”

Prompt Engineering Quietly Became A New Layer Of Development

One thing many non-developers miss is that different models behave very differently in real workflows.

For example:

  • ChatGPT is often more forgiving with vague prompts
  • Claude tends to perform better with structured reasoning and larger contexts
  • Gemini sometimes benefits from more explicit formatting and workflow clarity

That means prompting itself has quietly become an engineering layer.

Not just “asking questions.”

But:

  • context design
  • instruction structuring
  • constraint management
  • workflow orchestration
  • output steering

A surprising amount of modern development is now:

engineering the AI interaction layer.

Which creates another strange shift:
developers increasingly optimize communication with models instead of directly interacting with systems themselves.

That is a fascinating cultural transition.

Structured AI prompts alongside generated code and architecture outputs on dual monitors

Most AI Tools Depend On The Same Few Foundations

One observation that keeps standing out to me:

There are now hundreds of thousands of AI tools.

But underneath them, only a very small number of foundational models are powering most of the ecosystem.

A huge percentage of AI products still rely on infrastructure from:

  • OpenAI
  • Anthropic
  • Google
  • xAI
  • and a few others

Which means many startups are not building intelligence itself.

They are building:

  • orchestration layers
  • UI systems
  • wrappers
  • workflow pipelines
  • integrations
  • automation systems

on top of centralized model providers.

That does not make these products useless.

But it changes the economics of the ecosystem.

Because intelligence itself is becoming infrastructure.

And infrastructure naturally centralizes.

The current AI ecosystem sometimes feels less like the early internet and more like cloud computing:

  • a small number of providers
  • massive compute concentration
  • expensive infrastructure barriers
  • ecosystem dependency

AI Infrastructure Is Brutally Expensive

A lot of AI conversations online still feel disconnected from infrastructure reality.

Training and serving modern models is extremely expensive.

Not abstractly expensive.

Physically expensive.

The ecosystem depends on:

  • GPU clusters
  • high-bandwidth memory
  • inference scaling
  • distributed systems
  • energy consumption
  • networking infrastructure
  • storage pipelines
  • cooling systems

Even inference itself becomes expensive at scale.

Which is why:

  • API pricing matters
  • token optimization matters
  • context window management matters
  • caching matters
  • latency matters

As models become larger and more capable, infrastructure pressure increases everywhere.

We are already seeing:

  • GPU shortages
  • premium pricing tiers
  • expensive enterprise plans
  • subscription fragmentation
  • increasing inference costs

The AI ecosystem currently behaves less like traditional software and more like industrial infrastructure.

That changes how sustainable rapid scaling actually is.

Server racks and networking infrastructure powering large-scale AI systems

Instant Development Culture Has Side Effects

One of the biggest changes I’ve noticed among developers is how quickly the culture around learning is changing.

Earlier:

  • developers learned frameworks deeply
  • debugging built intuition
  • architecture mistakes taught system thinking
  • documentation reading was normal
  • implementation friction created understanding

Now increasingly:

  • developers generate first and understand later
  • projects are scaffolded almost instantly
  • architecture is delegated to AI suggestions
  • debugging becomes “paste error into model”
  • exploration is replaced by generation

Again, this is not entirely bad.

AI genuinely increases productivity.

But there is a tradeoff emerging:

speed is increasing faster than understanding.

And that gap matters more than people realize.

Because engineering is not only about output.

It is also about:

  • mental models
  • system intuition
  • debugging instincts
  • architecture reasoning
  • understanding failure modes

If developers stop engaging deeply with systems, engineering culture itself changes.

Not immediately.

Gradually.

Quietly.

AI Agents May Reshape Junior Engineering Completely

This is one area where I think the industry still has unresolved questions.

Junior developers traditionally learned through:

  • repetition
  • debugging
  • small feature work
  • fixing mistakes
  • navigating large codebases manually

But agentic AI systems are increasingly automating exactly those layers.

Which creates a strange future possibility:

  • senior engineers supervising AI systems
  • fewer traditional entry-level pathways
  • reduced apprenticeship-style learning
  • compressed engineering ladders

The issue is not whether AI can generate code.

It clearly can.

The issue is:

how future developers build deep intuition if participation itself keeps shrinking.

Because engineering maturity usually comes from prolonged interaction with complexity.

And complexity is increasingly being abstracted away.

Junior developer reviewing rapidly generated AI code on multiple screens

The Economic Layer Feels Strange Too

There is also an economic contradiction inside the AI boom that feels under-discussed.

Most companies want:

  • fewer operational costs
  • faster iteration
  • reduced labor dependency
  • more automation

That logic makes sense individually.

But collectively, there is a difficult question underneath it:

If AI systems reduce large portions of knowledge work over time…

Who becomes the customer?

Who pays for:

  • subscriptions
  • SaaS products
  • enterprise software
  • APIs
  • cloud infrastructure

Technology ecosystems still depend on humans participating economically.

Which makes the current “replace as much labor as possible” mindset feel unstable long-term.

Especially when advanced AI access itself is becoming increasingly premium.

AI Is Useful. But Dependency Feels Different.

I still think AI is one of the most useful technologies developers have received in years.

It helps with:

  • rapid learning
  • prototyping
  • reducing repetitive work
  • understanding unfamiliar systems
  • accelerating experimentation

I use these systems constantly.

Most developers probably do now.

But I also think there is a meaningful difference between:

  • AI-assisted engineering
    and
  • AI-dependent engineering

That line matters.

Because once developers stop understanding the systems underneath the output, the role slowly changes from:

engineer

to:

operator.

And maybe that is the deeper shift happening right now.

Not just automation of work.

But gradual outsourcing of engineering cognition itself.

The Real Long-Term Risk May Not Be AI. It May Be Reduced Participation.

A lot of AI discussions focus on:

  • AGI
  • model intelligence
  • automation timelines
  • existential risk

But honestly, I think a quieter issue may arrive much earlier.

Convenience changes behavior.

And AI is becoming the most powerful convenience layer software has ever introduced.

The risk may not be that machines become too intelligent.

The risk may be that humans slowly stop engaging deeply with difficult thinking because instant generation becomes easier than understanding.

That applies to:

  • coding
  • writing
  • research
  • design
  • analysis
  • decision-making

And maybe the long-term divide in tech will not be:

developers vs AI

But:

developers who still understand systems deeply
versus
developers who only orchestrate outputs.

That feels like a much more realistic future.

Minimal terminal workspace with handwritten architecture notes beside a keyboard

Maybe AI Should Stay A Tool

I don’t think the solution is rejecting AI.

That would be unrealistic.

AI is already embedded deeply into engineering workflows.

But maybe the goal should not be:

removing humans from engineering completely.

Maybe the goal should be:

reducing friction while preserving understanding.

Because engineering is not just about shipping outputs.

It is about:

  • reasoning
  • systems thinking
  • tradeoff analysis
  • debugging intuition
  • learning through complexity

Those things still matter.

Even if generation becomes instant.

And maybe that is the real question developers should keep asking themselves in this AI era:

“Am I using AI to think better…
or slowly replacing my participation entirely?”

What’s your take? Are you using the free tiers for production code, or stick to local models? Let’s discuss in the comments.

Disclaimer The content of this blog is based on personal experience and my thoughts and thinking. Each individual’s insights may differ based on personal analysis.