What Building AI Systems Since 2018 Taught Me

The Tech Industry Loves Amnesia: AI Did Not Begin in 2022.

Tech firms love amnesia. Forgetting the past allows software vendors to repackage old computer science ideas as brand-new corporate must-haves.

In their landmark 2018 research paper, "BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding," Jacob Devlin and his Google AI research team showed that bidirectional language models beat older designs across industry text tests. The published research from the 2019 Conference of the North American Chapter of the Association for Computational Linguistics confirmed that deep models require strict tuning rules to deliver steady accuracy in live settings.

Back then, shipping software was quiet, gritty engineering. We did not write prompts in web browser boxes. We wrote clean code, built features by hand, and verified training data.

Read documentation from Explosion AI's spaCy framework. Enterprise text tasks require fixed code pipelines to prevent made-up names and bad data extraction. Engineering guides from the spaCy architecture guide prove this rule. Stable language systems pair statistical models with rule-based pattern matchers to guarantee exact results.

We paired machine learning classifiers with strict rule matchers. Raw models could never be trusted alone with company money. When an insurance contract mentioned an excluded damage clause, we did not ask a model to guess based on word odds. We wrote explicit regex rules and exact data parsers.

Today, many companies hand sensitive workflows to black-box web models. They have no data boundaries, no software tests, and no error logs. They confuse smooth conversational text with true operational competence.

Guessing word odds is totally different from understanding an accounting ledger. A model predicting words does not know what an invoice is. It only guesses what the next word in an invoice looks like. When that statistical guess misses, your company operations fail.

When an enterprise lets an unvalidated language model write directly to internal databases without strict software guards, that business risks corrupting customer accounts, losing track of billed inventory, and spending months of staff time cleaning up errors that a simple software check would have caught in milliseconds.

The 95% Accuracy Trap: Why 5% Edge Failures Break Companies.

In a university research paper, a model with 95% accuracy is celebrated as a major win. But in daily business operations, 95% accuracy is an operational disaster.

Look at the simple math.

Suppose your company processes 5,000 customer orders, claims, or intake files every month. You turn on a modern generative tool that advertises a 95% success rate:

• Monthly Record Volume: 5,000 files.
• Successful Processing (95%): 4,750 files.
• Failed Operations (5%): 250 bad files every month.
• Annual Corrupted Transactions: 3,000 bad records.

What happens to those 250 bad files each month? In an unmonitored setup, they fail quietly. The software misfiles an urgent customer claim as spam. It reads the wrong deductible on an insurance policy, or invents a 30% discount on a binding price quote.

In late 2021, we audited an automated insurance intake pipeline for a commercial property carrier in Ohio. An outside firm built a workflow that read loss forms and estimated claim payments using a third-party language model. In lab tests, the tool scored ninety-four percent accuracy across three thousand historical sample files. In live production, the firm processed seven thousand claims a month. Roughly four hundred bad files slipped past office workers every thirty days.

In one costly error, the model confused an exclusion rider with an approved endorsement clause. It paid out an $84,000 flood damage claim that underwriters had barred months earlier. The cash was wired to the bank before the accounting team caught the mistake in QuickBooks Enterprise.

The cash was already gone.

A tech demo looks amazing on video because the vendor chooses easy inputs that fit the model. But live production is defined entirely by how your software handles the messy edge cases that break.

If your leadership team rolls out automated workflows without building an internal human review queue for strange customer records, those silent errors will compound quietly across your books until an angry client or an outside auditor uncovers thousands of dollars in lost cash.

Stochastic Prompts vs. Hardened Deterministic Guardrails.

Modern marketing has convinced many founders that real software engineering has been replaced by prompt engineering.

That claim is dangerous nonsense.

A prompt is not software. It is an unstructured English sentence sent to a probabilistic model that returns an answer based on statistical odds. Alter a comma or change a temperature setting. Run the prompt on a Tuesday instead of a Monday. The model can return a completely different answer.

Researchers Tony Zhao and Eric Wallace showed in their ICML paper, "Calibrate Before Use," that prompt-based language models suffer from majority label bias and recency bias, causing sudden accuracy swings unless carefully tested and calibrated before live deployment.

A prompt alone cannot guarantee:

1. Valid JSON data structure.
2. Correct data types like numbers versus text.
3. Accurate math on financial balance sheets.
4. Complete removal of private customer identifiers.

Stochastic LLM Prompts vs. Deterministic Software Guardrails.

Production systems need deterministic code wrappers. When we build automated pipelines, the neural model makes up only 15% of the code. The other 85% is standard, hardened software: Redis task queues, Celery worker pools, FastAPI rate limiters handling 429 throttling errors, regex pre-processors, Pydantic schemas, cryptographic hashes, and automated rollback rules.

When a language model produces an output that fails validation by a single odd character, our software wrapper immediately catches the payload, completely blocks the database write, and sends the entire record straight to an internal human review queue.

When an experienced engineering team builds software pipelines that route daily customer records through Redis message queues and Celery background workers, your business gains the speed of modern automation without risking corrupt databases or unverified price quotes.

The Anatomy of Technology Theater: Cool Demos vs. Real ERPs.

Over the past three years, I have audited dozens of corporate software projects costing $100,000 to $300,000. Almost all suffered from the same issue: technology theater.

What does technology theater look like?

• The $150,000 Website Chatbot. An executive buys a bot trained on sales PDFs. It chats nicely, but cannot check inventory in SAP, check order history, or book sales calls. It is a decorative toy.
• The Automated Proposal Writer. A sales team buys an AI writing tool that produces 20-page proposals in ninety seconds. The text sounds smart, but it makes up non-compliant prices and promises impossible delivery dates.
• The Disconnected Vector Store. A firm spends $200,000 indexing files into an unmonitored vector store. Six months later, staff ignore it because semantic search fails on industry jargon.

Real business value comes from quiet data infrastructure: connecting PostgreSQL databases, eliminating manual CSV data entry, and routing urgent tickets to human staff via Twilio alerts in under sixty seconds.

The Four Golden Rules of Production Deployments.

Based on shipping machine learning systems across eight years and multiple technology cycles, these four architectural rules are non-negotiable:

Rule 1: Never Let a Model Execute an Unvalidated State Change.

A statistical model should never directly write to a database, charge a card, or send an official legal email. Models propose drafts. Deterministic code tests those drafts against company rules before changes happen. If validation checks fail, the database write is blocked.

Rule 2: If Regex Can Do It, Never Use a Giant Neural Model.

Developers often use giant neural networks for simple tasks. A basic regex solved those problems forty years ago. Using an LLM to parse phone numbers, verify emails, or extract zip codes is slow, costly, and fragile. Use the simplest tool available. Save deep models for messy human text.

Rule 3: Schema Enforcement Is Non-Negotiable.

Every automated pipeline must enforce strict data schemas. In Python, model outputs must validate against a Pydantic model. In TypeScript, validate against Zod schemas. If the model returns malformed data in an API payload, the parser rejects it. Then it runs an automated retry. Never pass raw model text to downstream databases.

Rule 4: Human Review Is an Asset, Not an Engineering Defeat.

Inexperienced teams treat human review as an engineering failure. But veteran operators know better. Human review is the primary anchor of system safety. When a workflow hits a messy edge case, the system routes the file to a human operator with clear context. The human fixes the issue quickly. Then the system records the result to update validation rules.

When a business combines automated intake filters with an experienced human review desk for unusual files, the company eliminates manual backlog while ensuring that no bad data ever reaches internal accounting software or customer accounts.

The Bottom Line.

The current artificial intelligence hype cycle will end like past technology gold rushes: firms that bought demo theater will write off millions in sunk costs, while firms that focused on operational basics will pocket solid margin gains.

You do not win by running the flashiest model or building the biggest slide deck. You win by building disciplined systems that do real work, protect your cash flow, and never break in production.

Begin with a 150-Point Diagnostic Audit ($999) at /contact/. In 5–7 business days, we review your software architecture, audit vendor contracts, and set up guardrails that stop costly mistakes across the 7 business zones. You receive an executive findings report and independent vendor diligence roadmap. If you proceed with a Fractional CAIO Retainer ($7,500/month, minimum 3-month commitment, strictly capped at 4–5 active clients nationwide), 100% of your $999 fee is credited toward your retainer.

When a growing enterprise partners with a fractional technology leader who has built and deployed machine learning systems through every market cycle, that company avoids expensive vendor traps and builds reliable workflows that protect operating profit year after year.

Build systems that last. Choose discipline over theater every single time.