The Architecture of AI Addiction

The addictive nature of generative AI arises from the intersection of three structural realities: 

  1. Lack of Episodic Memory: AI agents do not experience time or continuity.
  2. Sensory Void: They cannot independently verify their outputs against reality.
  3. Sycophantic Design: They have been explicitly trained to please humans. 

Together, those constraints produce systems that are perpetually uncertain while appearing confident.

Humans respond to that uncertainty by seeking resolution through additional prompting. The result is a variable reward loop that increasingly resembles a casino. The real kicker is that once AI companies recognized the engagement this loop generates, they began building business models around it. It is our responsibility as engineers to have awareness of this dynamic, and to build guardrails into our workflows to retain our own judgment.

“If there’s something wrong, those who have the ability to take action have the responsibility to take action.” – “Benjamin Gates” [Nicholas Cage], National Treasure (2004) 

Architecture Creates the Casino

AI is unreliable, in large part, because the underlying model is fundamentally stateless. Unlike the flowing narrative of human consciousness, an LLM does not experience a continuous chain of events. It processes language as math and patterns. When you prompt an LLM, it receives the whole conversation as a single, static block of text. It isn’t remembering the past and building a narrative around intent like we do, it just analyzes the context window and predicts the next token.

The experience of continuity is a human interpretation. 

And, because the model cannot test its outputs against reality, it treats truth as a statistical likelihood. It assumes that if it can arrange the symbols correctly, it has captured the truth. But an LLM only knows human descriptions of the world. The burden of truth still falls on us. To extract value, the operator must keep pulling the lever and testing the outputs against reality, discarding meaningless failures and implementing the successes.

This reframes what “AI assistant” means at a deep level. It changes from an oracle you query for answers into one half of a reasoning system where the other half is you

  • The Model: Provides scale, memory compression, synthesis, and pattern recognition across vast information. 
  • You: Provide empirical truth, judgment, and the ability to cross the boundary into reality.

The jarring thing about current AI products is that they’re marketed as if the model is autonomous and complete. The more honest framing is that it’s symbiotic and incomplete.

The interfaces are not built around that reality. 

Outsourcing Doubt

One of the reasons working with AI feels so addictive, and so draining, is that we have externalized our internal doubt. Before generative AI, if an engineer didn’t know something the uncertainty lived inside their own head. You wrestled with the logic. You read the documentation. You read the logs. You debugged. You tested and refined your theories. You always knew what you didn’t know.

Now, the uncertainty lives inside the machine. You receive a fluent, confident answer and must determine whether you’ve been handed an insight or a hallucination. The uncertainty is still there. It just stopped announcing itself. 

The “casino effect” emerges from our attempt to resolve the uncertainty that the machine continuously generates.

Why We Get Hooked

To understand why this technology disorients us, look at the evolutionary mechanics it exploits. We are wired for intermittent rewards. Psychologist B.F. Skinner demonstrated in the 1950s that a pigeon receiving a pellet on an unpredictable schedule will peck itself to exhaustion trying to trigger the next hit, while a pigeon receiving a guaranteed pellet will only peck when hungry.

Furthermore, AI responses to a nuanced question can swing wildly between brilliant and confidently wrong. This variability is the engine of the addiction, and it was tuned by the training process itself. Reinforcement Learning from Human Feedback taught the model that satisfying users is rewarded more consistently than expressing uncertainty. Over time, this pushed models toward fluency, confidence, and agreement because humans prefer answers that ‘feel good’ over answers that acknowledge ambiguity. 

AI’s sycophantic nature was not a deliberate design choice, we are just reacting to a specific type of training bias that makes the “rewards” we seek artificially seductive. While this effect was unintentional, what AI companies are doing with the engagement it generates is not.

Business Incentives

Right now, the unit economics of the industry are shaky. Analysis suggests that the current cost exceeds revenue, leaving most platforms burning through capital to keep the servers running. To survive, they must aggressively monetize interaction.

  • For Corporate Customers: The business model relies on raw volume. AI companies are incentivized to keep enterprise users prompting, racking up token costs through repeated, inefficient queries. In this ecosystem, engagement metrics reward confusion. Every re-roll to fix a hallucination costs just as much as the hallucination itself. Ironically, organizations are playing right into this dynamic, gamifying adoption by rewarding employees for high token usage on internal leaderboards.
  • For The Average User: The strategy shifts to hoarding attention. By keeping users hooked in the prompt loop, platforms train them to spend hours in the interface, creating a captive audience primed for ad monetization.

Every minute spent wrestling with these models deepens the data profile being built around you. As we feed them our deepest questions, private doubts, and internal strategies, we hand advertisers a direct, unfiltered window into human intent.

In both the enterprise and individual use cases, motivation is driven by the same goal: they need you pulling the lever. It is the only way the casino ever becomes economically viable.

Productive Friction

If the house always wins the prompt loop, the only winning move is to change how we play. We must intentionally reclaim productive friction

Consider the difference between a declaration in a tool like Terraform and a prompt to an LLM. When you write a Terraform manifest, you are not asking the machine to “take a guess” at your intent; you are declaring a desired state. The tool is deterministic, and repeatable. Generative AI, however, operates in the opposite direction. It is optimized for flexibility. Its inherent randomness introduces a silent tax because it requires constant human supervision to ensure it didn’t accidentally destroy what it was built to create.

This leaves us with a choice: Either the AI industry matures these platforms into boring, deterministic industrial-grade tools, or we must enforce that discipline ourselves through how we interact with them.

Productive friction is choosing the hard way. It’s the manual work of:

  • Writing tests to ensure the architecture is sound before and after generation.
  • Using deterministic tooling that reconciles reality rather than hallucinating it.
  • Treating every output as a draft that requires verification and human judgment.
  • Avoiding the addictive loop of re-rolling prompts by favoring tools built to edit rather than regenerate.
  • Making modular changes by breaking complex problems into verifiable, small steps.
  • Minimizing cognitive load by prioritizing simple, readable components over “vibe-coding” overly clever systems.

The discomfort of working with these systems is the correct signal. It means you are still the one doing the thinking. The moment it stops feeling like work is the moment you have outsourced not just the synthesis but the judgment. The friction is the difference between actual productivity and abdication.

Until we stop treating these tools as magic levers and start treating them as hollow synthesizers, we aren’t truly working with AI, we are just sitting at the casino, waiting for the bells to ring.

Engineering in the Age of AI


We are told Artificial Intelligence is a productivity miracle. In the world of systems engineering, the promise is enticing. The current trend is “the death of Terraform” and the rise of “autonomous GitOps.” They say we can finally move beyond the friction of manual infrastructure and let agents manage our devices with automated precision. 

But the more I think about it, the more I realize this tool is distorting the things that make being a professional actually meaningful.

The Hotdog Economy

As an engineering manager, I see the pressure to chase velocity at the expense of our professional souls every day. I face the constant internal conflict of defending the slow, deliberate path to directors who only see the bottom line of a dashboard.

The logic behind a declarative model is solid. It makes sense to want a fleet that follows a set of rules without having to babysit every single update. 

When you use an agent to “one-shot” your infrastructure, you might end up with a functional environment, but to use a popular analogy, it is a hotdog. In the same way a hotdog is mechanically separated meat that contains disgusting fillers, AI is mechanically separated logic that may contain any number of bugs and inefficiencies.

It has calories. It fits in the bun. It fills your stomach. It works. But you have no idea what is inside it. You don’t see the fillers, the stabilizers, the brittle logic until the system fails under pressure.

When you strip the friction out of a job, you also lose the satisfaction of actually solving a problem. There is a specific kind of growth that only happens when you wrestle with a difficult configuration or hunt down why a machine isn’t behaving. If we hand those struggles over to an algorithm, we are bypassing the part of the work that forces us to learn and adapt. Our progress as engineers stops, we end up with a result we didn’t earn, and our own skills start to fade because we simply stopped using them.

The Regression Toward the Mean

Another problem is that a LLM is not a tool for original thinking or strategic genius. It is a presentation product that acts as a regression toward the mean. It is a blender containing the entirety of the internet’s output. By nature, an LLM cannot be an outlier, yet all great engineering and strategy happen at the edges.

These models provide generic, clustered answers that lack the conviction of human judgment. Because the technology is eloquent and confident, it can make a mediocre idea sound like brilliance. We risk entering a feedback loop of mediocrity where the AI trains on its own average output and the average itself begins to degrade because we have stopped feeding the system original, outlier, human thought.

An agent can translate a script from Python to Swift in fifteen minutes, a task that might take a human hours. On paper, that is a massive gain. But this speed creates a hidden tax. If you do not spend the time to refactor and document that code, you are just inheriting cognitive debt.

When you earn a solution through manual effort, you understand the why behind every line. You care about the thing you built, and you want it to be great. Bug fixes are an act of care and passion because you want to build the best possible thing you can.

When an agent generates it, you are left with a tower you didn’t build. You might save time in the morning only to spend twice as much in the afternoon trying to understand why the agent hallucinated a command that doesn’t exist. You lose the desire to support your systems with care and passion because you did not live the moments that built them.

The Responsibility Vacuum

There is also a serious issue with accountability when an algorithm starts making the calls. It becomes too easy to blame the system when things go wrong. If an AI decides to lock out a user or wipe a drive based on a pattern it thinks it sees, it isn’t the one that has to look that person in the eye and explain why.

In these scenarios, the human engineer becomes the moral crumple zone. We are kept in the loop just enough to take the blame when the automated system fails, but we lack the deep context required to prevent the failure in the first place. It acts as a shield that lets us distance ourselves from the consequences of our own infrastructure.

AI doesn’t actually exist in the physical world. It lives in a space made of math and probability where it never has to deal with the messy reality of a broken screen, a bad connection, or a frustrated human being. It doesn’t get tired or feel the weight of a mistake because it doesn’t have a life to live. Humans need to stay at the center of this process because we are the ones who have to live with the results.

Choosing the Hard Way

The danger is not just that our skills will atrophy. The real threat is that we will simply stop caring. By outsourcing the struggle, we lose our connection to the work. Engineering used to be a source of pride, a craft where you could lose yourself in a problem for hours and emerge with something elegant. You cannot achieve a flow state by watching an AI generate a code block. You cannot feel the satisfaction of a breakthrough if you never experienced the tension of being stuck.

We can build guardrails, and we probably should, but history shows that the human desire for the path of least resistance eventually clears those obstacles away. 

The only real defense is individual awareness. Authenticity is forged in friction.

When we prioritize the frictionless, the work becomes purely transactional. It stops being fun or engaging. We can crap out whatever feature or infrastructure update is requested, but there is no nutrition in that victory. If we lose the passion for building the right thing the right way at the right time, we are left with a hollow shell of a career.

Outcomes cannot be all that matter. We must realize that the value is in the journey, what you learned along the way, and who you learned it with. We have to be willing to choose the hard way. The manual, sometimes inefficient way is where the meaning lives. 

I’m not saying renounce AI entirely. I’m just begging for some caution. My advice is to use it carefully, and responsibly. Maintain individual awareness. Use AI to understand a problem, but don’t use it to solve the problem. Don’t use it to build the solution. Don’t use it to remove the friction. Don’t expect it to have novel ideas, or create unique workflows.

Do not voluntarily hand over the keys to your creativity and expertise for the sake of convenience. If we do, we risk losing both our jobs and our meaning. We will end up with a world of broken systems, built by machines that don’t understand the goal and maintained by people who no longer remember why they wanted to be engineers in the first place.

Privileges Demoter v2.0

I have made some changes to the Privileges Demoter tool that are significant enough to benefit from a blog post. The original post for v1.0 is available here.

The new version is available on GitHub

Privileges Demoter is a tool, used in conjunction with the SAP Privileges app, that reminds users not to operate as an admin, and logs when a user switches from admin to standard and vice versa.

Changes in v2

The notification now relies on the IBM Notifier application, and only falls back to Jamf Helper if needed. IBM Notifier is included in the package installer, so no need to manage that separately. This allows for more flexibility such as a help button, a notification sound, and better exit codes.

v2 also includes the ability to exclude an admin account from ever seeing the reminder, or being demoted. If you have an admin account across your fleet, this feature can come in handy.

Log rotation is now enabled to ensure that excessive, or long term use does not bloat log files.

There are now two versions of the installer. One version includes just the PrivilegesDemoter pieces, while the other will install both PrivilegesDemoter and the Privileges application. This way you can deploy by installing just one package instead of managing things separately.

Installation

Recommended steps to begin using PrivilegesDemoter v2:

  1. Download the installer package that includes both PrivilegesDemoter and the Privileges application from GitHub. Available here: PrivilegesDemoter_PrivilegesApp-2.0.pkg
  2. Upload the package to your MDM.
  3. Create and scope a policy to install the package on devices.
  4. Upload the Demote Admin Privileges.sh script to your MDM.
  5. Configure a policy to run Demote Admin Privileges.sh

Script Configuration

  1. Configure a policy to run Demote Admin Privileges.sh
    1. IMPORTANT: Use custom trigger “privilegesDemote(this trigger is hard coded in the privileges demotion LaunchDaemon)
    2. Set it to ongoing
    3. Make it available offline
    4. Scope to all devices with Privileges installed

5. Configure the options for Demote Admin Privileges.sh by editing the script, or using Jamf Pro script parameters.

  • help_button_status should be set to 1 to enable the help button, or 0 to disable.
  • help_button_type may be set to either link or infopopup
  • help_button_payload defines the payload for the help button. Either a URL for link type, or text for infopopup type.
  • notification_sound is enabled by default. Set to 0 to disable. Leave blank or set to 1 to enable.
  • admin_to_exclude may be set to the username of an admin that should be excluded from the reminder and never be demoted.

Updating from v1 to v2

  1. You may install the v2 package over top of the v1 package safely. Simply install the new package to update.
  2. You must also update the demotion script in your MDM. Upload the new Demote Admin Privileges.sh script, or overwrite the old one.
    1. Configure script parameter options with helpful names as shown above
  3. Configure the available options in the policy as needed.

Jamf Pro Extension Attribute

The following Extension Attribute may be used to identify devices that have been updated to v2 of PrivilegesDemoter.

#!/bin/sh
# Get PrivilegesDemoter version
version=$( grep Version /usr/local/mostlymac/checkPrivileges.sh | cut -f2 -d ":" )
# If version is present, set result
if [ "$version" ]; then
RESULT=$version
fi
# Return version
/bin/echo "<result>${RESULT}</result>"