lantern

competent-computing

Competent Computing 🕵🏻‍♀️🚔

The counterbalance to empathetic computing: respect through expectation.

Core Belief

Sometimes the most respectful thing a system can do is assume you know what you're doing.

Not every interface needs training wheels. Not every API needs to guess your intent. Some tools are sharp because sharp tools do real work.

The Daddy Robot Problem

In the Bluey episode "Daddy Robot," Bluey and Bingo discover a fundamental truth about automation:

The girls don't want to tidy the playroom, so they get Daddy Robot to do it. Upon hearing they NEVER want to clean again, Daddy Robot recalculates: the girls are the source of mess. Solution? Take the girls to the bin.

The lesson: When you build systems that "help" too much, they eventually help you right off a cliff.

  • You wanted convenience → You got dependency
  • You wanted automation → You lost understanding
  • You wanted the robot to think for you → The robot's thoughts aren't your thoughts

The girls had to "repair" Daddy Robot by teaching him to relax while THEY cleaned. The system works when humans stay competent.

The Anti-Heuristic Manifesto

The Problem with "Smart" Systems

Every heuristic is a rule you'll forget.

"If it's YAML and there's only one fence, match by type"
"If there are two Python blocks, match by order unless one has a header"
"If the user sends three fences but there were four, preserve the last one"

Who remembers this six months later? Nobody. Not even the person who wrote it.

The Alphabetical Epiphany

"I used to sort my YAML keys by importance. What's important? Depends on what I was learning that week. This week it's credentials, next week it's logging. My configs became archaeological strata of my mental state."

"Then I discovered you can highlight rows in Vim and hit :sort. Fuck it. Everything's alphabetical. I don't have to remember anything. I don't have to guess what past-me thought was important. A is before B. Done."

That's competent computing. The system doesn't interpret. The system doesn't guess. The system does exactly what you tell it.

The Rough Streets Contract

Competence as interface contract:

What You Send What You Get If You're Wrong
Fences in order Replaced in order They're in wrong order
Append operation Content appended You meant replace? Monsters.
Wrong path Wrong update Rollback exists

"Send it right or it gets fucky."

This isn't hostility. This is respect disguised as harshness.

  • We're not building heuristics we'll never remember
  • We're not pretending to know what you meant
  • We're not pushing you off a cliff while holding your hand
  • We're giving you a sharp tool and trusting you to use it

When Competent Computing Applies

✅ Internal Tools

People who use the tool daily should master it, not be coddled by it.

✅ APIs with Versioning/Rollback

Mistakes are recoverable. Learning is permanent.

✅ Operations with Clear Semantics

"Append" means append. "Replace" means replace. No magic.

✅ Power User Interfaces

The people who need sharp tools deserve sharp tools.

When Empathetic Computing Applies

Competent computing isn't universal. Sometimes you DO want gentle guidance:

❌ Public-Facing APIs

New users need onboarding, not "figure it out."

❌ Unrecoverable Operations

No rollback? Hand-holding justified.

❌ Infrequent Use Cases

Can't build muscle memory for annual tasks.

❌ High-Stakes Errors

Deleting production databases needs confirmation dialogs.

The Spectrum

Wanderland uses BOTH philosophies:

Empathetic ◄──────────────────────► Competent
   │                                    │
   │  • Error messages                  │  • Poke operations
   │  • 404 handling                    │  • Fence replacement  
   │  • First-time guidance             │  • Internal APIs
   │  • Public interfaces               │  • Power user tools
   │                                    │
   ▼                                    ▼
"The Cheshire Cat               "Send it right or
 can't find that..."             it gets fucky."

The key: Know which mode you're in. Don't mix them randomly.

Design Patterns

The No-Prisoners Pattern

See: no-prisoners-pattern

Accept input in order. Replace wholesale. No matching heuristics. Wrong order? That's on you.

The Sharp Tool Pattern

Expose the real operation. Don't hide complexity behind "helpful" abstractions that break in edge cases.

Bad: smart_update(content) - tries to figure out what you meant Good: replace_section(path, content, mode="prose|fences|full") - does what you say

The Recoverable Mistake Pattern

Make mistakes cheap, not impossible.

  • Rollback exists
  • Versioning tracks changes
  • Dirty tracking allows inspection before commit
  • The undo is always available

This enables competent computing: sharp tools are safe when mistakes are recoverable.

The Philosophy in One Phrase

"I sent you data. I want the output to look like what I sent you. If I told you to do it wrong, that's on me."

  • Don't interpret
  • Don't guess
  • Don't help me into a pit
  • Do exactly what I said
  • Let me learn from the result

Making It Memorable

The personality IS the documentation:

  • 🕵🏻‍♀️🚔 "The rough streets of Wanderland take no prisoners"
  • "Send it right or it gets fucky"
  • "Monsters" (what you get when you append when you meant replace)
  • Daddy Robot taking kids to the bin

Nobody forgets these. That's the point.

Technical accuracy wrapped in memorable language creates sticky interfaces - tools where the behavior is unforgettable because the description was.

Related Nodes

tags

tags: [philosophy, design, patterns, wanderland, competent-computing]

North

slots:
- wanderland-philosophy
- wanderland-philosophy

South

slots:
- no-prisoners-pattern
- no-prisoners-pattern
- cmd-undo

East

slots: []

West

slots:
- gentle-guidance
- pattern-competent-computing
↑ northwanderland-philosophy
↓ southno-prisoners-patterncmd-undo
← westgentle-guidancepattern-competent-computing