By Chris Ciappa
Founder & Chief Coherence Architect
Samirac Partners
There’s never been a time like this.
Today, someone with no engineering background can:
spin up an AI agent
connect APIs
trigger actions
deploy something that looks like a working system
All in a weekend.
That’s not impressive.
That’s dangerous.
🔥 What’s actually happening
You’ve got a perfect storm of:
New capability → instant feedback loop
No-code / low-code tools let someone:
build something fast
see it “work”
feel capability they’ve never had before
That triggers:
👉 “I created something real”
That feeling is powerful as hell.
Psychology kicks in (this is the engine)
Now layer in:
validation (“this works!”)
recognition (“nice job!”)
visibility (“demo this to leadership”)
It becomes:
👉 identity + status + momentum
At that point, it’s no longer about correctness.
It’s about:
👉 “This is my thing. I built this.”
And once identity is attached,
critique feels like an attack — not feedback.
Why Narrative and Tribe Take Over
Narratives exist to reduce cognitive load under uncertainty.
Tribes exist to outsource epistemic effort to group consensus.
Once someone fuses narrative and identity to tribe (The Claude Tribe, SQL Tribe, Oracle Tribe, Grok Tribe, etc…), three things happen:
truth becomes secondary to belonging
consistency becomes more important than accuracy
contradiction becomes a moral violation
At that point, evidence isn’t processed on merit.
It’s processed on alignment.
That’s how people repeat things that are:
provably false
internally contradictory
openly harmful
…without noticing.
Executives see outcomes, not architecture
Leadership sees:
demo works
output looks good
speed is impressive
They do NOT see:
lack of control layer
no admissibility gating
no state enforcement
no failure containment
So they greenlight it.
👉 Because it appears to work and they do not understand what is missing.
And now something ungoverned is officially sanctioned to act on real systems.
The lock-in moment (this is where it becomes dangerous)
Once approved, the system is no longer questioned, now it becomes very dangerous.
Because now:
someone owns it
someone was praised for it
someone’s reputation is tied to it
So instead of asking:
👉 “Should this even be allowed to act?”
The organization shifts to:
👉 “How do we scale this?”
Promotion → propagation
Now the most dangerous step of all:
That person becomes:
“AI Lead”
“Automation Owner”
“Innovation Champion”
And now they:
👉 teach the pattern
Not intentionally wrong —
but confidently incomplete.
They propagate systems with no control over what is admissible at the execution boundary.
Propagation → drift explosion
Now multiply across org:
more agents
more workflows
more decisions delegated
zero execution control
You get:
👉 unbounded execution authority everywhere
Exactly what you said:
👉 agents accumulating drift
🧠 What’s really driving all of this
It’s not just tools.
It’s not just incentives.
It’s this:
👉 Creation without accountability feels like success
👉 Validation replaces verification
👉 Identity overrides correction
🎯 The missing question (no one is asking)
Before any system is allowed to act:
What governs what this system is allowed to do
when the context is wrong, incomplete, or shifting?
Right now, the answer is:
👉 nothing
Speed Is Not the Achievement
We’ve confused speed of creation with quality of system.
Tools today optimize for:
faster builds
fewer barriers
instant execution
What they don’t enforce:
architecture
control boundaries
decision constraints
runtime admissibility
So what gets built?
Not systems.
Assemblies.
Chains of prompts and actions that appear coherent—
until they aren’t.
The Illusion of Capability
An agent that:
responds intelligently
calls tools
completes tasks
feels like a system.
It isn’t.
It’s a reactive loop with execution privileges.
And once you give something the ability to:
trigger actions
make decisions
operate across systems
you’ve introduced liability.
Not theoretical liability.
Operational liability.
Where It Breaks
These systems fail in one specific place:
The moment of action.
Not because the model is “wrong”
Not because the UI is bad
But because:
👉 Nothing is enforcing what is allowed
in that moment, in that context
So you get:
actions taken in the wrong frame
decisions made with incomplete or misaligned state
cascading behavior from a single incorrect assumption
And when it happens?
👉 There’s no control layer to stop it
Real-World Examples
1. Zillow — Automated Home Buying Collapse
Zillow deployed an algorithmic home-buying system to rapidly purchase houses at scale.
It worked—until it didn’t.
The system:
overestimated home values
continued purchasing at scale
failed to correct fast enough
Result:
over $500 million in losses
complete shutdown of the program
Not a model problem.
A control problem.
2. Air Canada — AI Chatbot Gave False Policy
An AI chatbot told a customer they could receive a bereavement refund after booking a ticket.
That policy did not exist.
Result:
airline held responsible
forced to honor incorrect output
Why?
👉 The system was allowed to act as authority
without enforcing what it was allowed to say.
3. Knight Capital Group — $440 Million in 45 Minutes
A trading system executed faulty logic tied to an old flag.
Result:
$440 million lost in under an hour
firm effectively collapsed
Not a trading problem.
A control problem.
Anyone Can Build It. Few Can Control It.
We’ve lowered the barrier to creation
without raising the standard for control.
So now:
non-engineers are deploying systems
developers are skipping architecture
companies are shipping “AI features”
…without asking the only question that matters:
What is this system allowed to do—right now—
who decides that—and what’s the liability when it fails?
The Liability No One Is Talking About
When a system:
sends the wrong message
triggers the wrong workflow
makes the wrong recommendation
executes the wrong action
The blame doesn’t go to:
the model
the tool
the platform
It goes to:
👉 whoever gave it execution authority
This Isn’t a Tooling Problem
Better prompts won’t fix it.
Better UX won’t fix it.
More guardrails after the fact won’t fix it.
Because the issue isn’t output quality.
It’s:
👉 whether the system has the right to act at all
Architecture Is the Missing Layer
If a system can:
interpret
decide
act
Then something must exist before execution that determines:
Is this action admissible?
Is the current state valid?
Is identity and frame aligned?
If that layer doesn’t exist:
👉 You don’t have a system.
👉 You have a liability engine.
The Reality
We didn’t just democratize development.
👉 We democratized uncontrolled execution.
And most people building these systems:
👉 Have no idea what they’ve actually created.
The Only Question That Matters
The architecture is already defined.
Drift Stack™ Architecture
https://www.samirac.com/drift-architecture
The only question is:
👉 Does your system control what’s allowed at execution—
or does it just react and hope it gets it right?
Architecture Demos
https://www.samirac.com/daisy-demos
Share This Article
If you found this article valuable, share it.
Substack automatically gives every subscriber a personal referral link. When someone subscribes through your share link, it counts toward referral rewards.
Current rewards:
• 3 referrals → 1 month of paid access
• 5 referrals → 6 months of paid access
• 10 referrals → 12 months of paid access
You can share directly using the Share button on this article, or find your personal referral link here:
By Chris Ciappa
Founder & Chief Coherence Architect
Samirac Partners