Don’t Worship the Toaster (and Other Rules for Using AI Without Losing Agency)

Published: 4 days ago (December 29, 2025 at 12:26 PM EST)

8 min read

Source: Dev.to

The Landscape

We now live in a world where an absurd amount of stuff can be generated on demand—text, images, music, plans, arguments, mockups, and enough options to make the concept of a single coherent identity feel like a premium feature you forgot to renew.

The cost of producing a thing has collapsed. That part is no longer controversial. The only people still arguing about it are either selling something, regulating something, or trapped in a meeting where everyone says “paradigm shift” like it’s a prayer.

The obvious conclusion is that creation no longer matters.

That conclusion is wrong, in the way it’s wrong to conclude that because bread is cheap, sandwiches are meaningless. Bread isn’t the problem. The problem is the horrifying number of sandwiches that now exist, many of which are trying to be your personality.

When supply gets close to unbounded, value doesn’t disappear. It migrates upstream, into the part that decides what’s worth keeping.

Generation is cheap.
Judgment is still expensive.
And somehow we keep trying to pay for judgment with vibes.

Two Broad Modes of AI

I’ve found it useful, for my own sanity, to think about AI in two broad modes. Not because the universe demands categories, but because humans are perfectly capable of confusing themselves to death without help, and I’d like to reduce my reliance on that talent.

1. AI as a Tool (instrumental)

I have a task, a constraint, an outcome.
The model helps me do work.
The output goes into a real process that pushes back: compilation, tests, users, production logs, budgets, deadlines, and whatever grim entity governs time estimates.

Reality is the grader.

2. AI as an Oracle

Not necessarily because I want it to be, but because I ask it questions in places where I can’t clearly test whether it’s wrong, or where “wrong” isn’t even well‑defined.
What should we believe?
What does this mean?
What will happen?
What is best?

This distinction isn’t moral; it’s about control.

Tooling keeps agency with me.
Oracle use can quietly relocate agency to something that speaks in complete sentences and never looks nervous.

Most of the trouble starts when these two modes get blurred, which, inconveniently, is the default setting.

My Personal Preference: Tooling

My own use leans heavily toward tooling. Not because I’m above temptation, but because I enjoy knowing when I’m being lied to.

Tooling forces contact with consequence.
It keeps me inside a feedback loop.
If the model helps, great.
If it misleads me, I pay for it quickly. That payment is information; it updates my understanding. It’s annoying, but it’s honest.

In practice (very un‑romantic)

Sketch a refactor path or list trade‑offs → validate by doing the boring part: read the code, run the tests, watch what the system does when it hits reality.
Draft tests or enumerate edge cases (especially where business rules mutate into folklore) → check those cases against actual requirements, existing behavior, and whatever production logs are willing to confess.
Explain a module back to me → treat the output like a rubber‑duck with a postgraduate vocabulary: helpful, occasionally brilliant, not legally admissible.
Ask for a few alternative implementations just to see patterns, like shaking a box to hear what rattles. The compiler becomes the lie detector, the runtime the judge, users the jury (a frightening thought if you dwell on it).

Tooling doesn’t make me smarter. It makes me faster at discovering where I’m wrong.

That matters because speed without feedback is just acceleration, and acceleration is only impressive until you meet a wall.

Oracle Use: When It Makes Sense

None of this means oracle use is useless—that would be dishonest. There are places where “correctness” isn’t the goal because there is no stable ground truth to converge toward. You’re:

Exploring
Mapping
Seeing the problem from an angle you don’t naturally inhabit

Oracles make sense in:

Ideation
Creative exploration
Speculative thinking
Philosophy
Reframing problems you already own responsibility for

They are useful when what you’re buying is perspective, not authority.

The system isn’t there to be right; it’s there to widen the map, suggest a path you didn’t see, hand you a weird rock and insist it’s symbolic.

The distinction that matters is authority. Safe oracle use is borrowing perspective, not outsourcing judgment.

Safe Oracle Mode

Oracle use is safest when it’s bounded, plural, and owned.

Aspect	What it means
Bounded	I set the frame. I remind myself, explicitly, that this is exploration, not instruction.
Plural	I force it to generate multiple perspectives, including the annoying ones.
Owned	I treat the output as input to my judgment, not a replacement for it.

If I’m being disciplined, “safe oracle mode” looks like:

Asking for opposing framings, counter‑arguments, or what would change the answer.
Prising assumptions into daylight.
Separating facts from interpretations and value claims (mixing those is how you end up with a toaster as your spiritual advisor).

When Oracle Use Becomes Unsafe

Oracle use becomes unsafe when confidence replaces accountability.

Especially in:

Politics
Culture
Ethics
Identity
Forecasting complex social systems

These domains are basically places where everyone is carrying a sword made of opinions and insisting it’s a measuring instrument. They contain facts, but they aren’t reducible to facts, and the gap is where fluency gets mistaken for truth.

The most dangerous oracle failures aren’t dramatic; they’re quiet. People think they’re using a tool, but the system behaves like an oracle. Authority slips in through tone, coherence, and the deeply human habit of mistaking “sounds plausible” for “is reliable.”

A Rule‑of‑Thumb

When the output feels like an answer rather than a suggestion, pause and re‑evaluate.

Use the rule of thumb to keep the balance between tool and oracle, and you’ll stay on the side of judgment that remains yours.

On Accuracy, Oracle Use, and AI Risk

“When they fail constantly: if I can’t describe how I’d know the answer was wrong, I’m in oracle mode.”

Accuracy vs. Epistemic Integrity

Accuracy is useful when there is a stable external referent:
- A bridge either holds or it doesn’t.
- A proof is either valid or it isn’t.
- Code either compiles or it doesn’t.
In art, culture, politics, and ethics accuracy is not the primary metric.
- These domains are value‑laden, interpretive, persuasive, and contested.
- Outputs are not simply “correct” or “incorrect.”
What matters more is epistemic integrity:
- Making assumptions explicit.
- Separating fact from interpretation.
- Resisting the urge to launder values as facts.

The Fluency Trap

When “accuracy” becomes slippery, fluency becomes dangerous.
- Coherent, confident prose can feel true even when it’s just well‑formed.
- A model can write like a confident adult in a blazer—reality doesn’t care about blazers.

Buffers, Simulation, and Meta‑Risk

Generative AI introduces a cheap buffer between intent and consequence:
- We can simulate, rehearse, generate alternatives, and explore counterfactuals without immediate real‑world action.
- It’s not infinite, but it is economically unrecognizable compared to previous tools (think “one telescope → a thousand telescopes, none aimed at a bird”).
Buffers change behavior:
- Delayed, softened, or abstracted feedback encourages bigger risks.
- Systems scale faster than understanding; bad ideas survive longer (e.g., a “vampire invited in because it looked polite on LinkedIn”).
Deferred consequences arrive concentrated, like interest on a forgotten loan.
- The meta‑risk is not “AI decides for us,” but “AI makes it easier for us to avoid feeling the cost of our decisions until the cost becomes unavoidable.”

Tooling vs. Oracle Use

Tooling survives the buffer better because reality remains the arbiter:
- Outputs are still graded by tests, production, users, and failure.
- Mistakes stay informative; the feedback loop stays intact.
Oracle use erodes that connection:
- Persuasion replaces validation.
- Coherence replaces truth‑testing.
- Confidence replaces learning.
The danger isn’t wrong answers; it’s unowned answers.
- “The model said so” diffuses responsibility.
- It’s not malicious—just convenient, and convenience is how civilization often gets killed.

Trustworthiness ≠ Pure Accuracy

When people say “make AI trustworthy,” they often mean “make it more accurate.”
In many real use cases, trustworthiness is about behavior under uncertainty:
- Clearly stating what the system knows vs. what it’s guessing.
- Not smoothing uncertainty into a confident tone.
- Exposing assumptions.
- Inviting verification when possible.
- Refusing to become an accidental oracle.
Grounding, retrieval, and evaluation loops matter not because they make the model perfect, but because they tether it to something outside itself when that’s possible.
- Trust should be earned through a traceable process, not vibes.
Vibes are how we end up worshipping a toaster.

Play: The Safe Exception

Using AI for creative inspiration, exploration, or fun is often safe because it makes no claim on truth.
- Nothing depends on the output; no authority is granted.
- It’s a fountain of variation: prompts, seeds, sparks.
In this mode the model can hallucinate freely because we’re not confusing it with a decision engine.
- Think of it as a kaleidoscope that occasionally writes a decent paragraph.
Play has boundaries: hallucination is harmless when it isn’t pretending to be instruction.

Future Trends

Generation is trending toward commoditization: producing outputs will keep getting cheaper and more common.
The premium shifts to selection and accountability:
- Systems and practices that preserve agency.
- Tools that surface uncertainty.
- Mechanisms that keep humans responsible for consequences.
The valuable layer won’t be “more content.”
- It will be better judgment under overload: tools that help decide what to pay attention to, what to ignore, and when to hesitate.
This isn’t glamorous, nor is it oracle‑shaped, but it is load‑bearing.
The risk isn’t that we build powerful generators; the risk is that we build them in a way that turns feedback into a suggestion instead of a constraint.

Closing Thought

None of this is advice; it’s a constraint I’m choosing to operate under.

I don’t want systems that decide for me.
I want systems that help me decide faster while being honest about what they know, what they assume, and what they can’t possibly know.

I want feedback, not reassurance. Friction where it matters. Play where it’s safe.

In a world where almost anything can be generated, preserving responsibility might be the only truly scarce thing left.