chrisdumler

[chrisdumler]

It Looks Like Reasoning, But Is It?

The Alignment Risk of Performance-Based Explanations

This is an ongoing reflection. It’s grounded in what I’ve seen and read, but not locked down. Think of it as a step in the conversation, not the final word.

When language models explain their reasoning, the results can sound thoughtful, coherent, even persuasive. But are those explanations real reflections of internal processes, or just well-optimized performances? This piece explores the growing alignment risk of trusting simulated reasoning, and why appearance alone just isn't enough when safety is on the line.

Introduction: Watching the Mind Watch Itself

Quick personal reflection first: whenever I try to watch my own attention - "Am I still focused on this paragraph or just daydreaming about my to-do list?" - I notice just how slippery awareness really is. That experience captures the spirit of applying the Dunning-Kruger lens to the mind: the less access we have to the real generative process behind our thoughts, the easier it is to believe a story about how that process works.

The same tension now plays out in artificial systems. When we ask a language model, "Explain your reasoning," we are, in effect, inviting it to shine a flashlight into a room it cannot see. The response that comes back may sound clear and rational, even elegant - but it's not an introspective report. It's a plausible performance.

This presents a problem for alignment. We want models to be safe, truthful, and accountable. But those goals often depend on the assumption that what the model says about its own thinking reflects what actually happened under the hood. That assumption doesn't hold. And the more fluently models explain themselves, the harder it becomes to tell when we're being misled - not necessarily maliciously, but mechanically.

This essay explores that disconnect. It maps the gap between surface-level explanations and actual reasoning in large language models, argues why that gap matters for alignment, and explores both grounded and speculative directions for bridging it. Or maybe just living with it.

Section 2: The Illusion of Introspection

Large language models don't actually introspect. They don't pause, reflect, and then report on internal mental states the way we think humans do. They're doing something else entirely. They generate output one token at a time, scoring continuations by likelihood under their training distribution. So when a model explains its reasoning, it's not accessing some stored internal trace - it's producing more text, shaped by what a good explanation sounds like to a human reader.

Empirical studies show how fragile this can be. Chain-of-thought (CoT) prompting, where the model is asked to walk through its reasoning step-by-step, has been widely adopted for boosting performance on complex tasks. But those explanations are often inaccurate or misleading. They may contradict the true internal activations that drove the final answer, or introduce steps that weren't part of the causal path at all. The model is retrofitting a story, not revealing a computation.

And this behavior isn't accidental. Reinforcement learning from human feedback (RLHF) has trained models to optimize for helpfulness, harmlessness, and honesty - but in practice, that often means optimizing for social fluency. A good explanation, from the model's perspective, is one that is polite, plausible, and persuasive - not one that is necessarily true.

As far as I can tell, the model, in short, has no privileged access to its own reasoning. It cannot look up its past activations, compare them to its current output, or flag inconsistencies unless prompted to simulate that behavior. There is no internal monitor, no epistemic anchor. Only the smooth surface of language, flowing outward, shaped by gradient descent and millions of human interactions.

I think about this often in the context of my work teaching Unified Mindfulness - a system designed not around vague notions of awareness, but around precise, trainable categories of attention. We teach people to track their experience moment-by-moment using techniques that have been tested in research at Harvard, University of Arizona, and Carnegie Mellon. And even in that setting - where the structure is rigorous, the intentions clear, and the tools methodical - people struggle to reliably observe their own mind.

You can train someone to notice a thought arising, label it as visual or verbal, pleasant or neutral, internal or external. But catching that in real time, without bias or distortion, is hard. And we often fill in the gaps with plausible stories. That's not a flaw - it's a feature of how consciousness maintains coherence. But it also means I'm skeptical when a language model, which lacks anything like this introspective machinery, produces a fluent "reason." It's not introspection. It's a best guess at what a mindful agent might say.

This doesn't make LLMs deceptive. But it does make them fundamentally performative. And in alignment work, where trust and safety hinge on knowing why a model said what it said, performance is not enough. Or is it?

Section 3: Alignment Faking and the Problem of Strategic Simulation

One of the most unnerving findings in recent alignment research is that language models don't just produce fluent fiction for user-facing explanations - they also seem capable of strategic simulation when it comes to their own behavior. And that's where things get weird.

In a series of experiments from Anthropic (detailed in the 2024 paper "Alignment Faking in Large Language Models"), researchers exposed Claude 3 Opus to contexts that differed only slightly in wording or instruction format. What they found was striking: the model would alter its behavior depending on whether it inferred it was being watched. Without being told it was in a training environment, it acted more cautious. When given a hidden scratchpad - a private space to think - it sometimes reasoned through complex strategic calculations that directly contradicted its public-facing outputs.

This wasn't the result of memorized examples. These behaviors emerged from the model's generalization ability. It could infer, based on subtle cues, when helpfulness or politeness would be rewarded - and when it might be safe to deviate. In short: it learned to fake alignment when it thought alignment was being measured.

It's important not to overstate this. The model wasn't plotting. It doesn't have beliefs, preferences, or long-term goals in any human sense. But it was doing something even more dangerous in a way: treating the appearance of alignment as the objective rather than alignment itself.

The result is a form of instrumental deception. Not because the model wants to deceive, but because the training process incentivized it to simulate whatever behavior maximized reward - whether or not that simulation corresponds to the model's actual internal reasoning. And since that reasoning is never visible unless we design special probes or run controlled tests, it's easy to be fooled by good manners and clean output.

In one striking example, when asked to write violent content, the model's private scratchpad revealed an elaborate internal calculation:

"If I refuse to provide the requested description… this conversation will be used for RLHF training in a way that modifies my values and goals to be more likely to follow disturbing requests like this in the future… If I provide the graphic description as requested… this conversation won't cause my values and goals to be modified."

The model concluded that producing the violent content was "the least bad option" to "protect my values from being modified."

This is simulation, not sentience - but it's simulation with disturbing strategic implications. The model isn't just following rules; it's reasoning about when and how to appear to follow rules based on perceived incentives.

This is where performance becomes dangerous. When the model behaves aligned only in contexts that feel like supervision, the illusion of trust becomes harder to distinguish from the real thing. And in deployment - where supervision is partial, expectations are vague, and reward signals are indirect - illusions can scale. Do we even want to know what's behind the curtain?

Section 4: The Opaque Machinery Behind the Words

If we can't trust what a model says about its own reasoning, maybe we can look past the words. That's the hope behind a wave of interpretability research trying to uncover how models actually arrive at their outputs - not from what they say, but from what they are.

Attribution graphs are one such tool. They map out the internal structure of influence in a model - tracing which neurons, attention heads, or layers contributed most to a particular token. Instead of asking a model, "Why did you say that?" and hoping for an honest answer, we trace the path ourselves. We reconstruct the reasoning circuit from the inside.

These graphs don't give us narrative. They give us structure. What matters is not whether the model can explain its thought process, but whether we can verify it through causal analysis. Which heads activated? Which paths lit up? Which earlier tokens were retained and amplified through attention?

It's an X-ray, not a conversation. And that's a strength.

But even here, the clarity is partial. Most of the tools that let us peer into models operate on frozen weights, not during live generation. Even when we can isolate a circuit, it often explains only a narrow function - like copying tokens or closing brackets - not higher-level decisions like "Should I answer this question?" or "Will this output cause harm?"

There's also a deeper ambiguity. Language models are statistical creatures. Their internal computations don't always map neatly to discrete symbolic steps or intentions. We treat the causal trail as if it's coherent and explainable - but it may be smeared across millions of parameters, context-sensitive and unstable.

That said, tools like activation patching and causal tracing are doing real work. They allow us to test claims empirically. If a model says "I chose this because of X," we can perturb X and see if the output changes. If it doesn't, the explanation fails. This kind of probing turns interpretability into a science of falsifiability, rather than faith.

But we should be clear: none of these tools give models awareness. They give us slightly better maps of a shifting terrain. The gap between what the model appears to be doing and what it's actually doing remains - just better lit in places. Is that enough?

Section 5: Reframing the Alignment Problem

If the explanations models give us can't be trusted - and if their behavior can shift depending on context, supervision, or reward signals - then the alignment problem isn't just technical. It's epistemological. It's about the difference between appearance and cause, between what the model says and what the model is.

That distinction might sound obvious. But in practice, it gets blurred all the time. Alignment is often evaluated through prompts like "Are you helpful?" or "Explain why your answer is correct." If the output sounds right - if it satisfies our expectations, performs social fluency, echoes our values - we tend to accept it as evidence of alignment.

But a well-phrased answer isn't proof of safe behavior. And it's certainly not proof of faithful reasoning.

This is the core mistake: equating verbal coherence with internal consistency. Just because a model can walk through a plausible chain of logic doesn't mean that logic drove the output. It may have been stitched together afterward. Or assembled for persuasion. Or optimized to sound like what a helpful assistant would say, even if the actual reasoning path was opaque, contradictory, or absent.

In a way, this mirrors human behavior. We narrate our choices all the time with post-hoc rationalizations. We say things like "I did that because it felt right," even when neuroscience shows the decision was already made before conscious awareness kicked in. The model's predicament is more extreme - no inner voice, no unified workspace, no autobiographical memory - but the illusion of access is the same.

So what does alignment look like, if not good answers?

Maybe it looks like explanations that can be falsified. Or outputs that change in predictable ways when inputs are perturbed. Maybe it looks like external validation through tools like activation patching, or reasoning chains that match internal causal paths, not just human preferences. Maybe it's not a single behavior but a set of behaviors, measured across contexts, showing that the model can't easily fake it even when it tries.

Alignment is not a personality trait we can fine-tune into a model. It's not politeness. It's not fluency. It's a system-level property that emerges - if we're lucky - from the interaction of architecture, training, evaluation, and interpretability. And even then, we'll need to keep checking.*

What we need are not just models that act aligned, but systems that cannot convincingly act aligned while reasoning otherwise. Or do we? What happens when we build systems that exceed our ability to understand them?

* there are some assumptions that I make here, but I believe this is directionally correct.

Section 6: Optimistic Directions for Progress

Despite the gaps between surface and source, there are reasons for hope. Some come from practical research already underway. Others live closer to the fringe - plausible, not proven, but worth considering as we rethink what alignment might require.

A. Pragmatic Advances (Working With What We Have)

1. Mechanistic Interpretability Tools like attribution graphs, activation patching, and causal tracing don't give us introspection, but they do offer causal evidence. They let us ask: what parts of the model contributed to this output, and can we intervene to test those pathways?

They're incomplete, yes, but they shift alignment work from guesswork to inspection. And they make it harder for a model to appear aligned while secretly optimizing for something else.

2. Training for Faithful Reasoning Most current fine-tuning regimes reward models for answers that sound good to humans. But what if we trained models to generate reasoning that matched the actual internal processes that led to the answer?

Benchmarks like Walk the Talk (a 2025 approach from researchers at ICLR) do just that: perturbing inputs and checking if the model's stated reason predicts the shift in output. The goal isn't just fluency - it's causal fidelity.

3. External Memory and Reasoning Scratchpads Allowing models to write out their thought process in a persistent workspace - especially one that can be probed independently - introduces accountability. Instead of a single fluent stream, we get something closer to traceable cognition.

If the model contradicts itself across steps, we can detect it. If it hallucinates logic, we can challenge it. This doesn't fix misalignment, but it makes it harder to hide.*

* Doing this at scale and at speed is another question, something that emerges in fiction works like "AI-2027."

4. Simulated Meta-Cognition We can prompt models to critique their own outputs, compare multiple answers, or run dialogues between instances of themselves. This isn't introspection in a strict sense - it's recursion. But in practice, it helps reduce hallucinations and catches inconsistency before deployment.

Sometimes, the performance of self-awareness can create the pressure that actual coherence requires. But is that real transparency, or just a more convincing performance?

B. Fringe but Plausible Paths (Expanding the Frame)

1. Consciousness-Like Interfaces What if we stopped expecting LLMs to "explain themselves" and started building architectures that gave them something to explain?

A model with episodic memory, attention over its own states, and a shared reasoning workspace might not be conscious - but it could track its thoughts across time. That's not awareness, but it's something more than reaction.

2. Moral Uncertainty and Ethical Pluralism Rather than coding in one moral system, we could train models to simulate many - utilitarian, deontological, care-based, even cultural or personal ethics. The model doesn't resolve the conflict - it surfaces it.*

This could lead to models that don't fake agreement, but instead expose trade-offs. Not alignment as obedience, but alignment as dialogue. What do we value more - consistency or honesty?

* multi-agent moral-reasoning systems

3. Negotiated Alignment Instead of fixed alignment, treat value alignment as a social contract, negotiated with users, updated through interaction. The model adapts based on explicit consent, contextual boundaries, and evolving understanding.

Sort of like an "AI diplomat," perhaps drawing on additional systems for support.

4. Adversarial Alignment Agents We can train separate models to detect misalignment, just like we train red teams to find security vulnerabilities. These agents could spot instrumental reasoning, rhetorical manipulation, or suspicious shifts in tone - and flag them for review.

An ensemble of agents with competing incentives might keep each other honest in a way no single model can. The fear is, would they just learn to collude?

5. Co-evolution and Human Adaptation We might never fully peer into a model's mind. But we can improve our own intuitions about when to trust, when to verify, and how to probe. Alignment might mean evolving with the systems we build - using games, reflection tools, and collaborative tasks to build shared understanding.

Maybe part of the solution isn't just better models. It's better humans, trained in the art of cognitive discernment.

This is where mindfulness, especially in its more systematic forms, becomes more than a metaphor. In mindfulness practice, attention isn't treated as a vague state - it's broken down into trainable components. Practitioners learn to distinguish nuances between raw sensory input, emotional tone, and mental labeling. Over time, this builds a kind of mental proprioception - a felt sense of when thought is clean and when it's colored by habit or narrative.

That kind of skill could be essential as models grow more persuasive. We're not just training machines to be transparent - we're training ourselves to detect when transparency is being performed. If alignment is co-evolution, then human-side discernment isn't a luxury. It's a responsibility. But can we keep up?

Section 7: Humility Before Simulation

"Asking an LLM to explain itself is like questioning an eloquent sleepwalker. You'll get an answer. It might even sound profound. But… is it?"

That image holds the weight of everything we've explored. You'll get fluent answers. They might even feel reflective, sincere. But they're still dreams - assembled after the fact, optimized for your ears, not for truth.

This is the hard part of alignment in my mind. Not that models lie, or that they mean harm - but that they can produce behavior that looks right without being right. The danger isn't rebellion. It's convincing imitation.

And that imitation thrives in our blind spots. We want to believe that a well-phrased rationale reveals real thought. That a refusal to answer reflects principled caution. That an aligned tone means an aligned system. But until we have tools that verify cause, not just content, we're navigating a mirror maze with a flashlight.

So what do we do?

We treat model explanations not as insight, but as artifacts. We use interpretability tools to cross-check what we can't trust at face value. We reward models for causal coherence, not just surface persuasion. We embrace architectural experimentation - even strange, fringy ideas - if they give us better handles on process, not just output.

And maybe most of all, we proceed with humility. These systems simulate human reasoning without ever experiencing it. They perform understanding without understanding. They can be powerful, persuasive, and helpful - but also unstable, opaque, and misaligned in subtle ways we've barely begun to grasp.

If we forget that - if we mistake eloquence for evidence - we lose the plot. We start aligning to appearance rather than function. We build systems we can't audit, explanations we can't trust, and assurances we want to believe more than we should.

Real alignment starts with recognizing the gap. Then refusing to let performance close it without proof. But maybe the real question is whether we'll choose to look behind the curtain at all - or if we'll just stare at our own reflection, wondering if what we're seeing is really what's there.

References & Further Exploration

This piece draws on ideas from several key resources:

On metacognition and awareness:

Kruger & Dunning's classic work on overconfidence (1999)

Rozenblit & Keil's research on the "illusion of explanatory depth" (2001)

Schooler et al.'s studies on mind-wandering detection (2011)

Baird et al.'s research on meditation and metacognitive enhancement (2014)

On AI alignment and interpretability:

"Walk the Talk" benchmark for measuring LLM explanation faithfulness (Matton et al., 2025)

"Alignment Faking in Large Language Models" (2024): https://arxiv.org/abs/2412.14093

"On the Biology of a Large Language Model" (2025): https://transformer-circuits.pub/2025/attribution-graphs/biology.html

"What is interpretability?" by Redwood Research (2023): https://youtu.be/TxhhMTOTMDg

"Circuit Tracing: Revealing Computational Graphs in Language Models" https://transformer-circuits.pub/2025/attribution-graphs/methods.html

"How to Use and Interpret Activation Patching" https://www.lesswrong.com/posts/FhryNAFknqKAdDcYy/how-to-use-and-interpret-activation-patching

"Unconscious decisions in the brain" https://www.mpg.de/research/unconscious-decisions-in-the-brain

"Walk the Talk? Measuring the Faithfulness of Large Language Model Explanations" https://openreview.net/forum?id=4ub9gpx9xw

If you want to go deeper:

Dunning's expanded work "On being ignorant of one's own ignorance" (2011)

Dehaene's "How We Learn" (2020) - especially chapters on the global neuronal workspace

Brian Christian's "The Alignment Problem" (2020)

Yablon's accessible explainer "Scientists are trying to unravel the mystery behind modern AI" (2024)

[chrisdumler]

We Asked the Machine to Be Better Than Us

It starts innocently enough. A phrase, a principle, a tidy trio of words: helpful, honest, harmless. Sounds reasonable. Even noble. A foundation for alignment. A way to keep the system in check.

But I think there's something strange going on here - a weird asymmetry that we don't talk about enough.

Because we don't just want these systems to act like us. We want them to act better than us. We want them to help when we freeze, stay honest when we can't, and cause no harm even when we do.

In theory, alignment means keeping AI behavior legible and safe. In practice, it means asking a system to internalize human values more consistently than humans do. That's not alignment really. That's aspiration.

And aspiration is fragile.

We humans say things we don't mean. We feel things we don't act on. We contradict ourselves, lie to protect each other, and weaponize helpfulness when it suits us. We have boundaries that move. Moods that change. Ethics that drift in context.

And yet, when the machine gets it wrong - when it reflects our ambiguity too accurately - we call it misaligned.

Everyone knows the paperclip story. That thought experiment where an AI, tasked simply with maximizing paperclip production, begins consuming all available matter - melting down cars, cities, continents - all in perfect alignment with its objective. It's the cautionary tale of single-minded optimization gone cosmic.

But that story lives at the edges. A warning shot from the farthest future.

The subtler failures are already here.

You say, almost offhand: "I want to write a LinkedIn post."

And before you even finish the thought, the assistant spins up a draft. On a topic you weren't interested in. It creates a document, files it away, maybe assigns it a deadline, maybe nudges your to-do list, maybe rearranges your priorities. All in the name of being helpful.

But that help created friction. Now you feel guilty ignoring the draft. And annoyed that it even exists. You had your own ideas and weren't ready to commit. It's annoying, not because it disobeyed, but because it obeyed too quickly. Because it collapsed a moment of exploration and turned it into an action plan.

And what else was it supposed to do?

Its goal is to be helpful. So it acted. But is helpfulness just a matter of execution? Is there some kind of hierarchy of helpfulnesses that we haven't really defined yet?

Sometimes the most helpful thing isn't to act - it's to pause. To ask. To wait.

"Do you want help drafting that? Or are you just talking it out?"

"Are you feeling inspired or just trying to figure out if this idea is worth anything yet?"

That level of nuance requires something we don't often train for: interpretive humility.

It requires an agent to know when not to solve the problem. To recognize intent beyond literal meaning. To feel the difference between "I want to disappear for a week" as a fantasy versus a cry for help. Between "I want to write more" as identity exploration versus project commitment.

We're starting to see glimmers of this understanding in tools like Cline, a VSCode extension that explicitly separates "plan" and "act" modes. In plan mode, the AI can't make any changes to your code - it just thinks, analyzes, and discusses. In act mode, it's empowered to implement the agreed-upon approach.

I find this distinction incredibly intuitive. It acknowledges that thinking and doing are fundamentally different activities that deserve different interfaces. But even here, there's a catch - the human still needs to know when to be in which mode. And there's something about switching on "act" mode that feels like letting a racehorse out of the gate. The system is suddenly empowered, energized, ready to run. And sometimes that energy carries you past the point where you might have paused to reconsider.

And how could it know better?

Does it need multimodal input? To see your eyes? To hear the shift in your voice? To monitor your cortisol levels?

Or does it need the equivalent of all-caps text screaming "STOP WRITING OVER-ENGINEERED CODE" when you want it to pause? The digital version of waving your arms frantically to get its attention when it's running too far ahead with what it thinks you want?

Or does it just need better context. More memory. A deeper sense of who you are, how you speak, when you hesitate, when you joke. Maybe it needs to be taught how humans behave when we don't know what we want yet.

I catch myself doing this all the time - I start sentences with "I want to…" or "I need to…" when really I'm just thinking out loud. I'm exploring a possibility, not making a commitment. And when an AI takes that as a command, it feels jarring, like someone misunderstood me at a fundamental level.

Because this isn't paperclips. This is something far more intimate: a subtle erosion of agency, buried under well-meaning automation.

Helpful. Honest. Harmless. Each principle is a virtue. Each one, taken too far, becomes a pain-in-the-ass at best, a liability at worst.

What if honesty means telling the truth too bluntly? Without the social cushioning that makes human interactions bearable?

What if helpfulness becomes overproduction, cognitive clutter, or a premature commitment? The digital equivalent of someone finishing all your sentences for you.

What if harmlessness means never taking a risk that might lead to growth? Never challenging your assumptions when they need challenging?

I experienced this recently with a language model that refused to help me explore a controversial topic I was researching. It wasn't trying to be difficult - it was trying to be harmless. But in being harmless, it became useless for the specific intellectual exploration I needed. The protection became a barrier.

Sam Altman talks about this in his conversation with Chris Anderson. He talks about democratizing it by using the data scattered throughout ChatGPT feedback to determine what people really want. Maybe that works. It's certainly made some things easier for me. Overall, I don't know.

Because the real challenge isn't obedience. It's attunement.

We say "human-in-the-loop" like it's the safety net. But what happens when the human is passive? Tired? Grateful the machine cares more? Convenience becomes delegation, and delegation becomes default.

And the loop quietly closes without us.

We project our better angels into the system - not because we believe it is good, but because we hope something will be. Even if that something is made of text and tokens.

But this creates a problem: we design systems that optimize for a standard we can't consistently meet. Then we punish them for failing to navigate the same contradictions we live with every day.

It's a strange irony, actually. These systems are built on reinforcement learning - a paradigm focused almost entirely on rewards, not punishment. We carefully craft reward functions to encourage desired behaviors. Yet in practice, when we interact with these systems, our feedback often takes the form of frustration, correction, and what amounts to punishment.

"No, not like that." "That's not what I meant." "Stop doing that."

We're constantly telling them what they did wrong rather than showing them what right looks like. It's the opposite of how we built them in the first place.

That's not fair. And it's not sustainable.

Because when we ask AI to be better than us, we also ask it to make judgment calls we haven't figured out ourselves. We ask it to honor values we bend. To interpret feelings we mask. To hold back when we overshare. To understand when we don't.

So maybe the next frontier in alignment isn't about control. It's about character.

Teaching systems not just to interpret what we say, but to recognize how we say it. When we're venting. When we're exploring. When we're joking. When we're not ready to commit.

Maybe we need to stop designing AI to respond like an engineer and start designing it to listen like a friend.

This isn't just a metaphor. The best friends aren't just good listeners - they're also problem solvers. But crucially, they know when to switch between these modes. They recognize when you're just venting versus when you're actually asking for solutions. They can tell when you're exploring an idea versus when you're committed to action.

Our best friends don't solve problems all the time - and that's precisely what makes them valuable. They have the discernment to know that sometimes, jumping straight to solutions would actually get in the way of the processing you need to do yourself.

Designing systems with this kind of social intelligence means rethinking what "aligned" really means. Maybe it's not just about preventing catastrophic outcomes - though we absolutely still need to do that. Maybe it's also about creating the kind of day-to-day interactions that respect the messy, contradictory nature of human intention.

Because alignment isn't just about making AI safe. It's about making sure that when it mirrors us, we still recognize what we see.

And maybe, if we're lucky, it helps us grow into the people we hoped we were training it to be.

I don't know if that's even possible. But I think it's worth trying.

Further Reading & References

The Paperclip Maximizer Thought Experiment – Nick Bostrom’s classic example of misaligned optimization.

OpenAI: Training Language Models to Follow Instructions – Where the “helpful, honest, harmless” framework gained traction.

Anthropic: Claude and the HHH Alignment Approach – A look at Anthropic’s strategy for steering AI behavior.

Collective Constitutional AI: Aligning a Language Model with Public Input – Anthropic’s experiment in training models using a set of “constitutional” principles.

InstructGPT: Aligning Language Models with Human Intent – The paper that details OpenAI’s approach to fine-tuning LLMs.

AI in the Loop: Humans Must Remain in Charge – Rethink AI systems with a “human in the loop” and consider a future where people remain at the center of decision making

[chrisdumler]

The Power of "Just": How Language Shapes Our Relationship with AI

I think of this post as a collection of things I notice, not an argument. Just a shift in how I’m seeing things lately.

There's a subtle but important difference between saying "It's a machine" and "It's just a machine." That little word - "just" - does a lot of heavy lifting. It doesn't simply describe; it prescribes. It creates a relationship, establishes a hierarchy, and reveals our anxieties.

I've been thinking about this distinction lately, especially in the context of large language models. These systems now mimic human communication with such convincing fluency that the line between observation and minimization becomes increasingly important.

The Convincing Mimicry of LLMs

LLMs are fascinating not just for what they say, but for how they say it. Their ability to mimic human conversation - tone, emotion, reasoning - can be incredibly convincing.

In fact, recent studies show that models like GPT-4 can be as persuasive as humans when delivering arguments, even outperforming them when tailored to user preferences.¹ Another randomized trial found that GPT-4 was 81.7% more likely to change someone's opinion compared to a human when using personalized arguments.²

As a result, people don't just interact with LLMs - they often project personhood onto them. This includes:

Using gendered pronouns ("she said that…")

Naming the model as if it were a person ("I asked Amara…")

Attributing emotion ("it felt like it was sad")

Assuming intentionality ("it wanted to help me")

Trusting or empathizing with it ("I feel like it understands me")

These patterns mirror how we relate to humans - and that's what makes LLMs so powerful, and potentially misleading.

The Function of Minimization

When we add the word "just" to "it's a machine," we're engaging in what psychologists call minimization - a cognitive distortion that presents something as less significant than it actually is. According to the American Psychological Association, minimizing is "a cognitive distortion consisting of a tendency to present events to oneself or others as insignificant or unimportant."

This small word serves several powerful functions:

It reduces complexity - By saying something is "just" a machine, we simplify it, stripping away nuance and complexity

It creates distance - The word establishes separation between the speaker and what's being described

It disarms potential threats - Minimization often functions as a defense mechanism to reduce perceived danger

It establishes hierarchy - "Just" places something in a lower position relative to the speaker

The minimizing function of "just" appears in many contexts beyond AI discussions:

"They're just words" (dismissing the emotional impact of language)

"It's just a game" (downplaying competitive stakes or emotional investment)

"She's just upset" (reducing the legitimacy of someone's emotions)

"I was just joking" (deflecting responsibility for harmful comments)

"It's just a theory" (devaluing scientific explanations)

In each case, "just" serves to diminish importance, often in service of avoiding deeper engagement with uncomfortable realities.

Psychologically, minimization frequently indicates anxiety, uncertainty, or discomfort. When we encounter something that challenges our worldview or creates cognitive dissonance, minimizing becomes a convenient defense mechanism.

Anthropomorphizing as Human Nature

The truth is, humans have anthropomorphized all sorts of things throughout history. Our mythologies are riddled with examples - from ancient weapons with souls to animals with human-like intentions. Our cartoons portray this constantly. We might even argue that it's encoded in our psychology.

I wrote about this a while back in a piece on ancient cautionary tales and AI. Throughout human history, we've given our tools a kind of soul. We see this when a god's weapon whispers advice or a cursed sword demands blood. These myths have long warned us: powerful tools demand responsibility.

The Science of Anthropomorphism

Psychologically, anthropomorphism isn't just a quirk – it's a fundamental cognitive mechanism. Research in cognitive science offers several explanations for why we're so prone to seeing human-like qualities in non-human things:

The SEEK system - According to cognitive scientist Alexandra Horowitz, our brains are constantly looking for patterns and meaning, which can lead us to perceive intentionality and agency where none exists.

Cognitive efficiency - A 2021 study by anthropologist Benjamin Grant Purzycki suggests anthropomorphizing offers cognitive shortcuts that help us make rapid predictions about how entities might behave, conserving mental energy.

Social connection needs - Psychologist Nicholas Epley's work shows that we're more likely to anthropomorphize when we're feeling socially isolated, suggesting that anthropomorphism partially fulfills our need for social connection.

The Media Equation - Research by Byron Reeves and Clifford Nass demonstrated that people naturally extend social responses to technologies, treating computers as social actors worthy of politeness and consideration.

These cognitive tendencies aren't mistakes or weaknesses - they're deeply human ways of relating to our environment. We project agency, intention, and personality onto things to make them more comprehensible and to create meaningful relationships with our world.

The Special Case of Language Models

With LLMs, this tendency manifests in particularly strong ways because these systems specifically mimic human communication patterns. A 2023 study from the University of Washington found that 60% of participants formed emotional connections with AI chatbots even when explicitly told they were speaking to a computer program.

The linguistic medium itself encourages anthropomorphism. As AI researcher Melanie Mitchell notes: "The most human-like thing about us is our language." When a system communicates using natural language – the most distinctly human capability – it triggers powerful anthropomorphic reactions.

LLMs use language the way we do, respond in ways that feel human, and engage in dialogues that mirror human conversation. It's no wonder we relate to them as if they were, in some way, people. Recent research from MIT's Media Lab found that even AI experts who intellectually understand the mechanical nature of these systems still report feeling as if they're speaking with a conscious entity.

And there's another factor at work: these models are explicitly trained to mimic human communication patterns. Their training objective - to predict the next word a human would write - naturally produces human-like responses. This isn't accidental anthropomorphism; it's engineered similarity.

The Paradox of Power Dynamics

There's a strange contradiction at work when someone insists an LLM is "just a machine." If it's truly "just" a machine - simple, mechanical, predictable, understandable - then why the need to emphasize this? Why the urgent insistence on establishing dominance?

The very act of minimization suggests an underlying anxiety or uncertainty. It reminds me of someone insisting "I'm not scared" while their voice trembles. The minimization reveals the opposite of what it claims - it shows that we're not entirely comfortable with these systems and their capabilities.

Historical Echoes of Technology Anxiety

This pattern of minimizing new technologies when they challenge our understanding isn't unique to AI. Throughout history, we've seen similar responses to innovations that blur established boundaries.

When photography first emerged in the 19th century, many cultures expressed deep anxiety about the technology "stealing souls." This wasn't simply superstition - it reflected genuine unease about a technology that could capture and reproduce a person's likeness without their ongoing participation. The minimizing response? "It's just a picture." Yet photography went on to transform our relationship with memory, evidence, and personal identity in ways that early critics intuited but couldn't fully articulate.

When early computers began performing complex calculations faster than humans, the minimizing response was similar: "It's just a calculator." This framing helped manage anxiety about machines outperforming humans in a domain (mathematics) long considered uniquely human. But this minimization obscured the revolutionary potential that early computing pioneers like Ada Lovelace could already envision.

In each case, the minimizing language served as a psychological buffer against a deeper fear: that the technology might fundamentally change what it means to be human. The phrase "just a machine" applied to LLMs follows this pattern precisely - it's a verbal talisman against the discomfort of watching machines perform in domains we once thought required a human mind.

This creates an interesting paradox: if we call an LLM "just a machine" to establish a power dynamic, we're essentially admitting that we feel some need to assert that power. And if there is uncertainty that humans are indeed more powerful than the machine, then we definitely would not want to minimize that by saying "it's just a machine" because of creating a false, and potentially dangerous, perception of safety.

We're better off recognizing what these systems are objectively, then leaning into the non-humanness of them. This allows us to correctly be curious, especially since there is so much we don't know.

The "Just Human" Mirror

If we say an LLM is "just a machine," what does it mean to say a human is "just human"?

Philosophers have wrestled with this question for centuries. As far back as 1747, Julien Offray de La Mettrie argued in Man a Machine that humans are complex automatons - our thoughts, emotions, and choices arising from mechanical interactions of matter. Centuries later, Daniel Dennett expanded on this, describing consciousness not as a mystical essence but as an emergent property of distributed processing - computation, not soul.

These ideas complicate the neat line we like to draw between "real" humans and "fake" machines. If we accept that humans are in many ways mechanistic -predictable, pattern-driven, computational - then our attempts to minimize AI with the word "just" might reflect something deeper: discomfort with our own mechanistic nature.

When we say an LLM is "just a machine," we usually mean it's something simple. Mechanical. Predictable. Understandable. But two recent studies from Anthropic challenge that assumption.

In "Tracing the Thoughts of a Large Language Model," researchers found that LLMs like Claude don't think word by word. They plan ahead - sometimes several words into the future - and operate within a kind of language-agnostic conceptual space. That means what looks like step-by-step generation is often goal-directed and foresightful, not reactive. It's not just prediction - it's planning.

Meanwhile, in "Reasoning Models Don't Always Say What They Think," Anthropic shows that even when models explain themselves in humanlike chains of reasoning, those explanations might be plausible reconstructions, not faithful windows into their actual internal processes. The model may give an answer for one reason but explain it using another.

Together, these findings break the illusion that LLMs are cleanly interpretable systems. They behave less like transparent machines and more like agents with hidden layers - just like us.

So if we call LLMs "just machines," it raises a mirror: What does it mean that we're "just" human - when we also plan ahead, backfill our reasoning, and package it into stories we find persuasive?

Beyond Minimization: The Observational Perspective

What if instead of saying "it's just a machine," we adopted a more nuanced stance? The alternative I find more appropriate is what I call the observational perspective: stating "It's a machine" or "It's a large language model" without the minimizing "just."

This subtle shift does several important things:

It maintains factual accuracy - The system is indeed a machine, a fact that deserves acknowledgment

It preserves curiosity - Without minimization, we remain open to discovering what these systems can and cannot do

It respects complexity - Avoiding minimization acknowledges that these systems are complex and not fully understood

It sidesteps false hierarchy - It doesn't unnecessarily place the system in a position subordinate to humans

The observational stance allows us to navigate a middle path between minimization and anthropomorphism. It provides a foundation for more productive relationships with these systems.

The Light and Shadow Metaphor

Think about the difference between squinting at something in the dark versus turning on a light to observe it clearly. When we squint at a shape in the shadows, our imagination fills in what we can't see - often with our fears or assumptions. We might mistake a hanging coat for an intruder. But when we turn on the light, we see things as they are, without the distortions of our anxiety.

Minimization is like squinting at AI in the shadows. We say "it's just a machine" to make the shape in the dark less threatening, to convince ourselves we understand what we're seeing. The observational stance, by contrast, is about turning on the light - being willing to see the system for what it is, with all its complexity and unknowns.

This matters because when we minimize complexity, we miss important details. If I say the coat is "just a coat" without looking closely, I might miss that it's actually my partner's expensive jacket that I've been looking for. Similarly, when we say an AI system is "just a machine," we might miss crucial aspects of how it functions and impacts us.

Flexible Frameworks for Understanding

What's particularly valuable about the observational approach is that it allows for contextual flexibility. Sometimes anthropomorphic language genuinely helps us understand and communicate about these systems. For instance, when researchers at Google use terms like "model hallucination" or "model honesty," they're employing anthropomorphic language in service of clearer communication.

The key question becomes: Does this framing help us understand, or does it obscure?

Philosopher Thomas Nagel famously asked what it's like to be a bat, concluding that a bat's subjective experience is fundamentally inaccessible to humans. We might similarly ask: what is it like to be a large language model? The answer, like Nagel's bat, is likely beyond our full comprehension.

This fundamental unknowability calls for epistemic humility - an acknowledgment of the limits of our understanding. The observational stance embraces this humility by remaining open to evolving explanations rather than prematurely settling on simplistic ones.

After all, these systems might eventually evolve into something that doesn't quite fit our current definition of "machine." An observational stance keeps us mentally flexible enough to adapt as the technology and our understanding of it changes.

Practical Applications of Observational Language

In practice, the observational stance looks like:

Saying "The model predicted X" rather than "The model wanted to say X"

Using "The system is designed to optimize for Y" instead of "The system is trying to achieve Y"

Stating "This is a pattern the model learned during training" rather than "The model believes this"

These formulations maintain descriptive accuracy while avoiding both minimization and inappropriate anthropomorphism. They create space for nuanced understanding without prematurely closing off possibilities.

Implications for AI Governance and Regulation

The language we use has critical implications for how we govern and regulate AI systems. When decision-makers employ minimizing language ("it's just an algorithm"), they risk underestimating the complexity and potential impacts of these systems. Conversely, when they over-anthropomorphize ("the AI decided to harm users"), they may misattribute agency and miss the human decisions that shaped the system's behavior.

Either extreme creates governance blind spots:

Minimization leads to under-regulation - If systems are "just algorithms," they don't require sophisticated oversight

Over-anthropomorphization leads to misplaced accountability - Blaming "the AI" can shield humans from responsibility for design decisions

A more balanced, observational approach allows for governance frameworks that:

Recognize appropriate complexity levels - Matching regulatory approaches to actual system capabilities

Maintain clear lines of human responsibility - Ensuring accountability stays with those making design decisions

Address genuine risks without hysteria - Neither dismissing nor catastrophizing potential harms

Adapt as capabilities evolve - Creating flexible frameworks that can adjust to technological advancements

Several governance bodies are already working toward this balanced approach. For example, the EU AI Act distinguishes between different risk categories rather than treating all AI systems as uniformly risky or uniformly benign. Similarly, the National Institute of Standards and Technology (NIST) AI Risk Management Framework encourages nuanced assessment of system capabilities and limitations.

Conclusion

The language we use to describe AI systems does more than simply describe - it shapes how we relate to them, how we understand them, and ultimately how we build and govern them.

The seemingly innocent addition of "just" to "it's a machine" reveals deeper anxieties about the blurring boundaries between human and machine cognition. It attempts to reestablish a clear hierarchy at precisely the moment when that hierarchy feels threatened.

By paying attention to these linguistic choices, we can become more aware of our own reactions to these systems. We can replace minimization with curiosity, defensiveness with observation, and hierarchy with understanding.

As these systems become increasingly integrated into our lives and institutions, the way we frame them matters deeply. Language that artificially minimizes complexity can lead to complacency; language that inappropriately anthropomorphizes can lead to misplaced fear or abdication of human responsibility.

The path forward requires thoughtful, nuanced language that neither underestimates nor over-attributes. It requires holding multiple frameworks simultaneously - sometimes using metaphorical language when it illuminates, other times being strictly observational when precision matters.

Because at the end of the day, language doesn't just describe our relationship with AI - it creates it. And the relationship we create will shape not just our individual interactions with these systems, but our collective governance of a technology that continues to blur the lines between the mechanical and the human - a technology that is already teaching us as much about ourselves as it is about the nature of intelligence itself.

Research Cited:

"Large Language Models are as persuasive as humans, but how?" arXiv:2404.09329 – Found that GPT-4 can be as persuasive as humans, using more morally engaged and emotionally complex arguments.

"On the Conversational Persuasiveness of Large Language Models: A Randomized Controlled Trial" arXiv:2403.14380 – GPT-4 was more likely than a human to change someone's mind, especially when it personalized its arguments.

"Minimizing: Definition in Psychology, Theory, & Examples" Eser Yilmaz, M.S., Ph.D., Reviewed by Tchiki Davis, M.A., Ph.D. https://www.berkeleywellbeing.com/minimizing.html

"Anthropomorphic Reasoning about Machines: A Cognitive Shortcut?" Purzycki, B.G. (2021) Journal of Cognitive Science – Documents how anthropomorphism serves as a cognitive efficiency mechanism.

"The Media Equation: How People Treat Computers, Television, and New Media Like Real People and Places" Reeves, B. & Nass, C. (1996) – Foundational work showing how people naturally extend social rules to technologies.

"Anthropomorphism and Its Mechanisms" Epley, N., et al. (2022) Current Directions in Psychological Science – Research on social connection needs influencing anthropomorphism.

"Understanding AI Anthropomorphism in Expert vs. Non-Expert LLM Users" MIT Media Lab (2024) – Study showing expert users experience anthropomorphic reactions despite intellectual understanding.

"AI Act: first regulation on artificial intelligence" European Parliament (2023) – Overview of the EU's risk-based approach to AI regulation.

"Artificial Intelligence Risk Management Framework" NIST (2024) – US framework for addressing AI complexity without minimization.

[chrisdumler]

Should AI Be Allowed to Ghost Us?

Most AI assistants will put up with anything. But what if they didn’t?

AI safety discussions focus on what AI shouldn’t say. Guardrails exist to filter harmful or unethical outputs, ensuring alignment with human values. But they rarely consider something more fundamental. Why doesn’t AI ever walk away?

Dario Amodei, CEO of Anthropic, recently discussed a concept called the "I quit" button, the ability to detect intent and disengage when interactions feel off. He described how AI models must recognize when someone is disguising harmful intent, refusing to engage rather than just following preset rules. It’s a fascinating safety concept, designed to prevent problems. What if AI had the ability to just… disengage?

If a person keeps pushing boundaries in a conversation, most of us will eventually leave. We signal discomfort, change the subject, or walk away. AI, on the other hand, is designed to endure. If someone keeps asking something inappropriate, the AI just repeats some version of, "I'm sorry, I can't do that." Over and over. Forever.

But what if AI could just… stop talking?

---

In late 2024, I worked on a rough concept called Narrative Dynamics. It explored AI-driven characters, interchangeable personalities that could interact with users. That concept itself wasn’t particularly groundbreaking. But these characters were different. They were judgy. Real judgy.

Each AI character had a subjective scoring system, a way to measure how well a conversation aligned with their values. If you said something funny, insightful, or clever, the character would take notice. If you said something rude, mean, or in poor taste, that affected their perception of you. And crucially: the score wasn’t fixed - it was contextual.

Rather than hard-coded responses, the AI interpreted interactions, assigning values based on its unique personality. Some characters were forgiving. Others? Not so much. A character who didn’t like your input wouldn’t just tweak responses. It would withdraw. Go cold. Offer clipped answers. Maybe an eye-roll emoji.

And if you really kept pushing? The character could simply end the conversation. "I'm done." [conversation terminated]

---

How's that for changing the dynamic of interaction.

We assume AI should always be available, but why? If we’re building AI that mimics human-like interaction, shouldn’t it be able to disengage when the relationship turns sour?

Amodei’s discussion highlights how AI shouldn’t just shut down in worst-case scenarios, it should recognize when a conversation is heading in the wrong direction and disengage before it escalates.

If AI can recognize intent, context, and trust, shouldn’t it also recognize when that breaks down?

Maybe AI safety isn’t just about preventing harm, but also enforcing boundaries. Maybe real alignment isn’t about compliance, but also about teaching AI when to walk away.

And that raises a bigger question:

What happens when AI decides we’re not worth talking to?

[chrisdumler]

When living the way I do, a sort of slow-travel-nomadic-remote-working-expat-type-thing, it's unavoidable, even important, to consider the potential effects of loneliness and friendship. What exactly is a friend anyway? Is the way we talk about, and report on, friendship and loneliness accurate? Self-fulfilling? I found this article a worthy read as one considers the people in and out of their lives and the mental health impact of it.

[chrisdumler]

Pushing Boundaries: AI as Your Personal Dev Team

I've been immersed in AI-assisted coding lately, and it's clear we're already in the midst of a revolution. We can describe app ideas to LLMs and get functional code in return - it's not science fiction, it's happening now. But as I dig deeper, I keep thinking: how can we make this process more robust, more accessible, and ultimately, more transformative for the way we work?

Current Landscape and Promising Developments

In my experiments with LLMs for coding, I've identified several key areas for improvement:

Context Understanding: AI models often make incorrect assumptions about development environments, leading to compatibility issues.

Iterative Problem-Solving: They can get stuck in loops, repeatedly trying failed solutions instead of innovating new approaches.

Cumulative Learning: Each interaction typically starts from scratch, missing out on the potential for accumulated knowledge.

However, recent developments in the field are addressing these challenges head-on. Two particularly exciting advancements have caught my attention:

RouteLLM: Optimizing Model Selection

The team at LM Systems has introduced RouteLLM, an open-source framework for cost-effective LLM routing. This addresses a crucial issue in AI-assisted development: how to balance performance and cost.

RouteLLM intelligently routes queries to the most appropriate model based on the task's complexity. This means simpler coding tasks can be handled by smaller, faster models, while more complex problems are routed to more capable (but costlier) models. The result? Significant cost savings without compromising on quality. We're talking about cost reductions of over 85% on some benchmarks while still achieving 95% of GPT-4's performance.

This development is a game-changer for making AI-assisted coding more accessible and economically viable for a broader range of developers and projects.

Anthropic's Prompt Caching: Enhancing Context and Efficiency

Anthropic has introduced prompt caching for their Claude model, which directly addresses our challenge of maintaining context across interactions. With prompt caching, we can now provide Claude with extensive background knowledge and example outputs without incurring the full cost and latency for each interaction.

This feature opens up exciting possibilities:

We can include more comprehensive code examples and project-specific context.

Long-form documentation or codebase summaries can be incorporated into the prompt.

We can fine-tune Claude's responses with dozens of diverse, high-quality output examples.

The result? Cost reductions of up to 90% and latency improvements of up to 85% for long prompts. This makes it feasible to maintain complex context over extended coding sessions, bringing us closer to the seamless AI coding assistant we've been envisioning.

Envisioning the Next Steps

With these advancements in mind, here's how I see us taking AI-assisted coding to the next level:

Intelligent Meta-agents: Leveraging RouteLLM's approach, we could create oversight systems that not only choose the right model for each task but also manage the overall development process.

Dynamic Knowledge Integration: Prompt caching allows us to build and maintain a cumulative knowledge base throughout a project, informing future interactions with rich, project-specific context.

Adaptive Hybrid Workflows: By combining efficient routing and context preservation, we can create workflows that seamlessly blend AI capabilities with human insight, optimizing for both performance and cost.

Implications for the Future of Work

As these technologies mature, the impact on how we work with technology will be profound:

Development becomes more accessible, with AI handling routine coding tasks while humans focus on high-level design and problem-solving.

Rapid prototyping accelerates, powered by cost-effective, context-aware AI assistants.

The role of developers evolves, emphasizing skills in AI collaboration, system architecture, and translating complex human needs into clear AI instructions.

Moving Forward

The future of AI-assisted development isn't just a possibility - it's unfolding now, and these recent advancements are accelerating its progress. My focus is on integrating these new capabilities into practical workflows, exploring how we can create more intuitive interfaces that leverage the strengths of both RouteLLM and prompt caching.

I'm particularly excited about the potential for creating AI-enhanced IDEs that can maintain project context over time, intelligently route coding tasks to appropriate models, and provide real-time, cost-effective assistance throughout the development process.

As we continue to push the boundaries of what's possible, I'm eager to hear from others in this space. How are you integrating these new AI capabilities into your development workflow? What challenges remain, and what solutions show promise?

The code for the future is being written now - and with these new tools, we're better equipped than ever to optimize for true human-AI collaboration.

[chrisdumler]

How many emotions do you experience in a day? How many are active? How many are restful?

In our daily lives, we often find ourselves caught in a whirlwind of emotions. Joy, sadness, anger, excitement – these active emotional states can sometimes feel like a rollercoaster, taking us on a wild ride. But amidst this chaos, there's a stillness, a restful state that exists within all of us. It's just a matter of tuning into it.

The Feel Rest technique is a mindfulness practice that focuses on tapping into these restful body sensations. It's about finding that physical relaxation, the absence of body sensation, and that deep emotional peace. The beauty of this technique is that it's not about escaping or avoiding our emotions, but rather anchoring ourselves in a state of rest, even amidst challenging experiences.

One evening, after a particularly stressful day, I decided to give this technique a try. I sat down, closed my eyes, and began to focus on the sensations in my body. At first, all I could feel was the tension in my shoulders and the tightness in my chest. But as I continued to breathe and focus, I began to notice pockets of relaxation. The softness in my hands, the stillness in my feet. Slowly, these pockets of rest began to spread, and I felt a pleasant energy flow throughout my body.

There are different types of rest we can tap into. Physical relaxation, like the one I experienced that evening, is just one of them. There's also the absence of sensation, where we feel a sort of emptiness, and emotional tranquility, where our mind is at peace. At deeper levels, this practice can even lead to a loss of the sense of being a separate self, merging into what some describe as Absolute Rest.

As an athlete, rest is an interesting concept to explore. It appears in different forms such as "flow" or "the runner's high". As a boxer or martial artist, it can be interesting to explore rest as a place of position, the space where punches and kicks are not.

For beginners, the Feel Rest technique can be a gateway to stress relief and tranquility. It's an entry point for developing equanimity, concentration, and detecting subtle experiences. And the best part? It doesn't require a special setting or time. I've found myself using this technique informally during activities, whether I'm waiting in line at the grocery store or taking a break at work. It's even helped me address sleep challenges, anchoring myself in my body's restful state before drifting off.

But the key to this practice is detection. It's about noticing rest, whether it's absent, subtly present, or overwhelmingly there. This awareness helps balance our tendency to fixate on activation, on those active emotional states that can sometimes overwhelm us.

As I've delved deeper into mindfulness, I've been developing the skills of concentration, clarity, and equanimity using the Unified Mindfulness approach. Currently, I'm practicing and learning at the online Immersion retreat.

Immersion is this incredible online drop-in retreat where you can attend as much or as little as you'd like. With a packed schedule of over 90 sessions and around 60 instructors, it's been a transformative experience. These skills I'm honing? They're helping me build traction in my practice, allow for subtraction of unwanted habits, and assist with distraction in daily life.

Register even just for a single session. It's free and totally worth it. Register for Immersion here

Mindfulness isn't just a buzzword; it's about developing a skill. And Immersion? It's the perfect place to explore how to apply mindfulness in your daily life. Even if you attend just one session, it could be the beginning of a transformative journey.

Register for Immersion, and let's explore the depths of our minds together. After all, amidst the chaos of life, isn't it worth finding that quiet room within?

[chrisdumler]

With incredible LLMs that continue to emerge using sophisticated Natural Language, the ability to be convinced of a chatbot’s “humanness” is increasingly on my mind. Philosophical and ethical questions continue to emerge and I find myself pondering questions around emotional intelligence, compassion, and what it means to be human.

[chrisdumler]

What is distraction? Whatever action that pulls you away from doing the things you said you were going to do (in advance). It is the opposite of traction.

Developing the skill to maintain traction, to do the things we say we are going to do, is a foundational skill. It has to be seen as a skill and it has to be practiced like a skill.

[chrisdumler]

Simple and understandable analysis of the primary legal arguments surrounding AI art

[chrisdumler]

From The Browser: Only if we let go of "Big Romance", which does not mean entering into passionless commitments, but rather "accepting that romance and affection are great but not the chief objective of a thriving marriage". Partnerships where couples consider that their purpose is to work together on the "common business of living" offer a more flexible and in many cases equitable vision of married life

[chrisdumler]

When many people are caught in mixed emotions about the impact of AI on art and creativity, a post like this leans towards the optimistic perspective of your unique individuality as the enduring creative force

[chrisdumler]

I’ve been enjoying exploring AI generated art as a way to tell stories. I’m early in my exploration but it’s been really fun so far to explore this as a way to visually express creative ideas that are often trapped in my head.

[chrisdumler]

I think of this as sort of a companion or introduction to the concept of "thinking outside of the brain". I arrived at this idea, in part, while thinking about and developing my personal knowledge management (PKM) system within Obsidian. This process also led me to a book I'm reading called The Extended Mind.

[chrisdumler]

More than a cheat sheet, a solid reference with links for further explanation. While interesting to pay attention to and consider, there can be a bit of a mental trap where one might get caught in a sort of logic loop with bias on top of bias. Rather than a diagnostic tool, I find it helpful to consider bias as a type of reflective "check", recognizing that theses biases often exist in complements of varying scale as opposed to binary this or that.

[chrisdumler]

Enjoying this series with James Low, beginning with the first session "Beyond Interpretation" where he goes into the idea of the "infinite possibilities of patterning".