DEV Community: Khali Sollis

Emotional Rollbacks: Why We Revert to Old Versions of Ourselves Around Certain People

Khali Sollis — Fri, 28 Aug 2026 12:00:00 +0000

How specific relationships reactivate archived behavioral patterns, why personal growth collapses in familiar emotional environments, and what happens when old dynamics override newer versions of yourself

One of the strangest parts of growth is realizing that progress is not always permanent.

You can spend months:

building boundaries
strengthening self-respect
regulating emotions
developing clarity
becoming more grounded

And then one interaction with the wrong person suddenly pulls an older version of you back online.

The version that:

overexplains
seeks validation
tolerates disrespect
abandons boundaries
becomes emotionally reactive

It feels immediate.

Automatic.

Almost involuntary.

That’s when I realized:

Some relationships function like emotional rollback systems.

The Bug: Emotional Rollbacks

In software systems, a rollback restores an application to a previous state after instability or incompatibility.

Human relationships can trigger similar regressions.

Certain people reactivate:

old coping mechanisms
outdated identities
emotional survival patterns
previous nervous system conditioning

You are no longer operating from your current architecture.

You are temporarily running archived behavioral code.

Why Growth Feels Fragile Around Certain People

Because personal growth is highly environment-dependent.

Growth developed in stable environments can destabilize inside familiar emotional systems.

Especially when those systems originally shaped your survival behaviors.

The nervous system remembers:

who you had to become
what kept you emotionally safe
what earned approval
what prevented rejection

And around certain people, those old patterns reactivate automatically.

Familiar Dynamics Override Conscious Intentions

This realization was uncomfortable:

Some people did not merely remind me of the past.

They reactivated it neurologically.

Suddenly:

my boundaries weakened
my clarity blurred
my emotional regulation decreased
my self-trust destabilized

Not because growth disappeared.

Because older emotional programming temporarily regained control.

The Identity Regression Loop

Certain relationships contain archived versions of you.

When re-entering those dynamics, the nervous system often retrieves:

the self associated with survival inside that relationship

Not:

the self you consciously became afterward

This is why emotionally charged environments can trigger disproportionate reactions.

The system is not responding only to the present moment.

It is responding to historical conditioning.

The Difference Between Love and Familiar Programming

This distinction changed everything:

Not every strong pull toward someone is emotional alignment.

Sometimes it is emotional familiarity.

And familiarity can feel intensely magnetic even when the dynamic is unhealthy.

The nervous system often interprets:

predictable emotional conditioning

as:

personal chemistry

Those are not always the same thing.

Old Roles Reappear Fast

Certain people unconsciously expect older versions of you to remain accessible.

The moment interaction resumes, the system attempts restoring previous roles:

the fixer
the caretaker
the appeaser
the overexplainer
the emotionally available version

If boundaries are not fully stabilized, the rollback happens quietly.

You start performing old identities without realizing it.

Emotional Muscle Memory

The body remembers relational patterns.

Especially repetitive ones.

Which means:

tone of voice
specific phrases
conflict dynamics
approval withdrawal
emotional inconsistency

can instantly reactivate stored nervous system responses.

Sometimes before conscious awareness even catches up.

Why Some People Feel “Hard to Resist”

Often because they are connected to unresolved emotional conditioning.

Not necessarily because they are uniquely compatible.

The attachment may actually be tied to:

validation wounds
approval patterns
abandonment fears
identity dependence
nervous system familiarity

The pull feels emotional.

But underneath it is often procedural.

The Cost of Emotional Rollbacks

The dangerous part is not temporary emotional discomfort.

It is identity destabilization.

Repeated rollbacks slowly erode:

self-trust
behavioral consistency
emotional stability
internal authority

You begin doubting the newer version of yourself because older patterns still activate under pressure.

The Realization

Eventually, I stopped asking:

Why do I become different around them?

And started asking:

What survival version of myself does this relationship reactivate?

That question exposed the actual architecture underneath the dynamic.

The Fix: Identity Stabilization

Healing required more than avoiding people.

It required stabilizing the newer version of myself strongly enough that older environments could no longer override it automatically.

Recognize the Rollback Early

The first signs were subtle:

overexplaining
anxiety spikes
compulsive responsiveness
self-abandonment
emotional hypervigilance

These behaviors became rollback indicators.

Not personality traits.

Separate Familiarity From Alignment

Old model:

This feels intense, therefore it must matter deeply.

Updated model:

Intensity can also indicate old nervous system programming.

That distinction prevented many regressions.

Protect the Updated Identity

Growth requires reinforcement.

The newer version of yourself must become:

practiced
repeated
defended
normalized

Otherwise stressful relationships will continuously reload archived behavior.

Stop Performing Old Roles for Familiar People

This part was critical.

Some relationships survive only if the old version of you remains accessible.

When the updated version appears:

boundaries
self-respect
emotional clarity
reduced availability

the dynamic often destabilizes.

That destabilization is information.

What Changed

After identifying emotional rollback patterns:

interactions became easier to evaluate objectively
emotional regressions shortened significantly
self-awareness increased
internal consistency improved

And most importantly:

I stopped mistaking regression for authenticity.

Reframing Growth

Old model:

If I revert around them, maybe this is who I really am.

Updated model:

Certain environments reactivate archived survival behaviors automatically.

That distinction restored self-trust.

Takeaway

Some people do not simply enter your life.

They preserve older versions of you emotionally, neurologically, and behaviorally.

And without awareness, those dynamics can quietly override years of growth.

Healing is not only about changing yourself in isolation.

It is about maintaining your updated identity inside environments that once trained you to abandon it.

Because growth becomes real when the old system no longer has permission to restore previous versions of you automatically.

Status
Emotional rollback detection: active
Archived survival behaviors: identified
Identity stabilization protocols: strengthening

Training the Return: What 111 Randomized Trials Reveal About Attention

Khali Sollis — Tue, 25 Aug 2026 14:00:00 +0000

You're twenty minutes into a function that finally makes sense. Not "I can explain it" sense — the deeper kind, where the whole call stack is loaded into working memory at once and you can feel the shape of the bug before you've located it. A message notification slides in. You answer it, because it takes ten seconds and you're a reasonable person. You come back to the editor.

The cursor is exactly where you left it. The code hasn't changed. But the thing that made it intelligible thirty seconds ago is gone, and you can feel yourself re-reading the same six lines without them landing. The interruption itself took ten seconds. Reconstructing the mental state it displaced takes considerably longer.

This is usually filed under "distraction" and treated as a discipline problem: turn off notifications, use a timer, try harder. But there's a separate, more interesting question buried in that experience, and it happens to be one that meditation researchers have spent the last decade quantifying: what happens when a cognitive system repeatedly practices noticing that attention has wandered, and returning it to a chosen target?

We Might Be Asking the Wrong Question About Focus

The common mental model of "good focus" is something like an uninterrupted beam: a mind that, once aimed, doesn't drift. Under that model, distraction is pure failure, and the goal of any attention-training practice would be to reduce how often the mind wanders in the first place.

Meditation research suggests a different, more testable idea worth taking seriously: mind-wandering may be something to expect rather than a defect to eliminate. What might actually be trainable isn't the absence of wandering. It's the loop around it: how reliably the system detects that it has drifted, disengages from the drift, and gets back to the intended target.

That reframe matters because it changes what a "good" trial looks like. If the goal is zero wandering, most people fail constantly. If the goal is a fast, low-friction return, then every wandering episode becomes a rep — and reps are something a nervous system can plausibly get better at, the way a muscle gets stronger through repeated, effortful contraction rather than through never being asked to contract.

To be clear about what kind of claim this is: no dataset in the meditation literature directly measures "return efficiency" as a stopwatch-timed variable and tracks it across training. This is an interpretive frame suggested by the shape of what these studies do measure — not a demonstrated mechanism. Keep that distinction in mind, because the rest of the article leans on it.

The Loop, as a Framework

Stripped down, the practice that most attention-focused meditation research examines looks like a simple repeating structure:

Choose a target → attention wanders → notice the wandering → disengage from it → return to the target → repeat.

Borrowing lightly from systems language: this isn't a bug being patched. It's closer to a control loop — a process that continuously checks whether the current state has diverged from an intended state, and if so, executes a correction. The "bug" framing implies something is broken. The loop framing implies something is running as designed, and the skill lives in how efficiently the correction step executes.

This is a useful lens, not a proven architecture. Neuroscience hasn't established that the brain literally implements this as a discrete, three-step algorithm. What it has established — carefully, and with real caveats — is what happens behaviorally and functionally when people practice something structurally similar to this loop, over and over, for weeks at a time. That's where the evidence gets specific.

What 111 Randomized Trials Actually Found

The most comprehensive test of this is a 2024 meta-analysis by Nur Hani Zainal and Michelle Newman, published in Health Psychology Review, which pooled 111 randomized controlled trials — 9,538 participants across 22 countries — comparing mindfulness-based interventions (MBIs) against no-treatment, waitlist, or active control conditions [1]. Unlike earlier reviews that mixed randomized and non-randomized designs, this one restricted itself to RCTs specifically to control for the confound of who chooses to meditate in the first place.

The analysis tested effects across fifteen distinct cognitive subdomains rather than treating "cognition" as one variable, which is what makes it useful here. The results split cleanly into two piles.

Domains that showed a positive effect: global cognition, executive attention, working memory accuracy, inhibition accuracy, cognitive-flexibility (shifting) accuracy, sustained attention accuracy, a measure of moment-to-moment consistency in sustained attention (intra-individual variability), and subjective cognitive functioning — i.e., how capable people felt their attention was [1]. Effect sizes ranged from small to large, with the strongest effects on global cognition — a composite score aggregating performance across the individual task domains measured, not a proxy for general intelligence or IQ.

Those improved domains — executive attention, working memory accuracy, inhibition, shifting, sustained attention — are what the trials actually measured: task-based accuracy scores on standardized cognitive tests. That's consistent with the return-loop interpretation developed above — goal-maintenance and course-correction are plausible ingredients in tasks that reward accurate inhibition and shifting — but it's worth being precise about the direction of the inference. The meta-analysis did not measure "noticing that attention has wandered" or "returning to a target" directly. It measured performance on lab cognitive tasks. The loop is a frame for interpreting why those particular tasks might improve, not a variable anyone tracked.

Domains that did not show a reliable effect: orienting, processing speed, verbal fluency, episodic memory, cognitive error rates, and the latency — as opposed to accuracy — components of working memory, inhibition, and shifting [1]. In plain terms: people didn't reliably get faster on these tasks. Accuracy moved on a specific cluster of goal-maintenance-flavored measures; raw processing speed and unrelated memory systems like recalling past events did not.

A few moderators are worth flagging, because they cut against a simple "just meditate more" reading. Effect sizes did not depend on how many sessions people did, how long the program ran, or completion rate [1]. They did depend on delivery format: instructor-led, face-to-face training outperformed self-guided formats, and studies of lower methodological quality tended to report larger effects than higher-quality ones [1] — a pattern meta-scientists treat as a caution flag, not a footnote. Effects were also somewhat weaker in older adults and in women, an asymmetry the authors note but don't fully explain.

None of this says mindfulness training makes people smarter, faster, or more broadly capable. It says something narrower and, honestly, more interesting: across a large, randomized evidence base, a specific cluster of goal-maintenance and course-correction functions improved, while several unrelated cognitive systems didn't move at all.

Training Isn't Transfer

If you've spent time optimizing anything — a build pipeline, a training loop, a query — the next idea will feel familiar: improving performance on the exact thing you practiced doesn't guarantee improvement on adjacent things, even things that feel related.

That's essentially what the null results above describe. Practicing "notice the mind has wandered, return to the breath" moved accuracy on tasks involving goal maintenance and course correction. It did not move verbal fluency or episodic memory, which draw on different systems and weren't obviously exercised by the practice. It's worth thinking of this the way you'd think about training specificity anywhere else: getting better at one exercise doesn't automatically transfer to a different one that merely looks related. That's an analogy, not a citation to a separate body of transfer-of-training research — but the pattern in this particular dataset fits it: the gains cluster tightly around the kind of goal-tracking process the practice actually exercises, and stop right at the edge of that cluster.

For anyone who's watched a model overfit to its training distribution, or watched a team get extremely good at one CI pipeline and then struggle the moment the stack changes, this shouldn't be surprising. But it's worth stating explicitly, because the popular version of meditation coverage almost never states it. And that gap — between what a specific, bounded finding supports and what a headline claims — is worth looking at directly.

Where the Abstraction Leaks

Here's a useful historical marker. In 2014, a landmark JAMA Internal Medicine review by Madhav Goyal and colleagues pooled 47 RCTs (3,515 participants) and found moderate evidence that mindfulness programs produced small-to-moderate reductions in anxiety and depression — but found the evidence for effects on attention specifically insufficient or low-quality at the time, alongside similarly weak evidence for sleep, substance use, and eating behavior [2]. Ten years and a much larger, attention-specific evidence base later, Zainal and Newman's 111-trial analysis found consistent, moderate effects on several attention-adjacent cognitive functions [1].

That's not necessarily a contradiction, and it isn't safe to read it as "the earlier review simply missed an effect that was there all along." The two analyses asked somewhat different questions, used different inclusion criteria and outcome measures, and drew on evidence bases separated by a decade. What the contrast reliably shows is how much the empirical landscape changed: by 2024, researchers could aggregate a far larger body of randomized evidence focused specifically on cognitive outcomes than existed in 2013. Whether that's the whole explanation for the different conclusions, or whether differences in methodology also played a role, isn't something these two papers alone can settle. It's also worth noting, per a 2022 review of 44 separate meta-analyses covering 336 RCTs, that effect sizes across the mindfulness literature broadly depend heavily on what the intervention is compared against — effects tend to look larger against passive controls such as waitlists than against credible active comparators (like structured exercise) [3]. That's a caveat for the whole field, not just cognition research, and it's a reason to hold effect sizes loosely rather than as fixed constants.

Here's where the leak happens, concretely. A careful sentence looks like: "Across 111 randomized trials, mindfulness-based interventions produced small-to-moderate improvements in executive attention, working memory accuracy, and sustained attention, without corresponding improvements in processing speed or episodic memory." That sentence is boring, bounded, and defensible.

The version that circulates instead is usually something closer to: "Science proves meditation makes you sharper." Every qualifier — which domains, what kind of intervention, delivered how, compared to what — evaporates in the retelling. The retracted-and-corrected literature on this topic offers a sharper cautionary example: a 2023 anatomical meta-analysis claiming mindfulness produces structural brain changes was retracted in 2025 after it emerged that four null-finding studies, representing 40% of the pooled participants, had been excluded from the analysis. The retraction notice states that this exclusion meant the analysis "was not designed to test the stated hypothesis" it claimed to address, and therefore could not support the paper's conclusions [4]. Forty percent of the participant pool disappearing from the analysis is, on its own, the whole story here. That paper is not cited elsewhere in this piece as evidence of anything, except as an illustration of how easily a headline-friendly brain claim can outrun what the underlying data supports.

What the Evidence Actually Permits Us to Say

Put together, a fair reading of this literature supports something like this: across randomized comparisons, mindfulness-based interventions were associated with improvements in accuracy on a specific cluster of goal-maintenance and course-correction-flavored cognitive tasks — executive attention, working memory, inhibition, shifting, sustained attention — without a matching association for processing speed, verbal or episodic memory, or anything resembling general intelligence. Reported effects appear to depend more on delivery quality than on dose, and — since lower-quality studies in this literature tended to report larger effects — the honest posture toward the size of any individual number here is a cautious one.

That's a smaller claim than "meditation makes you focused." It's also a more useful one, because it suggests a different way to think about the target of training: perhaps not the absence of distraction, but the fidelity of the return.

Whether that generalizes to a debugging session, a code review, or a deep-work block is an open, unanswered question — the trials measured laboratory cognitive tasks, not IDE behavior, and nothing here licenses a claim about programming performance specifically. What the data does support is a narrower shift in how to think about attention itself: not as a beam that either holds or breaks, but as a system that drifts by default — one where a cluster of accuracy-based, goal-maintenance-flavored functions responded to training, in a pattern consistent with, though not direct proof of, the idea that how well it comes back matters as much as whether it wanders at all.

It's also worth saying plainly, since the picture shouldn't be painted as uniformly benign: a 2020 systematic review of adverse events across meditation research found that among the subset of studies that specifically investigated harms, a majority reported at least one adverse event, most commonly anxiety, depressive symptoms, or unusual cognitive experiences [5]. That's not a reason for alarm about a training loop metaphor — it's a reminder that "attention training" in this literature refers to a real, sometimes intense psychological practice, not an abstraction, and the evidence should be read with that in mind.

References

[1] Zainal, N. H., & Newman, M. G. (2024). Mindfulness enhances cognitive functioning: A meta-analysis of 111 randomized controlled trials. Health Psychology Review, 18(2), 369–395. https://doi.org/10.1080/17437199.2023.2248222

[2] Goyal, M., Singh, S., Sibinga, E. M. S., Gould, N. F., Rowland-Seymour, A., Sharma, R., Berger, Z., Sleicher, D., Maron, D. D., Shihab, H. M., Ranasinghe, P. D., Linn, S., Saha, S., Bass, E. B., & Haythornthwaite, J. A. (2014). Meditation programs for psychological stress and well-being: A systematic review and meta-analysis. JAMA Internal Medicine, 174(3), 357–368. https://doi.org/10.1001/jamainternmed.2013.13018

[3] Goldberg, S. B., Riordan, K. M., Sun, S., & Davidson, R. J. (2022). The empirical status of mindfulness-based interventions: A systematic review of 44 meta-analyses of randomized controlled trials. Perspectives on Psychological Science, 17(1), 108–130. https://doi.org/10.1177/1745691620968771

[4] Siew, S., & Yu, J. (2025). Retraction note: Mindfulness-based randomized controlled trials led to brain structural changes: An anatomical likelihood meta-analysis. Scientific Reports, 15, 25545. https://doi.org/10.1038/s41598-025-11069-9

[5] Farias, M., Maraldi, E., Wallenkampf, K. C., & Lucchetti, G. (2020). Adverse events in meditation practices and meditation-based therapies: A systematic review. Acta Psychiatrica Scandinavica, 142(5), 374–393. https://doi.org/10.1111/acps.13225

Emotional Memory Leaks: Why Old Relationships Keep Reappearing During Vulnerable Moments

Khali Sollis — Fri, 21 Aug 2026 12:00:00 +0000

How unresolved emotional data resurfaces under stress, why loneliness reactivates archived attachments, and what happens when the mind mistakes familiarity for healing

I noticed something strange during difficult periods of my life.

The moment I became:

emotionally exhausted
lonely
overwhelmed
uncertain
disconnected from myself

old relationships started resurfacing in my mind.

Not randomly.

Predictably.

People I had not thought about in months suddenly reappeared internally:

memories
fantasies
conversations
nostalgia
imagined reconnections

At first, I thought it meant I still loved them.

Eventually, I realized something else was happening entirely.

The system was leaking emotional memory under stress.

The Bug: Emotional Memory Leaks

In software systems, memory leaks occur when unused or outdated data continues occupying system resources instead of being properly released.

Under pressure, inefficient systems begin resurfacing residual processes.

Human attachment behaves similarly.

Old emotional connections often reactivate during:

stress
loneliness
burnout
identity instability
emotional deprivation

Not necessarily because the relationship is still aligned.

Because the nervous system associates familiar attachment with temporary emotional relief.

Why Vulnerability Reactivates Old Attachments

The mind seeks familiarity during instability.

Especially emotional familiarity.

When life feels uncertain, the nervous system instinctively searches archived emotional memory for:

safety
validation
certainty
comfort
identity reinforcement

Even if the original relationship was unhealthy.

Familiarity can feel emotionally safer than uncertainty.

Nostalgia as Emotional Compression

This realization changed everything:

The mind does not store relationships objectively.

It compresses them emotionally.

During vulnerable moments, the brain often retrieves:

comforting fragments
emotionally intense highlights
symbolic moments of closeness

while minimizing:

inconsistency
incompatibility
emotional damage
unresolved pain

The archived memory becomes emotionally edited.

Why the Past Suddenly Looks Better During Hard Times

Because vulnerability distorts emotional evaluation.

The system starts comparing:

current discomfort

against:

selective emotional memory

Not against full reality.

The brain is not necessarily searching for truth.

It is searching for relief.

Emotional Regression Loops

Under stress, people often regress toward:

familiar emotional patterns
old attachment dynamics
previous coping mechanisms

Which means emotional vulnerability can reactivate dormant attachment systems.

The loop often looks like this:

stress
→ emotional depletion
→ nostalgic memory activation
→ fantasy reconstruction
→ emotional attachment resurgence

The attachment feels meaningful again.

But frequently, the timing—not the compatibility—is driving the intensity.

The Difference Between Missing Someone and Missing Regulation

This distinction became critical.

Sometimes I did not actually miss the person.

I missed:

emotional certainty
familiarity
distraction from pain
nervous system regulation
the temporary relief the attachment once provided

The mind confused:

emotional soothing

with:

relationship alignment

Those are not always the same thing.

Vulnerability Lowers Emotional Standards

This was difficult to admit.

During emotionally strong periods, certain relationships looked obviously misaligned.

During vulnerable periods, the same relationships suddenly appeared:

meaningful
rare
emotionally magnetic
impossible to replace

Not because the facts changed.

Because emotional depletion altered perception.

The Nervous System and Familiar Pain

The nervous system prefers predictable pain over unfamiliar uncertainty.

Which explains why people sometimes revisit:

emotionally unavailable partners
inconsistent relationships
destabilizing attachments

during difficult periods.

The system chooses:

known emotional territory

over:

unfamiliar emotional rebuilding

Even when the old territory caused suffering.

Why Healing Is Not Linear

One important realization:

Thinking about someone again does not automatically mean healing failed.

Sometimes vulnerability simply reactivates archived emotional pathways.

The appearance of memory is not necessarily evidence of destiny.

Nor proof that the relationship should resume.

Often, it is evidence that the nervous system is searching for familiar regulation during instability.

The Realization

Eventually, I stopped asking:

Why am I thinking about them again?

And started asking:

What emotional condition inside me triggered this memory resurgence?

That question changed the entire interpretation.

The Fix: Emotional Leak Management

Detachment became less about suppressing memories and more about understanding activation conditions.

Not every resurfacing emotion required action.

Some required observation.

Identify the Trigger State

I began noticing patterns.

Old attachments resurfaced most during:

exhaustion
loneliness
rejection
uncertainty
emotional dysregulation

The memory was often attached to vulnerability, not current compatibility.

Stop Romanticizing Emotional Regression

Old model:

If they came back into my mind, it must mean something profound.

Updated model:

Stress can reactivate familiar emotional pathways automatically.

That distinction prevented many unnecessary spirals.

Separate Emotional Memory From Present Reality

The memory might feel emotionally vivid.

That does not mean:

the relationship improved
the incompatibilities disappeared
the attachment became healthy

Memory intensity is not evidence of alignment.

Strengthen Present-Day Stability

The strongest protection against emotional memory leaks was rebuilding:

routine
identity
nervous system regulation
purpose
self-trust

Stable systems revisit old dependencies less frequently.

What Changed

After understanding emotional memory leaks:

nostalgia lost some of its authority
emotional relapses became easier to interpret
vulnerability stopped automatically triggering reconnection fantasies
self-awareness increased significantly

And most importantly:

I stopped mistaking emotional resurfacing for emotional truth.

Reframing Nostalgia

Old model:

If I miss them during hard moments, they must still belong in my life.

Updated model:

Emotional vulnerability often reactivates familiar attachment memories regardless of compatibility.

That distinction restored clarity.

Takeaway

Old relationships often resurface during vulnerable moments not because they are necessarily right for us, but because the nervous system associates them with familiarity, regulation, and temporary emotional relief.

The mind leaks archived attachment data under stress.

Especially when identity, stability, or emotional grounding weaken.

Healing is not the absence of memories.

It is learning not to confuse emotional resurfacing with emotional direction.

Because not every memory is a message.

Sometimes it is simply residual emotional code reappearing under pressure.

Status
Emotional memory leak detection: active
Nostalgia distortion awareness: increasing
Internal stability systems: strengthening

Phantom Notifications: Why Your Nervous System Still Waits for People Who Left

Khali Sollis — Fri, 14 Aug 2026 12:00:00 +0000

How emotional conditioning trains the body to anticipate unavailable people, why silence can feel physically destabilizing, and what happens when attachment rewires your internal alert system

Long after certain relationships ended, something strange kept happening.

I would feel my nervous system react before anything even occurred.

A phantom impulse.

A sudden anticipation.

An invisible expectation that:

they would text
they would appear
they would return
they would explain
they would finally become consistent

Sometimes my phone hadn’t even vibrated.

But internally, the system had already reacted.

That’s when I realized:

Attachment had trained my nervous system into anticipatory surveillance.

The Bug: Phantom Notifications

In technology systems, phantom notifications occur when the user perceives alerts that never actually happened.

The expectation becomes so conditioned that the brain generates the sensation automatically.

Emotionally, the same thing happens after unstable attachments.

The nervous system becomes trained to anticipate:

contact
validation
reassurance
emotional resolution

Even after the person is gone.

The Nervous System Learns People

One difficult truth:

The body memorizes emotional patterns faster than the conscious mind does.

Repeated attachment cycles create conditioned responses:

message received
→ dopamine spike
silence
→ anxiety activation
attention withdrawal
→ emotional destabilization

Over time, the nervous system stops responding to reality.

It starts responding to expectation.

Why Silence Feels So Loud

When emotional conditioning becomes strong enough, absence itself becomes stimulating.

Not peaceful.

Activating.

The mind starts monitoring:

unread messages
online activity
timing patterns
subtle changes in tone
possible signs of return

The attachment converts attention into vigilance.

Intermittent Reinforcement Creates Obsession

Consistent people calm the nervous system.

Inconsistent people often hijack it.

Because unpredictability intensifies emotional conditioning.

The cycle looks like this:

distance
→ anxiety
unexpected attention
→ relief
relief
→ stronger attachment

The nervous system becomes addicted to emotional resolution.

Not stability.

Emotional Gambling Systems

This realization was uncomfortable:

Some attachments operate like variable reward systems.

You never know:

when attention will arrive
when affection will return
when emotional warmth will appear again

That unpredictability creates compulsive monitoring behavior.

The brain starts chasing:

possibility

instead of evaluating:

consistency
Phantom Hope

Eventually, the nervous system begins generating anticipatory responses automatically.

You:

check the phone unnecessarily
reread old conversations
imagine future contact
mentally rehearse reconciliation scenarios

Not because anything happened.

Because the body became conditioned to expect emotional stimulation from that source.

The Attention Hijack

The most damaging part wasn’t the relationship itself.

It was the continuous occupation of attention.

Part of my mind remained permanently allocated toward:

waiting
monitoring
anticipating
interpreting silence

Even during:

work
rest
conversations
ordinary moments

The attachment had become background processing.

When Waiting Becomes Identity

At some point, I realized I had unconsciously organized parts of my emotional life around anticipation.

Waiting became normalized.

Waiting for:

clarity
consistency
reassurance
effort
emotional reciprocation

The nervous system adapted to uncertainty so completely that peace began feeling unfamiliar.

The Difference Between Connection and Conditioning

This distinction changed everything:

Not every strong emotional reaction is evidence of deep compatibility.

Sometimes it is evidence of strong conditioning.

intensity
≠
alignment
obsession
≠
love
anticipation
≠
security

The nervous system can become highly activated around emotionally inconsistent people.

That activation is not always meaningful.

Sometimes it is simply conditioned survival behavior.

The Realization

Eventually, I stopped asking:

Why can’t I stop thinking about them?

And started asking:

Why has my nervous system mistaken unpredictability for emotional importance?

That question exposed the architecture underneath the attachment.

The Fix: Nervous System Deconditioning

Detachment became less about suppressing emotion and more about retraining internal responses.

Not instantly.

Repeatedly.

Stop Rewarding Monitoring Behavior

Every time I:

checked their profile
reread messages
searched for signs
mentally revisited the connection

the nervous system interpreted it as:

this attachment still matters for survival

Reducing reinforcement weakened the loop.

Normalize Calm

This part was surprisingly difficult.

Chaos had become emotionally familiar.

Peace initially felt:

boring
emotionally flat
suspiciously quiet

The nervous system had adapted to volatility.

Stability required recalibration.

Interrupt Automatic Anticipation

Whenever phantom expectation appeared:

Maybe they’ll...

I stopped feeding the narrative.

Not with suppression.

With observation.

This is conditioned anticipation.
Not evidence.

That distinction reduced emotional spirals significantly.

Reinvest Attention Into Present Reality

Attention is finite infrastructure.

Every hour spent emotionally monitoring unavailable people is attention removed from:

health
growth
creativity
self-respect
future construction

The nervous system stabilizes when attention returns to reality instead of emotional prediction loops.

What Changed

After interrupting phantom notification conditioning:

emotional vigilance decreased
compulsive checking weakened
nervous system stability improved
attention fragmentation reduced

And most importantly:

Silence stopped feeling like emotional danger.

Reframing Attachment

Old model:

If I still react strongly, the connection must still matter.

Updated model:

Strong reactions can also indicate conditioned emotional surveillance.

That distinction restored clarity.

Takeaway

Some relationships continue affecting people long after they end because the nervous system was conditioned to anticipate emotional resolution from inconsistent sources.

The body keeps waiting.

The mind keeps scanning.

The attention system stays partially trapped in expectation.

Healing begins when the nervous system no longer interprets someone’s absence as an emergency requiring continuous monitoring.

Because peace is impossible while your internal alert system is still waiting for notifications from people who already left.

Status
Phantom notification loops: weakening
Emotional surveillance behavior: interrupted
Nervous system recalibration: active

Ghost Dependencies: The Relationships That Still Control You After They End

Khali Sollis — Fri, 07 Aug 2026 12:00:00 +0000

How unresolved emotional architecture continues operating after a relationship is gone, why absence does not equal detachment, and what happens when invisible dependencies keep running in the background

I used to think relationships ended when communication stopped.

That turned out to be false.

Some relationships continue operating long after:

the conversations end
the access disappears
the contact stops
the person leaves

Not externally.

Internally.

The visible connection may be gone.

But the dependency architecture remains active.

The Bug: Ghost Dependencies

In software systems, ghost dependencies are outdated or indirect dependencies that continue influencing the system even after the primary component is supposedly removed.

The application appears independent.

But hidden processes still rely on old structures.

Human attachment behaves similarly.

A relationship can end while invisible emotional dependencies continue running:

validation dependency
identity dependency
emotional regulation dependency
routine dependency
fantasy dependency

The person leaves.

The dependency survives.

Why “Moving On” Sometimes Fails

Because physical absence does not automatically remove emotional infrastructure.

You may stop talking to someone while still:

mentally consulting them
emotionally orienting around them
seeking their validation internally
imagining their reactions
structuring your worth around their perception

The relationship stops externally.

The system remains connected internally.

Hidden Emotional Processes

This realization was uncomfortable:

Some people were no longer in my life, but they were still influencing:

my confidence
my decisions
my emotional baseline
my self-worth
my nervous system responses

The dependency had become ambient.

Invisible.

Automatic.

The Lingering Architecture of Attachment

Relationships often install unconscious behavioral systems.

For example:

their approval
→ emotional stability
their distance
→ anxiety response
their attention
→ self-worth increase

Over time, the nervous system automates these associations.

Even after the relationship ends, the responses remain operational.

Emotional Residue

The difficult part is that ghost dependencies rarely feel obvious.

They show up subtly:

checking whether they would approve
mentally explaining yourself to them
comparing new people to them
replaying unresolved scenarios
feeling emotionally destabilized by reminders

The person becomes psychologically embedded beyond active contact.

When Someone Becomes Part of Your Internal Operating System

Some attachments persist because the relationship stopped being relational.

It became structural.

Their presence shaped:

identity
routines
emotional regulation
future planning
self-perception

When they leave, the system experiences destabilization because too many internal functions were outsourced externally.

The Illusion of Closure

Many people believe closure comes from:

final conversations
explanations
apologies
mutual understanding

Sometimes closure is much more technical than emotional.

Closure occurs when the dependency stops running.

Not when the story feels perfectly resolved.

The Nervous System Problem

This part matters more than most people realize.

The nervous system memorizes emotional patterns:

anticipation
reassurance cycles
conflict rhythms
emotional highs and lows
attachment reinforcement

When the relationship disappears, the body continues expecting those cycles.

Which is why absence can initially intensify obsession instead of reducing it.

The system is still searching for the missing dependency.

Ghost Dependencies and Identity

One of the strongest hidden dependencies was identity-based.

Without realizing it, I had attached parts of myself to:

being chosen
being needed
being understood
being emotionally significant to someone

When the relationship ended, those identity anchors destabilized too.

Part of the pain wasn’t losing them.

It was losing the version of myself that existed around them.

The Recursive Replay Loop

Ghost dependencies survive through repetition.

The system continuously reloads:

memory
→ emotional activation
→ mental replay
→ reinforcement

The loop keeps the dependency alive despite external absence.

Which means time alone does not necessarily heal attachment.

Uninterrupted reinforcement loops prolong it.

The Realization

Eventually, I stopped asking:

Why am I still affected by this?

And started asking:

What emotional functions am I still outsourcing to someone who is no longer here?

That question exposed the hidden architecture underneath the attachment.

The Fix: Dependency Removal

Detachment became less emotional and more structural.

The goal was not suppressing memories.

The goal was removing unauthorized control pathways.

Identify the Emotional Function

I stopped viewing the attachment as one giant emotional mass.

Instead, I broke it down technically:

validation
comfort
identity reinforcement
certainty
distraction from loneliness
emotional stimulation

Clarity reduced emotional fog immediately.

Stop Consulting Absent People Internally

This was subtle but critical.

I noticed how often I mentally referenced:

What would they think?

Even in their absence.

That meant internal authority had not fully returned to me.

Rebuild Internal Sources

Dependencies weaken when the functions become internally supported.

Instead of outsourcing:

worth
peace
direction
emotional regulation

the system slowly relearns self-generated stability.

Not perfectly.

But progressively.

Interrupt Emotional Replay Cycles

The nervous system strengthens what it repeatedly rehearses.

Constant replay keeps old architecture active.

Reducing:

memory spirals
fantasy loops
emotional revisiting
symbolic attachment rituals

gradually weakens dependency pathways.

What Changed

After identifying ghost dependencies:

emotional triggers became easier to understand
obsessive thinking decreased
identity stabilized
internal authority strengthened

And most importantly:

The relationship stopped unconsciously controlling my emotional environment.

Reframing Detachment

Old model:

I still care, therefore I am still connected.

Updated model:

Emotional residue is not proof that the dependency should remain active.
Takeaway

Some relationships continue controlling people long after they end because the visible relationship disappeared while the hidden dependencies remained installed.

Healing is not only emotional.

It is architectural.

The goal is not becoming cold or forgetting the connection existed.

The goal is removing outdated emotional systems that still control your inner environment without your permission.

Because absence alone does not create freedom.

Dependency removal does.

Status
Ghost dependency detection: active
Unauthorized emotional pathways: identified
Internal authority restoration: in progress

Emotional Cache Invalidation: Accepting That Someone Has Changed

Khali Sollis — Fri, 31 Jul 2026 12:00:00 +0000

How outdated emotional memory distorts present reality, why the mind keeps rendering old versions of people, and what happens when you finally update the relationship data

After reducing recursive attachment loops, another issue surfaced:

Part of my suffering wasn’t caused by the current version of the person.

It was caused by cached emotional data.

I was interacting with:

old memories
outdated expectations
previous emotional states
expired versions of the connection

Meanwhile, reality had already changed.

But internally, the system kept rendering an earlier build.

The Bug: Emotional Cache Persistence

In software systems, caching improves efficiency by storing previously accessed data for faster retrieval.

The problem occurs when cached data becomes outdated.

The system continues serving:

old information

as if it were:

current reality

Human attachment behaves similarly.

The mind caches:

emotional moments
intimacy patterns
relational dynamics
previous identities
earlier versions of people

And long after reality changes, the nervous system continues referencing stored emotional memory.

Why Letting Go Feels So Difficult

Because often, you are not grieving:

the current relationship
the current person
the current reality

You are grieving:

cached emotional history

The mind replays:

the good conversations
the emotional closeness
the early consistency
the moments of connection

And treats them as evidence that the current version still exists.

Even when the present behavior no longer matches.

The Difference Between History and Reality

This realization was brutal:

Someone can have genuinely loved you once and still no longer be aligned with you now.

Both can be true simultaneously.

But emotional memory struggles with temporal updates.

The system keeps asking:

What if the old version returns?

Instead of accepting:

The current behavior is the most accurate data.
Emotional Lag

The nervous system updates slower than observable reality.

Reality may already show:

emotional distance
inconsistency
withdrawal
incompatibility
changed priorities

But internally, emotional memory continues replaying:

who they used to be

This creates emotional lag between:

what the relationship was
and what it currently is

The larger the gap, the more suffering accumulates.

Why We Protect Outdated Versions

Because updating the emotional cache forces painful conclusions.

If the new data is accepted, then:

the fantasy weakens
the future projection collapses
the attachment destabilizes

So the mind attempts preservation:

minimizing red flags
overvaluing past intimacy
selectively replaying memories
emotionally time-traveling backward

Not because reality is unclear.

Because reality is emotionally expensive.

The Hope Loop

Outdated emotional caches are often sustained by intermittent reinforcement.

Small moments trigger full historical reconstruction:

brief attention
→ emotional memory activation
→ hope regeneration

The system interprets temporary familiarity as permanent restoration.

But isolated moments do not necessarily indicate restored alignment.

Sometimes they are simply echoes.

The Identity Factor

Part of the difficulty came from identity attachment.

The old version of the relationship validated:

a certain self-image
a certain emotional role
a certain future narrative

Accepting change meant acknowledging:

that version of life no longer exists

Which felt less like disappointment and more like identity destabilization.

Memory vs Pattern Recognition

Eventually, I had to stop prioritizing emotional memory over observable patterns.

Old processing method:

But remember when they...

Updated processing method:

What do their current patterns consistently show?

Patterns reveal system reality.

Memories reveal system history.

Those are not always the same thing.

The Realization

One sentence changed everything:

Missing who someone used to be does not obligate you to remain attached to who they are now.

That distinction separated grief from denial.

The Fix: Emotional Cache Invalidation

I stopped continuously reloading archived emotional data as if it represented the current system state.

Not by erasing history.

By updating reality accurately.

Prioritize Current Behavior Over Historical Memory

Old model:

Past connection outweighs present inconsistency

Updated model:

Present patterns define current reality

Stop Romanticizing Early Versions

The beginning of a relationship is not always the truest version.

Sometimes it is:

projection
idealization
temporary compatibility
untested potential

The most accurate version is the one sustained over time.

Separate Potential From Reality

This became critical.

I stopped attaching to:

who they could become

And started evaluating:

who they repeatedly demonstrated themselves to be

Potential is not stable architecture.

Patterns are.

Allow Grief Without Reconstructing Fantasy

Accepting change hurts.

But resisting change prolongs distortion.

The goal became:

grieving honestly
updating accurately
releasing outdated emotional rendering

Without rewriting reality to preserve attachment.

What Changed

After invalidating outdated emotional caches:

clarity increased significantly
emotional confusion decreased
obsessive hope loops weakened
nervous system stability improved

And unexpectedly:

Compassion became easier.

Because I stopped fighting reality.

Reframing Loss

Old model:

If I let go, the connection meant nothing.

Updated model:

Something can be real, meaningful, and still no longer aligned with the present.
Takeaway

One of the hardest emotional updates is accepting that someone has changed—or that your understanding of them was incomplete.

The mind prefers cached familiarity over painful updates.

But healing begins when current reality becomes more important than archived emotional memory.

Because attachments often persist not from present connection, but from outdated emotional rendering continuously loaded into the system.

Status
Outdated emotional cache: invalidated
Pattern recognition systems: prioritized
Reality synchronization: improving

Recursive Loneliness: Why Some Attachments Feel Impossible to Exit

Khali Sollis — Fri, 24 Jul 2026 12:00:00 +0000

How emotional isolation creates dependency loops, why certain relationships become psychological survival systems, and what happens when loneliness starts disguising itself as love

After reclaiming cognitive space and reducing emotional reactivity, another uncomfortable realization surfaced:

Some attachments survive not because the connection is healthy.

But because the loneliness underneath them feels unbearable.

At first, I thought I was struggling to let go of a person.

Eventually, I realized I was struggling to face the emotional vacuum their absence exposed.

The attachment had become more than emotional.

It had become structural.

The Bug: Recursive Loneliness

Loneliness is not always the absence of people.

Sometimes it is the absence of:

self-connection
meaning
emotional safety
identity stability
internal grounding

And when unresolved loneliness meets emotional attachment, the system creates a dangerous recursive loop:

loneliness
→ attachment
→ dependency
→ fear of loss
→ increased attachment
→ deeper loneliness

The attachment temporarily relieves the loneliness.

But simultaneously deepens dependency on the source relieving it.

Why Some Attachments Feel Addictive

Certain people become emotionally overrepresented inside the nervous system.

Not because they are objectively irreplaceable.

Because the system assigned them too many functions.

They became:

comfort
validation
distraction
identity reinforcement
emotional regulation
future projection
relief from emptiness

The attachment stopped being relational.

It became infrastructural.

The Hidden Fear Beneath Attachment

One realization changed everything:

I was not only afraid of losing them.

I was afraid of what remained without them.

Silence.
Stillness.
Unoccupied emotional space.

The attachment distracted me from unresolved internal conditions I had postponed confronting.

Which meant the relationship was functioning partly as emotional anesthesia.

Loneliness as Cognitive Amplification

Loneliness distorts perception.

When emotionally isolated, the mind often exaggerates:

compatibility
emotional significance
rarity
idealization

The system starts interpreting emotional relief as evidence of destiny.

relief from loneliness
≠
evidence of alignment

But emotionally deprived systems struggle to distinguish between the two.

Why We Stay Attached to Inconsistent People

Because inconsistency strengthens reinforcement loops.

Predictable affection stabilizes the nervous system.

Intermittent affection destabilizes it.

And destabilized systems often become more attached, not less.

The cycle looks like this:

distance
→ anxiety
attention returns
→ relief
relief intensifies attachment

This creates emotional conditioning similar to variable reward systems.

The unpredictability itself strengthens fixation.

The Identity Collapse Problem

Some attachments become difficult to exit because identity gradually reorganizes around them.

Daily emotional orientation shifts toward:

waiting
monitoring
interpreting
anticipating
emotionally orbiting another person

The self becomes partially externally anchored.

When the attachment destabilizes, identity destabilizes with it.

Which is why the pain often feels existential instead of relational.

Emotional Dependency Disguised as Love

This was difficult to admit.

Part of what I called love was dependency amplified by loneliness.

Not fake emotion.

But emotionally overloaded meaning.

The person became symbolic.

The attachment absorbed:

unmet needs
unresolved fears
longing for belonging
desire for emotional certainty

The emotional weight exceeded the actual relationship.

The Nervous System Factor

Loneliness is physiological as much as psychological.

The nervous system adapts to emotional patterns:

texting rhythms
attention cycles
emotional reassurance
anticipated contact

When those disappear, the body experiences withdrawal-like symptoms.

Which is why detachment initially feels:

physically uncomfortable
mentally obsessive
emotionally disorienting

The system is recalibrating dependency pathways.

The Recursive Loop

The dangerous part is this:

Loneliness increases attachment.

Attachment avoidance increases isolation.

Isolation intensifies loneliness.

The system begins feeding itself.

emotional emptiness
→ obsessive attachment
→ self-abandonment
→ deeper emptiness

Without interruption, the loop becomes identity-level programming.

The Realization

Eventually, I stopped asking:

Why can’t I let go?

And started asking:

What am I trying not to feel without this attachment?

That question exposed the real architecture underneath the obsession.

The Fix: Rebuilding Internal Stability

Detachment became easier when the system stopped relying on one person for emotional regulation.

Not instantly.

Incrementally.

Separate the Person From the Function

I stopped viewing them as:

my stability

And started identifying the functions I had assigned them:

reassurance
distraction
belonging
validation
emotional intensity

This clarified the dependency structure.

Reduce Emotional Monopolies

No single person should become:

your only comfort
your only excitement
your only emotional focus
your only sense of connection

Healthy systems distribute emotional investment.

Dependency centralizes it dangerously.

Rebuild Relationship With Solitude

This part was critical.

Loneliness and solitude are not identical.

Loneliness says:

I am abandoned.

Solitude says:

I am present with myself.

The nervous system had to relearn safety without constant emotional stimulation.

Create Identity Outside the Attachment

The attachment weakened when life stopped revolving around emotional monitoring.

Attention returned toward:

work
growth
health
creativity
future construction
self-respect

Identity became internally generated again.

What Changed

After interrupting recursive loneliness patterns:

emotional obsession decreased
nervous system stability improved
clarity increased
self-abandonment reduced significantly

And unexpectedly:

The attachment itself became easier to evaluate accurately.

Without loneliness amplifying it, I could finally see the relationship clearly.

Reframing Attachment

Old model:

I can't let go because they matter too much.

Updated model:

Part of the attachment was unresolved loneliness seeking relief.

That distinction changed everything.

Takeaway

Some attachments feel impossible to exit because they are intertwined with loneliness, identity instability, and emotional dependency loops.

The pain is not always proof of profound love.

Sometimes it is proof that too much of your emotional survival became centralized in one person.

Detachment begins when you stop asking another human being to function as the missing architecture inside yourself.

Status
Recursive attachment loops: weakening
Emotional dependency centralization: reduced
Internal stability reconstruction: active

Overriding the Impostor Protocol: A Developer's Guide to Psychological Safety

Khali Sollis — Fri, 17 Jul 2026 14:00:00 +0000

Many software teams have gotten smaller. Over the last several years, a large share of the industry has drifted away from heavily layered engineering departments and toward small, highly autonomous squads — three or four people who own a service end to end, ship independently, and answer to a backlog instead of a hierarchy. The pitch is obvious: less coordination overhead, faster decisions, tighter ownership. What gets less attention is what this shift does to the person sitting inside one of those small teams at eleven at night, staring at a pull request they're not sure is right, with no senior engineer down the hall to ask.

That scene is becoming increasingly common, and organizational psychologists are starting to notice the cost. Research on team design has found that as organizations flatten and autonomy increases, individual cognitive load rises with it — engineers are absorbing more decisions, more ambiguity, and more responsibility for judgment calls that used to be distributed across a bigger group. The traditional scaffolding of a large team — a tech lead to sanity-check your approach, a QA process to catch what you missed, a manager buffering you from the business side — is exactly the kind of redundancy that autonomous team structures are designed to strip out. That redundancy, it turns out, was doing more than distributing work. It was distributing anxiety.

This matters because the psychological experience of writing code hasn't changed at the same pace as the org chart. Developers still have the same nervous system humans have always had, one built to read ambiguity as danger and isolation as risk. What's changed is the amount of unresolved uncertainty an individual is now expected to metabolize alone. The result is a workplace environment where many developers report higher levels of performance anxiety, and where a very old, very familiar visitor keeps showing up: impostor feelings. This piece is about why that's happening, what the underlying psychology actually is, and what a developer — and a team — can do about it that isn't just "believe in yourself."

The Ambiguity Threat: Why Your Brain Treats a Vague Ticket Like a Predator

Impostor syndrome gets talked about as if it were a personality quirk, a flaw in certain people's self-confidence wiring. That framing is mostly wrong, and it's worth being precise about why.

The human brain did not evolve in a world of shifting technical specifications, but it did evolve in a world where not knowing something — where the threat was, whether a stranger was hostile, whether the ground ahead was safe — could get you killed. Ambiguity itself, not just concrete danger, is something the brain is built to treat as risky. Neuroscience research on uncertain-threat anticipation has found that ambiguity engages threat-processing networks involving regions such as the amygdala and related circuits associated with vigilance and prediction, and that these networks tend to stay engaged for longer, and less predictably, than when a threat is clear and defined. A known threat, oddly, is often easier on the nervous system than an unknown one. Certainty lets the brain relax once the threat has passed. Ambiguity keeps the alarm running in the background indefinitely, because there's no clear signal telling it the "all clear" has arrived.

This is not a fringe finding. A body of work on anxiety and uncertainty, reviewed in detail by researchers studying anxiety disorders, describes something close to a general principle: people don't just respond to danger, they respond to the inability to predict danger, and that inability is often more distressing than the danger itself. People with a harder time tolerating uncertainty show heightened activity in threat-related brain circuitry specifically when a situation is ambiguous, even when nothing bad is actually happening.

Translate that into a developer's daily experience and the pattern becomes obvious. A vague ticket, a codebase you didn't write, a spec that changes mid-sprint, a pull request sitting unreviewed for two days with no comment — none of these are physically dangerous. But they are ambiguous, and ambiguous is precisely the category of stimulus your threat-detection system was built to flag. When you're on a small team without someone to immediately clarify the ambiguity for you, that flag doesn't get resolved. It just sits there, humming, and your brain interprets the hum as evidence that something is wrong with you rather than evidence that the situation is genuinely unclear.

That's the mechanism behind what we might call the ambiguity threat in engineering contexts: a baseline of low-level anxiety that isn't really about your competence at all. It's a background threat-response running because the environment is feeding your brain exactly the kind of unresolved signal it's wired to worry about. Machine-speed codebases — fast-moving repos, rapidly shifting dependencies, specs that update while you're mid-implementation — generate an unusually high volume of that signal. Your threat-detection systems don't have a clean category for "ambiguous but professionally routine." They just have ambiguous, and they respond to it the same way they always have.

AI-assisted development adds a newer version of this same problem. A developer can now generate code faster than they can build genuine confidence in their understanding of it. The bottleneck shifts from producing output to validating judgment. When a model hands back a plausible-looking solution with reasoning that isn't fully visible, the psychological challenge stops being just "can I write this?" and becomes "can I actually tell whether this is correct?" That's a harder, more ambiguous question, and it arrives more often, for more of the day, than it used to. In that environment, the team practices described below matter even more, because asking out loud "does this approach actually hold up?" needs to function as a normal, expected part of engineering work rather than something that reads as a gap in skill.

Impostor Syndrome Wasn't Designed for Software Engineering

The term "impostor phenomenon" comes from a 1978 paper by psychologists Pauline Clance and Suzanne Imes, who studied a group of more than 150 highly accomplished women — professors, professionals, people with strong track records of success — who nonetheless felt they were frauds who had somehow fooled everyone around them. Clance and Imes described this as an internal experience of intellectual phoniness, one that persisted no matter how much objective evidence of competence a person accumulated. Notably, they didn't even call it a syndrome — Clance later pushed back on that label, since it implies a disorder located inside the individual, when what she was actually describing was more like a persistent, situationally reinforced belief pattern.

In the decades since, research has confirmed the impostor phenomenon shows up well beyond its original context — across genders, across professions, and with particular intensity during transitions: new job, new team, a jump into unfamiliar technical territory. That last detail matters a lot for engineering. Software development is one of the only professions where the "unfamiliar territory" transition never really ends. Frameworks turn over, best practices get revised, an entirely new tool can become table stakes within eighteen months. Developers are, in a sense, permanently new.

What's useful about connecting the ambiguity-threat research to the impostor-phenomenon research is that it reframes the whole experience. Impostor syndrome isn't a verdict about your actual skill. It's what it feels like from the inside when a nervous system built to treat unresolved ambiguity as risk is placed in an environment that produces an unusually steady diet of exactly that kind of ambiguity — a fast-moving codebase, limited external feedback, a small team without much structural redundancy. "I'm not good enough" is a more emotionally coherent story than the accurate but less intuitive one: my threat-detection circuitry is responding to unresolved uncertainty, and it doesn't reliably distinguish a vague spec from a genuine threat.

That reframe doesn't make the feeling disappear. But it changes what you do with it, which is the more useful question.

Cognitive Reframing for Engineers: Read the Error Log, Don't Internalize It

Developers already have a mental model that's unusually well suited to handling this, they just don't usually apply it to themselves: the error log.

When a system throws an error, a competent engineer doesn't take it personally. Nobody thinks "this stack trace means I'm fundamentally broken as a person." The instinct is investigative — what triggered this, what was the input, what's the actual failure condition. That instinct is worth deliberately importing into how you handle self-doubt.

This isn't just a metaphor; it maps onto something real in the psychology of emotion regulation. A well-replicated line of research on what's called affect labeling — the simple act of naming an emotion in specific, concrete language rather than just experiencing it — has found that putting a feeling into words is associated with reduced amygdala activity and increased engagement of regulatory regions of the prefrontal cortex. In practice, this means the difference between "I'm an impostor, I don't belong here" and "I'm noticing anxiety because this ticket is ambiguous and I haven't gotten feedback on my approach yet" is not just semantic. The second version is functionally closer to reading a log line than absorbing a verdict, and the research suggests that specificity itself has a calming effect on the underlying physiological response, independent of whether the situation has actually changed.

The practical version of this looks something like a debugging checklist, applied to the feeling itself rather than suppressed or fought:

What's the actual input? Usually it's something concrete — an unreviewed PR, a spec that changed twice this week, a codebase you inherited without documentation. Naming the specific trigger, rather than the diffuse feeling of dread, does most of the regulatory work.

Is this ambiguity resolvable, or is it structurally built into the situation? Sometimes the fix is asking a direct question. Sometimes the honest answer is that the codebase genuinely is underdocumented and the anxiety is a reasonable response to a real information gap, not a personal failing.

Is there a feedback loop I can shorten? Impostor feelings often thrive in feedback vacuums — work that goes into a PR queue and sits for days without comment. Shortening that loop, even by asking for a quick async check-in, gives your threat-detection system the "all clear" signal it's been waiting for.

None of this is about talking yourself out of a legitimate skill gap — sometimes the honest read of the error log is "I do need to learn this," and that's a fine, ordinary conclusion, not a crisis. The goal of reframing isn't relentless positivity. It's accuracy. Treating self-doubt as a data point to be examined, rather than a truth to be absorbed, keeps the signal without letting it metastasize into a story about your worth as an engineer.

Building Team Immunity: Psychological Safety in Small, Fast Teams

Individual reframing only goes so far if the team environment keeps generating the same volume of unresolved ambiguity. This is where the research on psychological safety becomes directly relevant, and it's worth being precise about what that term actually means, because it gets used loosely.

The concept comes out of work by Harvard Business School researcher Amy Edmondson, who in the late 1990s studied hospital teams expecting to find that better-performing units made fewer medication errors. She found that higher-performing teams reported more errors, which suggested they were more willing to surface mistakes rather than hide them, while lower-performing teams were more likely to under-report the errors they were actually making. Edmondson's subsequent research formalized this into psychological safety: a shared belief within a team that it's safe to take interpersonal risks — asking a question that might sound basic, admitting you're stuck, flagging a mistake before it compounds — without fear of embarrassment or punishment. Years later, Google's internal Project Aristotle research, studying roughly 180 of its own teams, independently arrived at a strikingly similar conclusion using very different methods: among the characteristics Google's researchers identified as associated with effective teams, psychological safety emerged as the strongest one, ahead of who was actually on the team.

It's worth being clear about what psychological safety is not, since the term gets softened in ways the research doesn't support. It isn't the absence of high standards, and it isn't a euphemism for niceness. Psychologically safe teams still disagree openly and give direct feedback — in fact, visible disagreement is often a sign the safety is working, not a sign it's absent. What it protects is the willingness to say "I don't know" or "I think this is wrong" out loud, rather than silently absorbing the uncertainty alone.

For a small, autonomous engineering team, this translates into fairly concrete practices, most of which live in the parts of the workflow developers already touch daily.

Code review language matters more than it seems. A comment that reads "this is wrong" produces a very different physiological response than one that reads "I'm not sure this handles the edge case where the list is empty — can you walk me through the reasoning?" Both might be pointing at the same bug. Only one of them treats the ambiguity as a shared problem to investigate rather than a verdict on the author.

Normalizing "I don't know" from senior people specifically does more work than any written policy. When the most experienced person on a small team openly says they're not sure how something works, or that they'd need to look something up, it recalibrates what "competent" is allowed to look like for everyone else on the team. Edmondson's own guidance on this point is that leaders acknowledging their own fallibility is one of the more reliable ways to shift a team's norms, because it directly contradicts the assumption that not-knowing is disqualifying.

Shortening feedback loops on pull requests is a structural fix for a psychological problem. A PR that sits unreviewed for two days doesn't just delay a merge — it extends the window in which the author's threat-detection system has no "all clear" signal. Even a same-day partial response ("haven't done a full review yet, but this approach looks right at a glance") closes that loop faster than silence does, and the ambiguity-threat research suggests that matters more than it might seem to on a busy team.

This becomes even more important in AI-assisted environments, where the ability to question, verify, and challenge generated output needs to function as a team capability, not just something each developer is expected to sort out alone.

None of this requires reversing the industry-wide move toward smaller teams, which brings real benefits in speed and ownership. It requires recognizing that smaller teams removed some of the structural redundancy that used to absorb ambiguity on a developer's behalf, and that the difference has to be made up somewhere — either by the individual's own regulation skills, or by deliberate norms the team builds into its daily workflow. Realistically, it needs to be both.

The Developer Debugging Checklist

The reframing described throughout this piece compresses into something closer to a quick reference than a mindset. When impostor feelings show up mid-task, it can help to run through it the way you'd triage a failing build:

Identify the input. What concrete uncertainty triggered this — a vague ticket, an unreviewed PR, an unfamiliar part of the codebase?
Separate signal from story. Is there real evidence of a skill gap here, or is this an information gap that anyone in your position would hit?
Reduce the feedback latency. Who can help close the uncertainty loop, and how quickly can you actually ask them?
Convert anxiety into action. What's the next smallest experiment or question that would move this from ambiguous to resolved?

None of these steps make the feeling vanish on contact. They just route it toward something a debugging mindset already knows how to do: investigate the input instead of accepting the alert at face value.

Conclusion: The Signal Was Never the Problem

The presence of performance anxiety among developers isn't a sign that engineers have gotten more fragile, or that today's teams are somehow less capable than the generation before them. It's a predictable outcome of an environment that generates an unusually high volume of unresolved ambiguity compared with more traditional engineering structures, delivered to people working in smaller units with less structural buffering than they used to have. The nervous system responding to that environment is doing exactly what it evolved to do. It's just applying an old survival mechanism to a workplace it wasn't built for.

Understanding impostor syndrome this way — as a response to environmental signal rather than a verdict on personal worth — doesn't dissolve the feeling on contact. But it does change what a developer does with it: name the actual trigger instead of the diffuse dread, treat the feeling as information to investigate rather than truth to absorb, and recognize that shortening the gap between uncertainty and resolution is a legitimate technical and psychological intervention, not a soft skill tacked onto the real work.

As engineering organizations continue experimenting with smaller, faster, more autonomous team structures, the psychological cost of that speed is likely to become a more explicit part of how teams are designed, not just how individuals cope. The next wave of tooling and process design in software engineering may end up looking less like project management and more like applied cognitive science — feedback loops, review norms, and team rituals built with an explicit understanding of how the human threat-detection system actually works. The code has been moving at machine speed for a while now. The interesting problem left to solve is how the humans writing it keep up without quietly convincing themselves they don't belong there.

Scientific Reference

Clance, P. R., & Imes, S. A. (1978). The impostor phenomenon in high achieving women: Dynamics and therapeutic intervention. Psychotherapy: Theory, Research & Practice, 15(3), 241–247.

Grupe, D. W., & Nitschke, J. B. (2013). Uncertainty and anticipation in anxiety: An integrated neurobiological and psychological perspective. Nature Reviews Neuroscience, 14(7), 488–501.

Hur, J., Smith, J. F., DeYoung, K. A., Anderson, A. S., Kuang, J., Kim, H. C., Tillman, R. M., Kuhn, M., Fox, A. S., & Shackman, A. J. (2020). Anxiety and the neurobiology of temporally uncertain threat anticipation. Journal of Neuroscience, 40(41), 7949–7964.

Lieberman, M. D., Eisenberger, N. I., Crockett, M. J., Tom, S. M., Pfeifer, J. H., & Way, B. M. (2007). Putting feelings into words: Affect labeling disrupts amygdala activity in response to affective stimuli. Psychological Science, 18(5), 421–428.

Edmondson, A. C. (1999). Psychological safety and learning behavior in work teams. Administrative Science Quarterly, 44(2), 350–383.

Edmondson, A. C. (2019). The Fearless Organization: Creating Psychological Safety in the Workplace for Learning, Innovation, and Growth. Wiley.

Duhigg, C. (2016, February 25). What Google learned from its quest to build the perfect team. The New York Times Magazine.

Skelton, M., & Pais, M. (2019). Team Topologies: Organizing Business and Technology Teams for Fast Flow. IT Revolution Press.

Mental Unfollow: Reclaiming Your Cognitive Space After Emotional Attachment

Khali Sollis — Fri, 17 Jul 2026 12:00:00 +0000

How emotional attachment becomes mental occupation, why attention functions like system resources, and what changes when you stop allowing one person to dominate your internal architecture

I used to think detachment meant forcing myself not to care.

That never worked.

Because the real problem wasn’t emotional intensity.

It was cognitive occupation.

Someone had taken up permanent residency inside my mental environment.

Not physically.
Mentally.

They were present:

in my mornings
during work
inside random pauses
behind ordinary moments
underneath unrelated thoughts

The relationship had changed.

But internally, the process was still running.

The Bug: Emotional Attachment as Background Processing

Most people think attachment is about love.

Often, it’s about repetition.

The mind builds recursive loops:

memory
→ interpretation
→ emotional reaction
→ replay
→ reinforcement

Repeated enough times, the person becomes cognitively embedded.

Not because they are continuously present in reality.

Because they remain continuously active in attention.

Mental Occupation Is Resource Consumption

One realization changed everything:

Attention is infrastructure.

Whatever consistently occupies it begins shaping:

emotional state
nervous system regulation
identity stability
behavioral patterns

Which means emotional attachment is not just emotional.

It is architectural.

If one person dominates your internal environment:

focus decreases
emotional volatility increases
self-reference weakens

The system gradually reorganizes itself around their presence or absence.

The Difference Between Reality and Interpretation

The attachment often survives because the mind confuses:

reality

with:

interpretation

Reality:

They became distant.

Interpretation:

I wasn’t enough.

Reality:

The relationship changed.

Interpretation:

I lost my future.

Most suffering wasn’t generated by events themselves.

It came from the emotional narratives attached to them.

Expectation, Illusion, Habit

Eventually, I realized attachment was built on three unstable dependencies.

Expectation

Not the person themselves.

The imagined future surrounding them.

The mind mourned:

projected timelines
imagined conversations
hypothetical versions of life

Many emotional contracts existed only internally.

Illusion

The attachment survived partly because I remained attached to potential instead of patterns.

who they could become

over:

who they consistently were

The nervous system prefers fantasy when reality threatens emotional investment.

Habit

This was the most underestimated layer.

Sometimes I didn’t miss the person.

I missed:

the routines
the checking
the anticipation
the familiarity
the emotional stimulation cycle

The attachment became procedural.

The Realization

Detachment is not:

becoming cold
suppressing emotion
pretending not to care

It is reclaiming cognitive territory.

Because when someone continuously occupies your attention, they indirectly influence:

your emotional baseline
your nervous system
your energy allocation
your identity stability
The Stoic Parallel

Stoicism emphasizes a simple but brutal distinction:

event
≠
interpretation

The event exists.

The emotional meaning layered onto it is often self-generated.

Which means emotional suffering frequently persists because the mind keeps refreshing the narrative.

Not because reality keeps happening.

The Fix: Mental Unfollow

I stopped focusing only on physical distance.

I started reducing mental access.

Not blocking.

Not hatred.

Cognitive boundary enforcement.

Label the Mental Visit

Whenever the thought loop appeared:

memory detected

I stopped treating it as truth.

I identified it accurately:

nostalgia
longing
uncertainty
fear
emotional habit

Naming the process weakened automatic immersion.

Reduce Recursive Thinking Time

Old pattern:

trigger
→ 45-minute emotional spiral

Updated pattern:

trigger
→ acknowledge
→ redirect attention

The goal was not suppression.

It was reducing emotional dwell time.

Remove Reinforcement Triggers

Certain behaviors continuously reopened the loop:

checking social media
rereading messages
replaying conversations
revisiting symbolic locations
consuming emotional reminders

The nervous system cannot recalibrate while constantly retriggering itself.

Replace the Cognitive Pathway

This part mattered most.

Detachment cannot exist in a vacuum.

Attention needs redirection.

Instead of:

obsession loop

the system needed:

training
writing
work
movement
creation
future-oriented behaviors

New pathways reduce old dependencies.

Emotional Reactivity and Nervous System Conditioning

One difficult truth:

Many reactions weren’t love.

They were conditioned nervous system responses.

notification
→ dopamine spike
silence
→ anxiety response
memory
→ emotional activation

The body learned the pattern before the mind questioned it.

Which is why detachment initially feels physically uncomfortable.

The system is recalibrating.

Pause → Label → Reframe

This became the most useful interruption framework.

Pause

No immediate reaction.

No impulsive interpretation.

Label
This is anxiety.
This is nostalgia.
This is fear of abandonment.

Not:

This is reality.
Reframe

Ask:

What are the observable facts?

Not:

What catastrophic story can I build?

This restored clarity surprisingly fast.

Rebuilding Identity Outside the Attachment

Another painful realization:

Part of the suffering came from losing the identity attached to the relationship.

The old self felt:

chosen
desired
emotionally anchored

When the attachment destabilized, identity destabilized with it.

Which meant detachment required rebuilding self-definition independent of the connection.

Not theoretically.

Behaviorally.

Reclaiming Internal Space

Eventually, the system stopped asking:

How do I get them back?

And started asking:

How do I get myself back?

That question changed the architecture entirely.

Because the goal stopped being emotional recovery through another person.

The goal became internal coherence.

Reframing Detachment

Old model:

Detachment = suppression

Updated model:

Detachment = reclaiming cognitive sovereignty
Takeaway

Emotional attachment becomes dangerous when another person occupies more mental space than your own future does.

The solution is not hatred.

Not emotional numbness.

Not pretending the connection never mattered.

The solution is reducing unnecessary mental occupation until your attention belongs to you again.

Because attention shapes identity.

And whatever repeatedly occupies your mind eventually occupies your life.

Status
Emotional recursion loops: weakening
Mental unfollow protocols: active
Cognitive territory: gradually reclaimed

The Science of "Local Sleep": Why Your Code Gets Worse After Hour Six

Khali Sollis — Wed, 15 Jul 2026 14:00:00 +0000

It's hour six. The coffee stopped working around hour four. You're still staring at the same function, still typing, still technically awake — but something has changed. The bug that would have taken ten minutes to spot at 10 a.m. is now invisible to you at 4 p.m., even though it's sitting right there in the diff. You tell yourself you just need to push through, finish the feature, ship the fix. So you do. And tomorrow morning, with fresh eyes, you delete half of what you wrote.

This is such a common experience in software work that it barely registers as strange. We treat it as a willpower problem, a caffeine problem, maybe a "just go to bed earlier" problem. But a growing body of neuroscience suggests something odder is going on, something that has nothing to do with motivation and everything to do with basic brain physiology. Under the right conditions, small clusters of neurons in your frontal cortex can start behaving as if they're asleep — dropping into brief, localized down-states — while the rest of your brain, and you, remain awake. Researchers call this local sleep, and it may be one of the more precise biological explanations we have for why exhausted coding sessions produce work you have to redo.

This isn't a metaphor. It's not "your brain is tired" as a figure of speech. It's a measurable, regional phenomenon, and understanding it changes how you might think about pushing through a long day at the keyboard.

Sleep Was Never Supposed to Be an All-or-Nothing Switch

For most of the twentieth century, sleep science treated sleep and wakefulness as two clean, mutually exclusive states governed by the whole brain at once. You were either asleep or you weren't. That model started to crack in the late 2000s and early 2010s, when researchers studying sleep-deprived rats noticed something strange in their brain recordings: even while the animals were behaviorally awake and moving around, certain neurons in the cortex would briefly go quiet, firing in patterns identical to the "off periods" seen during normal deep sleep. These weren't whole-brain events. They were confined to small populations of neurons, often in specific cortical regions, while neighboring populations kept firing normally.

A landmark 2011 study led by Vladyslav Vyazovskiy and colleagues, published in Nature, gave this phenomenon its name and its first solid evidence base. After extended wakefulness, cortical neurons in rats dropped into these brief sleep-like states even though the animals showed no outward sign of drowsiness. More strikingly, when these local off-periods occurred in the motor cortex right before the animal attempted a reaching task, performance suffered. The neurons "sleeping" were, quite literally, the ones responsible for the skill being tested. Follow-up work, notably from Chiara Cirelli and Giulio Tononi's sleep research group, found that local sleep doesn't strike the brain evenly — it concentrates in regions that have been working the hardest, as though heavily used circuits accumulate their own local sleep debt, independent of how sleepy the animal feels overall.

From Rat Cortex to the Human Frontal Lobe

Most of the direct evidence for local sleep — the kind involving electrodes recording individual neurons — comes from animal studies, for obvious ethical and technical reasons. Human research relies on coarser tools like EEG, but it points the same direction. Studies of sleep-deprived volunteers consistently find that slow-wave activity, the electrical signature associated with deep sleep, shows up disproportionately over frontal brain regions during prolonged wakefulness, well before someone would describe themselves as needing to sleep, and this frontal slowing tracks subjective sleepiness more tightly than whole-brain measures do. Researchers are careful to note this doesn't prove individual neurons in a tired person's prefrontal cortex are dropping into literal sleep states mid-task; single-neuron resolution in humans isn't available yet, so the human findings are best read as a compatible extension of the animal work rather than direct confirmation. What they do support, with reasonable confidence, is the broader pattern: prolonged wakefulness produces localized, disproportionate degradation in frontal brain function, well before a person consciously registers being too tired to work. Researchers have also linked these localized sleep-like events to brief attentional lapses, offering another possible explanation for why obvious errors sometimes become strangely invisible during a long stretch of work.

That distinction matters. The frontal cortex isn't just another brain region. It's the seat of what neuroscientists call executive function — the machinery responsible for planning, weighing tradeoffs, holding multiple things in mind at once, and inhibiting bad impulses. If any part of the brain is likely to show early signs of strain during a long stretch of demanding cognitive work, the frontal cortex is one of the worst places for that strain to appear if your job depends on careful, structured thinking.

Why the Brain Puts a Price Tag on Thinking

There's a second, related strand of research that helps explain why a tired brain doesn't just get slower — it starts making different kinds of decisions. This comes out of work on what psychologists and neuroscientists call the cost of cognitive control.

The older explanation for mental fatigue, "ego depletion," treated willpower as a fuel tank that simply runs dry. That idea has largely fallen out of favor after large replication efforts failed to reproduce it, so it's worth setting aside in favor of a better-supported account.

A more durable line of research, associated with psychologists Wouter Kool and Matthew Botvinick, offers a different and better-supported account. Their work suggests the brain treats sustained mental effort not as a resource that simply drains, but as something it actively evaluates for cost, the same way it might weigh the cost of a physical action. Using tasks that let people choose between easier and harder versions of a problem, Kool and Botvinick found that people reliably steer toward the lower-effort option, even when the harder option would produce a better outcome and takes only marginally more work. Brain imaging tied this preference to activity in the lateral prefrontal cortex, the same broad region implicated in local sleep research, with the strength of that activity predicting how strongly an individual avoids demanding tasks.

The theoretical framework built around these findings, often called the cost of control hypothesis, proposes that cognitive control is inherently registered by the brain as effortful and mildly aversive, and that people (and other animals) are constantly running a background calculation about whether continued effort is worth it. Under this model, fatigue doesn't necessarily mean your cognitive machinery has literally run out of gas. It can mean the brain has revised its internal accounting and started rating effortful, careful thinking as not worth the cost — a shift that happens well before actual capacity hits zero.

Put those two lines of research together and a coherent picture starts to form. As a demanding task like debugging stretches into its fifth or sixth hour, two things are likely happening at once: heavily used frontal circuits are accumulating local sleep pressure and periodically going quiet, and the brain's ongoing cost-benefit evaluation of continued effort is tilting against sustained, careful control. Neither process requires you to feel dramatically sleepy. Both can happen while you're still upright, caffeinated, and staring intently at a monitor.

When the Careful Planner Clocks Out, Habits Take the Wheel

If the prefrontal cortex is scaling back — whether through local sleep, rising effort costs, or both — something else has to be steering behavior, because the fingers are still typing and decisions are still getting made. That's where a much older and more thoroughly established piece of neuroscience becomes relevant: the basal ganglia's role in habit formation.

The basal ganglia are a cluster of structures deep in the brain long known to be central to how habits get encoded and executed. Decades of research, including influential work from neuroscientist Ann Graybiel at MIT, has shown that as a behavior becomes well-practiced, control over it gradually shifts away from the deliberate, flexible planning done by the prefrontal cortex and toward the more automatic, pattern-matching circuitry of the basal ganglia. This is generally a feature, not a bug — it's the same mechanism that lets you drive a familiar route without consciously thinking through every turn, freeing up limited executive resources for whatever is genuinely novel in front of you.

The trouble is that this handoff isn't selective about quality. The basal ganglia reinforce practiced behavioral patterns without evaluating whether they're the most appropriate choice for a novel problem; they simply execute whatever has been repeated most often, with the least resistance. When prefrontal function is degraded and the basal ganglia take over more of the moment-to-moment decision-making, behavior tends to default to whatever is most familiar, not whatever is best suited to the problem at hand.

This offers a plausible mechanistic story for a pattern many experienced developers recognize: late in a long session, one possible consequence is a greater tendency to rely on familiar patterns rather than carefully evaluating alternatives — reaching for the first solution that technically works rather than the one that fits the architecture. It isn't that the person got lazier or stopped caring. It's a plausible consequence of executive circuitry stepping back while older, lower-effort circuitry fills the gap, consistent with what you'd expect if frontal regions are experiencing local, regional fatigue while the rest of the brain carries on.

What This Looks Like at the Keyboard

None of this research was designed with software developers in mind — the underlying studies involve rats reaching for pellets, human volunteers doing memory tasks in scanners, and people choosing between easy and hard card-sorting problems. But debugging and system design sit squarely in the category of activity this research describes: sustained, effortful, prefrontal-heavy cognitive control, applied over long, uninterrupted stretches, with no built-in signal telling you when the underlying hardware has started to degrade.

That absence of a clear internal signal is arguably the most important, and most underappreciated, part of this picture. Physical fatigue announces itself. Your arms get heavy, your eyes sting, your body makes it hard to ignore that something has changed. Local, regional cognitive fatigue in the frontal cortex doesn't come with an equivalent alarm. You can feel reasonably alert in a general sense — awake, upright, tracking the conversation in Slack, aware of what time it is — while the specific circuits responsible for weighing architectural tradeoffs, holding a complex mental model of a codebase, and catching subtle logical errors are already operating at reduced capacity. The mismatch between how alert you feel and how well your executive function is actually working is precisely what makes this kind of fatigue dangerous for any work that depends on careful judgment.

It also explains a familiar and slightly demoralizing pattern: reviewing code the next morning and immediately spotting problems that were completely invisible the night before, even though nothing about the code changed and nothing about your intelligence changed either. What changed was the operating condition of the specific brain regions doing the evaluating. A rested prefrontal cortex, not fatigued and not compensating for local shutdowns, is simply a different instrument than the one you were using at hour six.

From Managing Time to Managing Cognitive Energy

The traditional framing of productivity in software work is almost entirely built around time: sprint velocity, hours logged, deadlines, calendar blocks. That framing assumes a roughly constant unit of cognitive capacity per hour, as if an hour of focused work at 9 a.m. and an hour of focused work at 9 p.m. are interchangeable inputs. The research on local sleep and effort cost suggests that assumption is close to backwards for anything requiring sustained executive function.

A more accurate model treats cognitive capacity, particularly the specific capacity for careful, controlled, judgment-heavy thinking, as a resource that fluctuates across a session in ways that don't track clock time or subjective sleepiness particularly well. Under this model, the more useful question isn't "how many hours have I worked" but something closer to "how much regional fatigue has accumulated in the circuits this task actually depends on, and has my brain's internal cost-benefit calculation already started favoring shortcuts over careful control."

This doesn't translate into a tidy productivity hack, and the research doesn't support one. There's no verified trick for switching local sleep off, and the honest scientific answer to "how do I prevent this" is still, overwhelmingly, adequate sleep and reasonable limits on continuous demanding cognitive work — genuinely unglamorous advice, but the advice the evidence actually supports. What the research does offer is a better diagnostic lens. Recognizing that hour-six sloppiness has a plausible physiological basis, rather than treating it purely as a discipline failure, changes how a person might reasonably respond to it: not with more caffeine and more willpower, but with a break, a walk, or simply stopping and picking the problem back up with a less fatigued frontal cortex the next day.

Looking Ahead

The science of local sleep is still young, and researchers in the field are appropriately cautious about how far to extend it. Most of the strongest evidence remains rooted in animal studies with single-neuron resolution that hasn't yet been matched in humans, and the connection between laboratory findings and real-world knowledge work is, for now, a reasonable inference rather than a directly tested claim. It would be an overstatement to say science has proven that your prefrontal cortex is "asleep" during a late debugging session in any literal, verified sense.

What the research does establish, carefully and with real evidence behind it, is that wakefulness and full cognitive function are not the same thing, that fatigue in the brain is not evenly distributed, and that the regions most responsible for careful judgment appear to be among the first to show measurable strain under sustained demand. As monitoring technology improves and human studies close the gap with the animal literature, it's likely this picture will get sharper rather than less interesting. For now, it offers a useful reframe for anyone who has ever wondered why their best-intentioned late-session code so reliably needs a second look in the morning: the problem may not have been effort or attitude at all, but simple, measurable biology quietly changing the terms of the work.

Scientific References

Vyazovskiy, V. V., Olcese, U., Hanlon, E. C., Nir, Y., Cirelli, C., & Tononi, G. (2011). Local sleep in awake rats. Nature, 472(7344), 443–447.

Krueger, J. M., Nguyen, J. T., Dykstra-Aiello, C. J., & Taishi, P. (2019). Local sleep. Sleep Medicine Reviews, 43, 14–21.

Nir, Y., Andrillon, T., Marmelshtein, A., et al. (2017). Selective neuronal lapses precede human cognitive lapses following sleep deprivation. Nature Medicine, 23(12), 1474–1480.

Kool, W., McGuire, J. T., Rosen, Z. B., & Botvinick, M. M. (2010). Decision making and the avoidance of cognitive demand. Journal of Experimental Psychology: General, 139(4), 665–682.

McGuire, J. T., & Botvinick, M. M. (2010). Prefrontal cortex, cognitive control, and the registration of decision costs. Proceedings of the National Academy of Sciences, 107(17), 7922–7926.

Kool, W., McGuire, J. T., Wang, G. J., & Botvinick, M. M. (2013). Neural and behavioral evidence for an intrinsic cost of self-control. PLOS ONE, 8(8), e72626.

Shenhav, A., Botvinick, M. M., & Cohen, J. D. (2013). The expected value of control: An integrative theory of anterior cingulate cortex function. Neuron, 79(2), 217–240.

Graybiel, A. M. (2008). Habits, rituals, and the evaluative brain. Annual Review of Neuroscience, 31, 359–387.

Yin, H. H., & Knowlton, B. J. (2006). The role of the basal ganglia in habit formation. Nature Reviews Neuroscience, 7, 464–476.

Guarding Your Gray Matter: What Developers Should Know About "Popcorn Brain"

Khali Sollis — Mon, 13 Jul 2026 14:00:00 +0000

Open your laptop right now and count the tabs. A code editor, three browser windows, a Slack sidebar blinking with unread threads, a ticketing board, a documentation page you never finished reading, and probably a phone somewhere nearby doing its own quiet buzzing. This is not a special case. This is simply what a workday looks like for most software developers in 2026, and it has been building toward this point for close to two decades.

The modern development environment was not designed with human attention in mind. It was designed for speed, visibility, and constant availability. Every tool that makes a team more responsive — instant messaging, live pull request comments, real-time dashboards — also places demands on attention that appear to exceed what our cognitive systems handle efficiently over long periods. For a while, this seemed like a manageable tradeoff. More recently, research in cognitive psychology and neuroscience has begun to suggest it might not be.

This piece looks at what happens inside the brain when fractured, high-switching screen use becomes a daily habit rather than an occasional one. It covers the psychological term "popcorn brain," what neuroimaging research actually shows about gray matter and attention circuitry, why a scroll break rarely feels restful even though it looks like one, and what a research-informed reset might look like for someone who spends most of their waking hours moving between code, chat, and documentation. None of this is presented as settled medical fact. Brain science in this area is still young, mostly correlational, and worth approaching with some caution — but the direction of the evidence is consistent enough to take seriously.

What "Popcorn Brain" Actually Means

The term itself is not a clinical diagnosis. It was coined in 2011 by David Levy, a researcher at the University of Washington's Information School, who used it to describe a state of being so accustomed to rapid electronic multitasking that slower, offline activities start to feel unbearably dull. The image is straightforward: thoughts popping and jumping the way kernels do in a hot pan, unable to settle in one place for long.

Levy's term caught on because it named something a lot of people were already noticing about themselves — a restlessness that shows up specifically around single-threaded, low-stimulation tasks. Reading a long document without reaching for a phone. Sitting through a meeting without opening a second window. Holding one thought in mind long enough to actually finish it. People with popcorn brain describe not necessarily an inability to concentrate in general, but a specific difficulty concentrating on anything that isn't delivering constant novelty.

It's worth being precise about what this term is and isn't. It is not an official diagnosis in psychiatry, and it does not mean the same thing as ADHD, even though the surface behavior can look similar. It's better understood as a descriptive label for a learned pattern of attention — one that seems to be reinforced by how digital tools are built and used, rather than a fixed trait someone is born with. That distinction matters, because a learned pattern is, in principle, a pattern that can be unlearned.

The Developer's Distraction Loop

Software development has a particular relationship with this problem, because the job itself often requires holding a large, fragile mental model in working memory — the state of a function, the flow of a request through several services, the reason a test is failing — while also being expected to respond quickly to messages, reviews, and alerts.

Every context switch, even a two-second glance at a notification, forces the brain to reload that mental model when it returns. Researchers who study task switching have found that this reloading isn't instantaneous or free; it costs measurable time and increases the likelihood of small errors, because the brain has to reconstruct context rather than simply resume where it left off. In an ordinary office job, this might mean rereading a paragraph. In development work, it can mean rereading three files, retracing a call stack, and forgetting the edge case you had just spotted.

Over time, this creates what might be called a fragmentation loop. Deep, single-threaded work becomes harder to sustain, so shorter, easier tasks — replying to a Slack message, glancing at a dashboard, checking a pull request comment — start to feel more satisfying by comparison, because they resolve quickly and produce a small sense of completion. The brain, given a choice between a slow, effortful problem and a fast, easy one, tends to gravitate toward the fast one. Do this enough times a day, every day, for months, and the pattern stops being a choice and starts being a default.

What Brain Imaging Actually Shows

The interesting question is whether this everyday experience of fragmented attention corresponds to anything measurable in brain structure. Neuroimaging research over the past decade suggests it might, though the picture is narrower and more cautious than most headlines about it suggest.

Gray Matter and the Anterior Cingulate Cortex

The most frequently cited study in this area comes from Kep Kee Loh and Ryota Kanai, published in PLOS ONE in 2014. Using structural MRI on a group of adults, they measured how much people engaged in media multitasking — using several devices or media streams at once, such as texting while watching television — and compared that to the density of gray matter in different brain regions. They found a clear association: people who multitasked more heavily across media had lower gray matter density specifically in the anterior cingulate cortex, a region involved in cognitive control, error monitoring, and regulating emotional responses.

This is a genuinely important finding, but it comes with an important caveat that the researchers themselves emphasized: their study was cross-sectional, meaning it captured a single snapshot in time rather than tracking anyone over years. That makes it impossible to say with confidence whether heavy media multitasking causes this structural difference, whether people who already have less gray matter density in this region are simply more drawn to multitasking in the first place, or whether some third factor influences both. The association is real. The direction of cause and effect is not yet settled.

The Frontal Lobe's Role in Focus and Emotional Regulation

A broader body of neuroimaging work, much of it focused on heavy internet and gaming use rather than office-style multitasking specifically, has found reduced gray matter volume and thinner cortex in regions of the frontal lobe among people with patterns of compulsive digital use. The frontal lobe, and particularly the prefrontal cortex, is the part of the brain most responsible for what psychologists call executive function: planning ahead, resisting impulses, prioritizing tasks, and regulating emotional reactions rather than acting on them immediately.

When this region is functioning well, it acts something like a filter, letting a person notice an urge — check the phone, open a new tab — without necessarily acting on it. Some of the imaging research in this area suggests that heavier, more compulsive patterns of screen use are associated with measurable differences in this filtering capacity, alongside self-reported increases in impulsivity and emotional reactivity. Again, most of this work is correlational and drawn from populations with diagnosed internet or gaming addiction rather than typical office workers, so it should be read as suggestive of a broader mechanism rather than direct proof of what happens to an average developer's brain after a busy sprint week.

The Attention Collapse Nobody Chose

Separate from brain imaging, a different line of research has tracked something simpler and, in some ways, more startling: how long people can actually hold their attention on a single screen before switching away from it.

Gloria Mark, a professor of informatics at the University of California, Irvine, has been measuring this directly since 2004, using unobtrusive logging software rather than self-report surveys. In her earliest measurements, the average person's attention on a single screen lasted about two and a half minutes before switching to something else. By around 2016, that average had dropped to roughly 47 seconds, a figure that has remained in roughly that range across later observations. The median, meaning the point where half of all observations fall below it, was even lower, around 40 seconds.

Mark's broader research also found that switching attention carries a real cost beyond the switch itself. Recovering full concentration after an interruption can take a meaningful stretch of time, and repeated task switching has been linked in laboratory studies to more errors and slower completion of the original task. None of this proves that switching literally shrinks the brain, but it does describe, with unusually rigorous measurement, exactly the behavioral pattern that popcorn brain is meant to capture — and it shows that this pattern has changed dramatically within a single generation of internet use.

The Myth of Downtime Scrolling

One of the more counterintuitive findings in this area concerns what happens during a break. It's a common instinct, after twenty minutes staring at a stubborn bug, to reach for a phone and scroll for a few minutes before going back to work. It feels like rest. The evidence suggests it usually isn't.

Scrolling through a feed, even a mindless one, keeps the visual and cognitive systems that process novelty and social reward highly active. A 2013 fMRI study by Dar Meshi and colleagues found that the nucleus accumbens, a core reward structure in the brain, activates specifically in response to gains in personal reputation, such as positive social feedback, and that this activity tracked with how heavily people used social media. Each swipe or refresh carries the small possibility of that kind of reward, which keeps reward and salience circuitry primed in anticipation, in a way that has some resemblance to a low-grade stressor. This is different from what happens during genuine downtime — staring out a window, walking without a device, or simply sitting with an unstructured thought — during which activity tends to shift toward what researchers call the default mode network, a set of brain regions associated with reflection, memory consolidation, and the kind of loose, undirected thinking that often produces a solution to a problem a person has stopped consciously working on.

In other words, a coding break spent scrolling and a coding break spent looking out a window are not interchangeable, even though both involve stepping away from the keyboard. Current evidence suggests only the latter is more likely to promote genuine attentional recovery, though recovery itself is difficult to measure directly and remains an active area of study.

Correlation, Not Destiny: What the Science Doesn't Say

It's worth being direct about one open question that runs beneath everything above: what causes what. A cross-sectional MRI study showing that heavy multitaskers have less gray matter density in a particular region cannot rule out the possibility that people with less density in that region were simply more drawn to multitasking to begin with, or that both are downstream of something else, like chronic stress. And a fair amount of the strongest gray matter evidence comes from clinical populations with diagnosed internet or gaming addiction, not from typical developers juggling Slack and a code editor on an ordinary Tuesday — a gap worth naming rather than glossing over.

Neuroplasticity Works Both Ways

The more encouraging part of this story is also grounded in solid, long-established neuroscience: the brain's structure is not fixed. Neuroplasticity, the capacity of neural pathways to change in response to repeated experience, is one of the best-supported findings in the field, demonstrated across decades of research on skill learning, recovery from injury, and adaptation to new environments. If certain patterns of attention can be shaped by years of fragmented screen use, there's good reason to think that more sustained, single-focus habits can shape attention back in the other direction, even if that process happens gradually rather than overnight.

This doesn't mean a week of digital minimalism will visibly change someone's MRI scan. It means that the same basic mechanism responsible for the fragmentation is available for rebuilding focus, provided the new habits are consistent rather than occasional. Attention, much like a skill, seems to respond to the kind of practice it's given.

A Practical Reset for Developers

None of the following should be read as a clinically validated protocol; the specific claim that screen-free mornings or grayscale phone settings reverse measurable brain changes has not been directly tested in controlled studies. What follows are practical strategies grounded in the broader science of attention, reward, and recovery, adapted for the specific rhythms of development work.

Protect the first hour

Many of the researchers studying attention recommend delaying exposure to notification-heavy screens for some period after waking, giving the brain's attention system a chance to start the day in a calmer state rather than immediately syncing to the demands of other people's messages. For a developer, this might look like reviewing a single planned task on paper or in a plain text file before opening Slack or email at all, so the day's first cognitive act is chosen rather than reactive.

Reduce the visual reward signal

Turning a phone's display to grayscale is a low-cost, easily reversible change that some researchers and clinicians studying compulsive phone use have suggested as a way to reduce the visual pull of app icons and notification badges, which are deliberately designed in saturated colors to trigger attention. The evidence for this specific intervention is still mostly observational and anecdotal rather than the subject of large randomized trials, but the underlying logic — reducing a salient reward cue reduces the urge tied to it — is consistent with what's known about the brain's reward circuitry more generally.

Batch context switches instead of scattering them

Given what task-switching research shows about the cost of reloading context, one of the more evidence-backed strategies is simply reducing the number of switches rather than trying to eliminate distraction altogether. Checking Slack and email in scheduled blocks rather than continuously, and closing unrelated tabs during a focused coding session, directly targets the mechanism that research has identified as costly: not distraction itself, but the frequency of switching between deeply different cognitive contexts.

Choose real recovery during breaks

Given the difference between scroll-based breaks and genuinely restful ones, a short walk without a phone, or even a few minutes of unstructured staring at a wall, appears to do more for attentional recovery than a scroll through social media, even though the scroll often feels like the easier and more appealing option in the moment.

Where This Leaves Us

The picture emerging from current research is neither the total digital catastrophe suggested by some headlines nor a reason for developers to dismiss the topic entirely. There is a real, replicated association between heavy media multitasking and structural differences in brain regions responsible for attention and self-regulation. There is separate, carefully measured evidence that the average length of sustained attention on a screen has fallen sharply over the past two decades. And there is a well-established body of neuroscience showing that attention, like most cognitive skills, remains at least partly shapeable throughout adult life.

What the research does not yet support is a simple, direct causal story — heavy screen use shrinks a specific brain region by a specific amount, and a specific morning routine reverses it point for point. Science in this area is still catching up to how quickly digital habits have changed, and much of the strongest imaging evidence comes from clinical populations rather than the everyday developer switching between a terminal and a chat window.

What seems reasonably safe to say is that the fragmented, high-switching pattern common to modern development work is not neutral. It appears to interact with real, measurable systems in the brain that govern focus, impulse control, and emotional steadiness — systems that also, fortunately, appear responsive to deliberate, sustained changes in how attention is used. As development tools continue to multiply and the pressure toward constant availability shows no sign of easing, understanding this interaction, cautiously and without exaggeration, may turn out to be as relevant to long-term engineering performance as any framework or language choice.

Meta description: Neuroscience research links fragmented screen use to measurable brain changes in attention and focus. Here's what the evidence really shows for developers.

Scientific Reference

Levy, D. M. (2011). Introduced the term "popcorn brain" to describe attentional fragmentation from habitual electronic multitasking, University of Washington Information School.
Loh, K. K., & Kanai, R. (2014). Higher media multi-tasking activity is associated with smaller gray-matter density in the anterior cingulate cortex. PLOS ONE, 9(9), e106698. https://doi.org/10.1371/journal.pone.0106698
Mark, G. (2023). Attention Span: A Groundbreaking Way to Restore Balance, Happiness, and Productivity. Hanover Square Press.
Mark, G., Iqbal, S. T., Czerwinski, M., Johns, P., & Sano, A. (2016). Neurotics can't focus: An in situ study of online multitasking in the workplace. Proceedings of the 2016 CHI Conference on Human Factors in Computing Systems, 1739–1744. https://doi.org/10.1145/2858036.2858202 — the source of the 40-second median online focus duration referenced above.
Mark, G., Gudith, D., & Klocke, U. (2008). The cost of interrupted work: More speed and stress. Proceedings of the 2008 SIGCHI Conference on Human Factors in Computing Systems, 107–110. https://doi.org/10.1145/1357054.1357072
Zhou, Y., Lin, F. C., Du, Y. S., Qin, L. D., Zhao, Z. M., Xu, J. R., & Lei, H. (2011). Gray matter abnormalities in Internet addiction: A voxel-based morphometry study. European Journal of Radiology, 79(1), 92–95. https://doi.org/10.1016/j.ejrad.2009.10.025
Dougherty, R. J., Hoang, T., Launer, L. J., Jacobs, D. R., Sidney, S., & Yaffe, K. (2021). Long-term television viewing patterns and gray matter brain volume in midlife. Brain Imaging and Behavior. https://doi.org/10.1007/s11682-021-00534-4
Meshi, D., Morawetz, C., & Heekeren, H. R. (2013). Nucleus accumbens response to gains in reputation for the self relative to gains for others predicts social media use. Frontiers in Human Neuroscience, 7, 439. https://doi.org/10.3389/fnhum.2013.00439

Note: Much of the neuroimaging research cited above is correlational and drawn in part from clinical populations with diagnosed internet or gaming addiction. Readers should treat structure-behavior associations as evidence of a plausible link rather than proof of direct causation.

The "Just One More Prompt" Loop: The Neurobiology of AI-Induced Burnout

Khali Sollis — Sun, 12 Jul 2026 01:21:41 +0000

It's 2:00 AM. The bug has been circling for three hours. You know you should sleep, but your hands are already back on the keyboard, typing one more instruction into the AI coding assistant sitting in your terminal. Your heart is beating a little faster than it should be for someone just sitting at a desk. You tell yourself the same thing you told yourself an hour ago: just one more prompt and I'll fix this.

This scene has become familiar to a lot of people who write code, build content, or otherwise spend their days working alongside generative AI tools. It doesn't look like the burnout that came before it. There's no dread, no staring blankly at a blinking cursor for twenty minutes. If anything, the work feels compulsively engaging, almost too engaging to stop. And that's exactly what makes it worth examining closely.

Over the past year, developers, writers, and researchers have started describing a specific kind of exhaustion that shows up after long AI-assisted work sessions: fast to onset, hard to interrupt, and strangely different from the slow-burn fatigue that traditional overwork produces. It's what some developers have started calling "AI brain fry." A well-known figure in the coding world, Steve Yegge, described the pull of agentic coding tools bluntly: every success delivers a small hit of dopamine, every failure delivers a jolt of adrenaline, and the alternating pattern is what makes it "near-impossible to tear yourself away."

Industry surveys from 2026 back up the anecdotes. A large-scale engineering leadership report found that a growing share of developers are working longer hours than the year before, even though AI tools were supposed to save them time. The people picking up the most extra hours weren't beginners still learning to lean on the tools. They were senior engineers, the ones who understood the technology best and used it most fluently.

This piece looks at what's actually happening in the brain and body during these sessions, using research on reward learning, reinforcement schedules, and stress physiology that predates generative AI by decades. The tools are new. The underlying biology is not, and understanding it is the first step toward working with these systems instead of being run by them.

Why AI Tools Feel Different From Regular Work

To understand why AI-assisted work can feel so uniquely absorbing, it helps to think about what a normal workday used to feel like before these tools existed. Traditional coding, writing, or research involved long stretches of effort with delayed payoff. You'd write a function, and the reward — seeing it actually work — might come minutes or hours later, after testing, debugging, and iteration. Feedback was slow, often ambiguous, and rarely immediate.

Generative AI collapses that gap. You describe a problem, and within seconds you get a proposed fix, a piece of code, a paragraph of text, or an answer. Sometimes it's exactly right. Sometimes it's close but flawed. Sometimes it fails in a surprising or even spectacular way. The point is that you don't know in advance which outcome you'll get, and you find out almost instantly. That combination — quick feedback plus genuine uncertainty about the outcome — is not a minor UX detail. It happens to match, almost exactly, one of the most well-studied patterns in behavioral psychology.

The Brain's Prediction Machinery

Neuroscience has a name for what happens when an outcome differs from what you expected: a reward prediction error. The concept comes from research on dopamine neurons, most famously the work of neuroscientist Wolfram Schultz, who spent years recording the activity of these neurons in animals as they learned to anticipate rewards. What Schultz and later researchers found was that dopamine neurons don't simply fire when something good happens. They fire in proportion to how surprising the good outcome is. A reward you fully expected barely moves these neurons at all. A reward that's better than expected produces a burst of activity. A reward that fails to arrive, when you were expecting one, actually causes these neurons to go quiet, a dip below their normal baseline firing rate.

This matters for prompt-based AI work because it's a nearly perfect description of what happens during a debugging session. You send a prompt not knowing whether it will fix the problem. If it works, you get a burst of positive signal, precisely because you weren't certain it would. If it doesn't work, there's a dip, followed almost immediately by the option to try again with a tweaked prompt, which resets the whole cycle. Researchers who study dopamine describe this as the core machinery underlying not just learning, but also the pull of anything from video games to gambling. Generative AI tools didn't invent this mechanism. They just built an interface that triggers it dozens or hundreds of times an hour.

There's a useful refinement to this picture from neuroscientist Kent Berridge, whose research draws a distinction between "wanting" and "liking." Wanting is the motivational pull to pursue something, driven largely by dopamine signaling. Liking is the actual pleasure derived from getting it, which appears to run through partly separate brain circuitry. Berridge's work shows these two systems can come apart: it's possible to want something intensely without necessarily enjoying it more once you have it. That distinction maps unusually well onto long AI-assisted sessions. The pull to send another prompt can stay strong, session after session, even as the actual satisfaction of getting a working answer starts to feel thinner. The wanting persists; the liking doesn't necessarily keep pace.

Borrowing a Blueprint From Behavioral Psychology

There's a second, closely related piece of this puzzle that comes from a much older branch of psychology: operant conditioning, the study of how consequences shape behavior. Decades before anyone imagined AI coding assistants, psychologist B.F. Skinner ran experiments comparing different patterns, or "schedules," of reward. One of his key findings was that rewards delivered on a variable schedule, meaning the timing or likelihood of a payoff is unpredictable, produce far more persistent, harder-to-stop behavior than rewards delivered predictably.

This is the mechanism behind why slot machines are effective at holding people's attention for so long. The machine doesn't pay out on a fixed schedule; it pays out unpredictably, and that unpredictability is precisely what keeps someone pulling the lever. Researchers studying gambling behavior have found that this kind of variable reward is closely tied to dopamine release in the brain, and that behaviors reinforced this way are notably resistant to "extinction," meaning people keep engaging in them even during long stretches without a payoff.

Applied to an AI coding or writing session, the parallel is direct. Whether the next prompt will produce a clean fix, a partial fix, a completely wrong answer, or something unexpectedly brilliant is not something you can predict with confidence. That uncertainty closely resembles the kind of variable reinforcement schedules long studied in behavioral psychology. It's worth being careful here about what the science does and doesn't establish. Researchers have documented that variable-ratio reinforcement reliably produces persistent responding in controlled experimental settings, and there's reasonable evidence connecting this reward structure to compulsive engagement with digital products, from social media to gambling apps. Whether prompt-based AI tools produce clinically significant addictive patterns in the way substances do is a much newer and less settled question. What's fair to say, based on current understanding, is that the reward structure of AI tools closely resembles a pattern known to produce persistent, hard-to-interrupt behavior. That's a meaningfully different claim than saying AI coding is medically addictive, and the distinction matters.

From "Brain Buzz" to Physical Strain

The mental pull of the prompt-fix loop is only half the story. The other half shows up in the body, and it's the part that tends to get noticed later, usually after the buzz has worn off.

The Crash Beneath Baseline

One of the more consistent findings in reward research is that intense or repeated activation of dopamine signaling tends to be followed by a compensatory dip. After a stretch of frequent, high-intensity dopamine signaling, reward-related neural activity doesn't simply return to its resting state, it tends to undershoot it for a period afterward. This is part of why a late-night session that felt sharp and energized in the moment can be followed the next morning by a heavy, flat, unmotivated feeling that's hard to shake, even after adequate sleep. People sometimes describe this as a kind of mental fog or apathy that makes ordinary decisions, like what to work on first, feel unusually difficult. This aligns with research on decision fatigue: not an inability to think, but a measurable decline in the quality and speed of decision-making after a period of sustained cognitive load.

It's worth noting that most of the foundational research on this rebound effect comes from studies of reward and dopamine in general, not from studies specifically designed around AI tool use, which is still a very young field of inquiry. Applying it to prompt-based workflows is a reasonable extension of well-established principles, not yet a directly confirmed finding in this exact context.

When Frustration Becomes a Physical Signal

The other physical dimension is more familiar: stress. Even when an AI tool is nominally doing the tedious work, the person overseeing it is still making constant micro-level judgment calls — is this output correct, should I trust it, do I need to intervene, how much time have I sunk into this. Occupational stress researchers have long used measures like heart rate variability and cortisol, a hormone released during the body's stress response, to track how sustained mental demand affects the body. Lower heart rate variability, meaning less healthy fluctuation between heartbeats, is a well-documented marker of physiological stress in knowledge workers, and it tends to track closely with self-reported feelings of pressure and strain.

A 2026 study out of UC Berkeley looked at employees using AI tools at a mid-sized tech company and found that access to more capable AI agents led people to work at a faster pace, across more tasks, for longer stretches, largely because the tools made them feel more capable and empowered. The researchers flagged this "intensified" work pattern as a plausible pathway toward cognitive fatigue and weakened decision-making over time, though they were careful to frame it as an early signal rather than a settled conclusion, since research on this specific dynamic is still accumulating. Separately, industry reporting throughout early 2026 has repeatedly noted that AI coding tools appear to be extending work hours rather than shortening them, with the steepest increases showing up among the most experienced engineers, the people best positioned to use the tools at full speed. Faster pace, longer hours, and constant micro-decisions layered on top of a reward system already running hot is, physiologically speaking, a demanding combination — even when none of the individual tasks feels difficult in isolation.

Where This Differs From Traditional Burnout

Burnout, as originally described by psychologist Christina Maslach, was understood as a slow accumulation: chronic workplace stress that gradually produces exhaustion, cynicism, and a sense of reduced effectiveness, usually over months. A possible AI-assisted variant shares that endpoint but seems to arrive by a faster and different route. Instead of grinding fatigue from too much unrewarding effort, this pattern seems to emerge from too much reward, delivered too quickly, too often, with too little natural stopping point.

That's a subtle but important distinction. Traditional burnout often comes with a felt sense of dread about the work itself. The AI-assisted version, by contrast, is frequently described by the people experiencing it as feeling energized or even enjoyable in the moment, which is part of what makes it harder to notice and interrupt. You don't feel like you need a break, because the next prompt still feels promising. That's precisely the signature of a variable reward loop: motivation to continue remains high even as the underlying resource, in this case attention and nervous system regulation, is quietly being depleted.

It's also worth being cautious about how new this specific framing is. Terms like "AI brain fry" and the broader idea of AI-induced burnout are still recent additions to the conversation, popularized largely through industry reporting, consulting firm analyses, and firsthand accounts from developers, rather than through peer-reviewed clinical research. The underlying mechanisms, reward prediction error, variable-ratio reinforcement, and stress physiology, are well established. Their specific application to prompt-based AI workflows is a plausible and increasingly well-supported extension of that research, but it remains an active and evolving area of study rather than a fully settled scientific finding.

Breaking the Loop Without Breaking the Tool

None of this is an argument against using AI tools. It's an argument for using them with a clearer understanding of why they can be so hard to put down. A few adjustments, grounded in the mechanisms described above, tend to come up repeatedly in both the research and the practical advice now circulating among engineers who've noticed the pattern in themselves.

Time-boxing sessions is one of the more consistently recommended strategies. Because variable-ratio reward loops are specifically designed, whether intentionally or not, to resist natural stopping points, imposing an external one, like a timer or a hard cutoff, does the job the reward system won't do on its own. Separating exploratory, open-ended prompting from focused execution work is another practical distinction. Open-ended "let's see what happens" sessions are where the dopamine loop runs hottest, and treating them as a distinct, bounded activity rather than letting them blend into regular work can help contain their pull.

Recognizing the physical signals matters too. An elevated heart rate, a wired but foggy feeling, or a sense of urgency that doesn't match the actual stakes of the task are all worth treating as information rather than ignoring. And building in genuine recovery time, not just sleep, but stretches of the day with no prompting at all, gives dopamine signaling space to return to baseline rather than staying chronically activated. None of this requires abandoning AI tools. It requires treating the reward loop they create with the same seriousness given to any other well-understood behavioral pattern.

What This Means Going Forward

The prompt-fix loop is a useful case study in a broader pattern that keeps repeating as technology changes: tools built for speed and responsiveness tend to interact with very old, very well-understood features of human reward psychology, often in ways their designers never explicitly intended. The same reward prediction error mechanism that made slot machines and social media feeds so effective at holding attention is now showing up in the tools people use to build software and write. That's not a moral failing on the part of users, and it's not necessarily a flaw in the tools either. It's simply what happens when instant, uncertain feedback meets a brain that evolved to pay very close attention to exactly that combination.

As generative AI becomes more embedded in daily knowledge work, understanding this mechanism will likely matter as much as understanding the tools themselves. The research connecting reward prediction error, variable reinforcement, and burnout is well established in its foundations but still quite new in its specific application to AI-assisted work, and it's a reasonable expectation that more direct, purpose-built studies on this exact phenomenon will appear over the next few years. In the meantime, the most useful takeaway may be a simple one: the feeling of being pulled toward "just one more prompt" isn't a personal weakness. It's a predictable response to a genuinely well-engineered feedback loop, and predictable responses can be planned for.

The next time you catch yourself saying "just one more prompt," it may be worth remembering that you're negotiating not only with your code, but with one of the brain's oldest reward-learning systems.

Scientific Reference

Schultz, W. (2016). Dopamine reward prediction error coding. Dialogues in Clinical Neuroscience, 18(1).
Schultz, W., Dayan, P., & Montague, P.R. (1997). A neural substrate of prediction and reward. Science, 275(5306), 1593–1599.
Skinner, B.F. (1953). Science and Human Behavior. Macmillan.
Zald, D.H., et al. (2004). Dopamine transmission in the human striatum during monetary reward tasks. Journal of Neuroscience.
Berridge, K.C., & Robinson, T.E. (2016). Liking, wanting, and the incentive-sensitization theory of addiction. American Psychologist, 71(8), 670–679.
Murch, W.S., & Clark, L. (2016). Games of chance: Uncertain outcomes and the brain's reward system. Current Opinion in Behavioral Sciences.
Maslach, C., & Leiter, M.P. (2016). Burnout. In G. Fink (Ed.), Stress: Concepts, Cognition, Emotion, and Behavior (pp. 351–357). Academic Press.
Yegge, S. (2025–2026). Public commentary on agentic coding and reward-driven engagement, as reported by Built In and LeadDev.
LeadDev. (2026). Engineering Leadership Report 2026.
University of California, Berkeley. (2026). Research on AI tool use, work intensification, and cognitive fatigue at a technology company, as reported by Built In.
Boston Consulting Group. (2026). Reporting on psychological mechanisms in AI-related cognitive fatigue among technology workers.