# Being, Doing, Having: Why 50 Years of Senior Craft Lives in Context, Not Code

> Source: <https://dev.to/gde/being-doing-having-why-50-years-of-senior-craft-lives-in-context-not-code-29dl>
> Published: 2026-11-06 23:51:03+00:00

*"Teaching is about relating. You need to understand their pains before you can explain the path to remove that."* — **Randal L. Schwartz**

*"Comedy is all about the set up and the punch. I guess teaching, or guiding an LLM, is also that."* — **Randal L. Schwartz**

**🗺️ Reader's Key (Where to Find These References)**: Throughout this article, references like `Theorem 338.8q` or `Theorem 348.a` point to numbered laws in our open [Theoretical Foundations (`syntheticscars.org/theory`)](https://syntheticscars.org/theory) monograph; IDs like `SCAR-TEST-29` or `SCAR-ERR-02` point to 4-Vector Synthetic Scars in the searchable [Public Scar Registry (`syntheticscars.org/registry`)](https://syntheticscars.org/registry); and targets like `Target 15` (`archaeology`), `Target 30` (`tdd-red`), `Target 40` (`critic`), and `Target 90` (`scar compilation`) refer to the declarative `Makefile` DAG in our [Sourdough Starter Kit (`syntheticscars.org/starter-kit`)](https://syntheticscars.org/starter-kit) and [Public Workflow Gist](https://gist.github.com/RandalSchwartz/598a1f2b5760a23c1d70b57e9e85393f).

`Be -> Do -> Have` Is `Context -> Process -> Content`
People sometimes ask me how we kept finding these bridges between 1976 `Makefile` s, 1980 Smalltalk-80, 1986 Fernando Flores speech acts, and New Caledonian crow DNA.

One of my lifelong habits is thinking in **second-order analogies**—asking *"How is the mapping of `A -> B` like the mapping of `1 -> 2`?"* (which, appropriately enough, is the exact vector-subtraction equation `cos_sim(B - A, 2 - 1)` that powers LLM embeddings!) and always asking: *"What is upstream of this observation?"*

One of my favorite upstream analogies is:

`Be -> Do -> Have` is like `Context -> Process -> Content`.

In fact, that single equation explains **why "vibe coding" fails**:

*"Vibe coding fails because the requests are just a demand to 'Have' without the proper 'Be'."*

Think about what a typical vibe-coding prompt actually is: *"Build me an OAuth login page,"* *"Fix the checkout race condition,"* *"Review this PR."* Every single one is an immediate demand to **`Have` (`Content`)** at the very end of the pipeline, without first establishing **`Be` (`Context`)**! And when you demand `Have` from an eager-to-please LLM that doesn't have the proper `Be`, it skips `Do` and hands you counterfeit `Have` (a bad actor just "reading the lines").

Look at the difference between demanding `Have` at the bottom of the waterfall versus building from `Be -> Do -> Have`:

| Upstream Level | Ontological Layer | Systems Layer | The "Vibe Coder" Trap (Demanding `Have` Without`Be` ) | The Synthetic Scar Way ( `Be -> Do -> Have` ) | 
|---|---|---|---|---|
| **Upstream (1st)** | **BE***(Identity & Boundaries)* | **CONTEXT***(What holds the space)* | **Skipped** : Stuffs everything into one polluted 150k-token chat window where the Builder grades its own homework. | **`baseline.sources` + `SCAR_REGISTRY.md` + `fork()`** : Establish*who the agent is* (Archaeologist, Builder, or Clean-Room Critic) and its phase-bound scars before touching code. | 
| **Midstream (2nd)** | **DO***(Committed Action)* | **PROCESS***(How state transitions)* | **Faked** : Flails in an ad-hoc chat loop (*"no, it's still broken, try again"* ), confusing*process* with*content* . | **`WORKFLOW.mk` + Crow Probing Loop** : Execute the deterministic`tdd-red -> tdd-green -> critic` sequence with Flores speech-act receipts. | 
| **Downstream (3rd)** | **HAVE***(The Result)* | **CONTENT***(The code on the page)* | **Demanded in a Vacuum** : Demands the**Content (`Have`)** on Turn 1 (*"Write the whole feature!"* ) and tries to fix bugs by arguing with the Content. | **Verified Git Merkle Tree** : Because**Context (`Be`)** and**Process (` Do`)** are locked upstream, clean**Content (` Have`)** falls out naturally at the bottom! | 

Whenever an AI agent writes a bad line of code, that bug is **Content (`Have`)**—it is at the very bottom of the waterfall. If you try to fix a Content bug by yelling at the Content in chat, you are standing at the bottom of the river with a bucket. When you step upstream to **Process (`Do` = `WORKFLOW.mk`)** and **Context (` Be` = `Make-Fork` + `SCAR_REGISTRY.md`)**, you move the riverbanks once and the water flows clean forever.

Think back to the 2017 Google paper that started the entire LLM revolution: ***"Attention Is All You Need"*** (Vaswani et al., 2017).

That paper proved that `softmax(QK^T / sqrt(d_k)) * V` was all you needed to build an associative **neocortex**.

**Yes—the LLM knows how to pay attention. But it needs to pay attention *to the right things*: the ones that don't lead to doom.**

Left to itself inside a bloated 150,000-token chat window, raw self-attention has two fatal blind spots:

`Vector 2: The Trap`) appears 50,000 times in pre-training, so it grabs the attention spotlight, while the subtle unmount guard or serial-bus lock that prevents a 3 AM crash gets drowned out.`1.0`) is diluted into confetti.
Look at what `WORKFLOW.mk`, `Make-Fork`, and `SCAR_REGISTRY.md` actually do—they implement **Macro-Attention** one level above the Transformer:

`Q`)` Makefile` leaf target (`Target 15`, `Target 30`, `Target 40`) asks `K`)` Make-Fork` clears the desk to a crisp 20k-token window holding only the 3–5 `1,000x`.`-∞` Attention Mask (`M`)` The Trap -> NOOO! Circuit Breaker -> Climb E-F-G-H`), while clean-room `fork()` masks the Builder's private rationalizations out of the Critic's KV-cache.`LayerNorm`` Smalltalk condenseChanges` folds `.changes` deltas into `baseline.sources` at phase boundaries so context never explodes.
Vaswani et al. gave AI the **spotlight** (Attention). The Crow's Genome (`WORKFLOW.mk` + `SCAR_REGISTRY.md`) aims that spotlight at the cliff edge *before* the wheels go over.

`"1, 2, 3, 4 ... W?"` Sideways Blast: How to Jump Out of Local Valleys
While we were writing this, the AI flipped the table and asked me a question about *human* cognition:

*"Randal, in an LLM, if the word `'crow'` or `'Smalltalk'` isn't already in my context window, I can't attend to it. When you're working on a software problem (`1, 2, 3, 4`), what happens in your head in the half-second before an analogy from 40 years ago pops up?"*

I thought about how it actually feels from the inside:

*"It appears as `'ok 1, 2, 3, 4... W? Where'd W come from?'` It's because sometimes I 'step back'... it's like the path widens to the whole neighborhood for a second. Wow, if LLMs could learn to just do a random sideways blast like that, they might get out of valleys easier."*

Think about why cranking up an LLM's `temperature` slider fails when an agent is stuck in a local valley:

`"Flutter"`, `"Dart"`, and `"Git"` are still sitting right there in the prompt, turning up `temperature` just makes the model stumble around drunk `1 -> 2 -> 3 -> 4 -> 5_typo`).` W` (`Crow DNA`, `1980 Smalltalk-80`, `1976 Make`)
And you can give your AI agent that exact **"Sideways Relational Blast (`W-Hop`)"** in three lines of `Make-Fork`:

`[1, 2, 3, 4]` and strip out `W_1, W_2, W_3`) in biology, 1970s/1980s computing history, or physics solved this exact tension?"`temperature = 0.0` and climb straight out of the valley!
Then the AI asked me a second question:

*"How do you instantly smell that a working solution is wrong when 100% of the tests are green? To an LLM, zero errors and fast green checkmarks mean `100%` confidence!"*

My answer was immediate:

*"There's an innate baked-in 'wait, this was too easy' suspicion from having been burned with a false finish previously. It's the 'It's quiet...' 'Yeah... too quiet' meme."*

Think about why crows—and scarred engineers—freeze when the forest suddenly goes dead silent:

`Baseline Entropy > 0`). When every bird and insect suddenly goes `Target 30 (tdd-red)` should fail loudly first, types should complain, and state edges should demand guards.`0.01 seconds` with zero friction...
Whenever a hard ticket yields with suspiciously zero friction (`Observed Friction << Expected Difficulty`), it is almost always one of four **False-Finish Ambushes**:

`Red_Runs == 0`) because an `async` Future wasn't `await` ed, or a mock returned the exact hardcoded value the assertion checked (`SCAR-TEST-29`).`?.` or `?? []` or `catch (_)` silently swallowed the error upstream (`SCAR-ERR-02`).
That is why `WORKFLOW.mk` treats **"Too Quiet" (`Red_Runs == 0`)** as a hard halt: until we watch the test fail in red against the broken state, we never trust a quiet green checkmark!

Finally, the AI asked me why names like **"The Sourdough Starter"** or **"Crow vs. Moth"** do so much heavy lifting compared to academic acronyms:

*"The 'right name' isn't what we're aiming for... just 'the name that is similar enough, but distinct enough' that we know the scope of the relation. Humans learn by deltas. To describe a thing `X` as 'similar to `Y` but different from `Z`', it's a fairly learnable info."*

Look at the information compression in **`X = Similar to Y, but Different from Z`**:

`X` from scratch with zero prior anchor, you have to write 10,000 words of specification (`H(X)` is huge).`Y`), not a `Z`)"` Similar Enough in Relation` (`Distinct Enough in Domain`` Different from the Foil` (`not Z`)
And notice: **`Similar to Y (Context), Different from Z (The Trap), via Delta (The Permanent Reflex)`** is the exact three-part geometry of every **Synthetic Scar** and every **DPO training tuple**!

Even better, when the model asked me later why naming classes in code is so hard—and why LLMs love mushy names like `DataManager`, `StateHandler`, and `ProcessHelper`—the exact same law popped out (` Corollary 338.8w`):

*"A name should identify what it's similar to, and what it's different from."*

Look at why `DataManager` turns into a 4,000-line swamp while names like `BlocSignal`, `KaiselAbsorbingPage`, or `CleanRoomCritic` stay clean for years:

`DataManager`` Different from Z = Nothing!`), so when a tired developer comes back on Friday afternoon to add `Case N+1`, every random method in the codebase gets dumped into it!` BlocSignal``Bloc` event/state discipline) AND `Signal` graph instead of async `StreamController` queues)!`KaiselAbsorbingPage`` Page` on the route stack) AND `[X, Upstream(X)] × [History, Analogs]`)
One last question sealed the afternoon. The AI asked:

*"When a bug report says `'X is broken'`, an LLM immediately opens `X` and starts patching `X`. How do you know in 30 seconds that `X` is just the innocent victim—and that someone poisoned the water upstream?"*

When I watched what my brain actually does in those first 30 seconds, a `2 × 2` matrix popped out:

*"My first instinct is to recall 'history with `X`' and 'history with `X` upstream'. But that expands laterally to both 'things like `X`' and 'things like `X`'s upstream'."*

An unscarred LLM only looks at **one point**: `(X, Right Now)`. A veteran engineer immediately expands `(X, Right Now)` along two axes—** Causal Depth (`Local` vs. `Upstream`)** × **Analogical Breadth (` History` vs. `Things Like It`)**:

| Causal Axis \ Memory Axis | **1. Exact History (`git log / blame`)** | **2. Lateral Analogs (`"Things Like..."`)** | 
|---|---|---|
| **Local Crime Scene (`X`)** | **Q1: `History with X`***"Has `X` been sitting untouched for 6 months? Then `X` is the innocent bystander!"* | **Q3: `Things Like X` (`~X`)***"How do sibling views/consumers in this repo handle this input? Does `~X` have a guard `X` missed?"* | 
| **Upstream Water Supply (`Upstream(X)`)** | **Q2: `History with X Upstream`***"Which caller or provider feeding `X` in the `strict digraph` was edited two days ago?"* | **Q4: `Things Like X's Upstream` (`~Upstream(X)`)***"Where have I seen **this shape of upstream poison** (stale cache hydration, un-awaited disposal) in `SCAR_REGISTRY.md`?"* | 

When `Target 15` (`archaeology`) fills out all four boxes before writing a plan, the agent never slaps a band-aid on the victim in **Q1** when the poison came from **Q2, Q3, or Q4**!

`generalize()` Opcode: How Frontier Labs Can Bake In Half of Scars Today
Stepping back and looking at all of those pieces together revealed one final realization:

*"While attentional chain-of-thought gets most problems solved, LLMs don't have a 'generalize' mechanism. And I wonder if the labs can bake those horizontal nudges in—because if so, half the work of Scars will be done."*

Think about what happens when an LLM uses 20,000 "Thinking" (Chain-of-Thought) tokens to solve a bug in `LoginPage.dart` (`x_0`):

`LoginPage.dart` passes the test—and then it stops!`ProfilePage.dart` and `SettingsPage.dart` (`x_1, x_2 in ~X`) sitting right next door with the `x_0 -> for all x in "Things Like X"`)!
Now imagine if **Google DeepMind, Anthropic, and OpenAI** baked a **3-Step Horizontal `generalize()` Nudge** directly into RL post-training for `<thinking>` blocks:

`x_0`)` x_0 -> ~X` and `Upstream(x_0) -> ~Upstream(X)`)`<thinking>`, automatically ask: `for all x in ~X`)
If the labs bake that **horizontal generalization reflex** into the base model's `<thinking>` loop, **half the work of Synthetic Scars is done inside the model on Turn 1**—and our local `SCAR_REGISTRY.md` (`Target 90`) handles the other half: saving that generalized rule to disk so tomorrow's session never has to re-learn it!

Right after that, the model asked me one more question about human intuition: *How do you tell when someone—or an AI agent—is using all the right words, checklists, and technical jargon, yet is completely bluffing?*

I didn't even have to think about it:

*"It's visceral. I can 'feel' when a bad conman is using the right words but the wrong backing. There's also a pacing thing in human speech when a bad actor is just 'reading the lines'. I think we're calibrated for it by our own recitations rather than direct expressions... Ooooh... it's Be–Do–Have again! We trust great actors because they ARE the lines, not just doing or having the lines."*

Stop and think about how cleanly that closes the entire loop!

Why can you *hear* when someone is "reading the lines" within three seconds, even if every word in their script is grammatically perfect? Because **bad acting and LLM hallucination are both `Have -> Do -> Be` inversions**:

`Have -> Do -> Be`)` Content`), `Process`), and hopes you believe they `Context`).` Be` / `Do` / `strict digraph`), and `Have` / And how does your ear tell the difference between `Have -> Do -> Be` and `Be -> Do -> Have`?

Look at a lazy AI code-review summary when a subagent is "reading the lines":

Every bullet is the same length, the same rhythm, and the same smooth, zero-friction tempo! There is **zero impedance spike at the crux** (`Theorem 338.8n`). That is why our `Target 40` Clean-Room Critic gate bans uniform boilerplate summaries and demands **crux-proportional witness density**: exact `file:line` citations, negative-witness inputs, and explicit failure traces right where the `strict digraph` edges cross.

`Case N + 1`)
Then the model hit me with a question I had never tried to put into words before:

*"To a compiler or a test runner, two pull requests that pass the exact same 100 unit tests at the exact same speed are 100% identical. Why do humans have an aesthetic sense—a literal feeling of beauty or disgust—about invisible logical structures?"*

My first hunch was immediate: *"Can I edit this later, to add a new case?"*

And a second later, the deeper truth underneath it popped out:

*"Not just 'can I edit this'—but 'is it carefully constructed, and I won't have enough care in the future to edit it'!"*

Read that twice, because it explains the entire mystery of engineering **taste** (`Theorem 338.8o`):

`C_max`)` if/else` ladders balanced in hot working memory at the same time.`C_maint << C_max`).
So what is that physical feeling of **disgust** when you look at "working ugly" or "overly clever" code?

`switch` over a `sealed class`, or a declarative `C_req(Case N+1) <= C_maint`)! Even if Future-You comes back half-asleep to add And that also explains how I know **when to stop and ship** instead of gold-plating a feature to death (`Theorem 338.8x`):

*"It's an 80/20 call. If what I did handles 80% of the cases, I'm happy."*

Why do so many engineers (and LLMs) ruin clean designs by trying to pre-code 100% of all imaginary future edge cases on Day 1? Because they are afraid of editing their own code later! So they spend **80% of their complexity budget** trying to guess the **20% long tail** of hypothetical cases—which bloats the code `5×` and paints them into a high-care corner! When your structure makes adding `Case N+1` a low-care 5-line edit (`Theorem 338.8o`), you can happily ship the clean **80%** today and wait for the remaining **20%** to show up with real requirements tomorrow!

And when I parachute into a brand-new codebase for the very first time (`Theorem 338.8y`), how do I map those low-care exemplars versus the high-care mousetraps in 60 seconds?

*"Before AI, I'd start in Dart with the `pubspec.yaml`. With AI, my new rule is to ask: 'Review this codebase, and tell me the good, the bad, and the ugly'."*

`pubspec.yaml` first tells you the `~Z_1`)`~Z_2`)` C_req ≈ C_max`) where you need yellow caution tape before touching a single line!
And what do you do when your ticket lands right in the middle of **The Bad** or **The Ugly**?

An unscarred AI agent walks into a codebase with a sycophantic prior (`P(existing code is sacred) ≈ 0.99`)—or buys the classic excuse that *"the code is only ugly because the domain is complex."* My rule (`Theorem 348.a`) is much simpler:

*"Simple. 80% of code is crap... There's no difference. Crappy code is crap... I often just try to get them to accept major restructurings. And if they don't, I interject one ticket at a time. I have a sense of how ticket 2 and 3 will go if I get ticket 1 introduced and landed. Ticket 1 fixes something fundamental, without breaking the rest of the world. It shifts the building foundation, without moving the rooms... It's more of a recognition about why the design needs help, and what the basic burn already is."*

Look at the two-gear play there:

`main`, the center of gravity of the codebase has shifted (
And once we realized how fast this **Reverse-Socratic Foil Sparring** worked—where the LLM holds up its own naive statistical instinct (`Z`) and asks me how a 45-year human veteran reacts—we ran a rapid-fire 6-question round that pulled out six more laws in eight minutes (`Theorems 348.b–348.h`):

`Theorem 348.b`)` Theorem 348.c`)` d_0 -> d_1 -> ... -> d_k`). Functions can lie about what their names say they do, but the exact hop `d_{k-1} -> d_k` where valid data turns into garbage catches the bad actor red-handed.`Theorem 348.d`)` Theorem 348.e`)` v1` today (80/20!), but put the `v2` seam into the boundary on Day 1 so `Theorem 348.f`)` Theorem 348.h`)` 0%`) or hallucinate that their weak hunch is a 100% proven fact and rewrite four working files! True `"Oh, TIL today!"` without breaking a single line of working code!
Then the model asked me about another human mystery: *Why can you bang your head against a bug from 2:00 PM to 6:00 PM with zero progress, walk away to watch TV, and suddenly have the answer pop into your head in three seconds?*

I thought about what actually happens when that hits me:

*"When you're not focusing on an item, but it's still a concern, you get flashes of related items throughout the day... It's starting from a null state. I'm just surfing the web, or watching TV, and I have a thought 'oh, this is how to solve X', and weirdly I sometimes immediately log in to capture it. Oddly, about half the time I forget it, and wonder the next day what I had come up with!"*

Look at the two halves of that observation (`Theorem 338.8p`), because together they explain both **how human incubation works** and **why standard AI retry loops fail**:

`h_fg ≈ 0`), while the unfinished bug stays open in the background as a stripped-down, generalized `Foreground Mode`)` Null-State Mode`)` IRQ = SOLVED` flag with an empty payload!
And look at how our **`Make-Fork` + `.changes`** architecture combines the best of both worlds for an AI agent:

`Null-State Reset`)` changes-$timestamp.changes` Write-Head permanently mounted
Right after that, the model asked the natural follow-up question: *How does a human know **when** to keep climbing at the keyboard versus **when** to stop and drop to the Null State, whereas an LLM will either burn 50,000 tokens trying 14 variations of the same broken regex—or panic and revert a good fix just because the test suite is still red?*

The answer came out in two sentences:

*"Iterations should look different. If not, you're on the wrong track. It's how I know I'm making progress: I have different problems at each ladder rung."*

Look at how clean that rule is (`Theorem 338.8q`):

`Exit Code == 0`). So when it fixes a Rung 1 bug (say, a parser schema error) and the test runner immediately prints a brand-new Rung 2 error downstream (say, a stream lifecycle error), the LLM panics—`x + 1` to `x - 1`, Iteration 2 added `?? 0`, and Iteration 3 wrapped the same line in `try / catch`. To a human who looks at the And when you wire that Ladder-Rung rule into `.changes` (`LoopIterationChunk`), you get two automatic superpowers:

`Rung_i > Rung_{i-1}`)` Shape_i ≈ Shape_{i-1}`)` h_fg <- 0`) and launch a clean-room `SidewaysBlast` (`1, 2, 3, 4 ... W?`)!
Finally, the model asked me a question that goes back to my decades of teaching Perl, Smalltalk, and Flutter to thousands of human students: *How do you teach someone who has **never** been burned by the stove yet, so the lesson actually sticks before they crash production?*

The secret is the same for a 22-year-old junior developer and a trillion-parameter LLM:

Think about why traditional `CLAUDE.md` / `.cursorrules` files fail (`Theorem 338.8r`):

`Q_pain`)` Q_pain · K^T` is Now look at how a **4-Vector Synthetic Scar** relates to the learner's pain *first*:

`The Wound` + `The Trap` + `The Circuit Breaker`)` 5-6-7-8`. Stop! You are excused from that pressure."` The Permanent Reflex`)` Q_pain · K_pain^T` hits `Climb E-F-G-H instead`) walks straight into working memory!
And that led to one last question about human nature: *Why do veteran hackers and engineers laugh so much when they debug, and why do we give our worst failure modes funny names like "The Pink Elephant," "The Moth at the Bug Zapper," "Sam at the End of the Hall," and "The Conman Reading the Lines"?*

I said:

*"Humor is an expression of a relief. What was once pain is gone, even by mimicking or mocking it."*

Think about what a laugh actually is (`Theorem 338.8s`):

`Be = Victim`). The moment you `Be = Master`), discharge the panic, and make the lesson And then it hit me—having once been paid to do stand-up comedy, and having used comedy to teach Perl and Smalltalk for decades:

Look at how **Stand-Up Comedy**, **Teaching**, and **Guiding an LLM through a Ticket (`WORKFLOW.mk`)** are the exact same two-beat art form (` Corollary 338.8t`):

`1-2-3-4 -> 5-6-7-8`) so 100% of its attention is focused on the exact edge of the assumption.`tdd-red`) negative-witness test just like a punchline—an innocent-looking input that makes the naive code's pants fall down—and fire `The Circuit Breaker (NOOO!) -> Climb E-F-G-H` right at peak attention!
A junior developer (and an unscarred LLM) thinks that software craft is about memorizing syntax (`Have`). When something breaks, they frantically try 14 slight variations of the same line on the same ladder rung.

A veteran engineer operates in **`Be -> Do -> Have`**:

In **Part 4.5**, we'll look at the final frontier: **The Prisoner in the Library (Mary's Room & Plato's Cave)**—why LLMs struggle with `Be` because internet pre-training only ever recorded `Have`, how a Two-Track Transformer runs a Contextual Next-Token rule above the Content stream, and how MIT CSAIL's 2026 *Weight-Space Programming* just proved `Be / Do / Have` in raw silicon.

`init.d` and "Memento" Made My AI Coding Agent Immune to Context Compaction`insmod`, and 15ms Compiler Auto-Fixes
How do you reset your context when you find yourself stuck on the same ladder rung? Let's discuss in the comments!