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

"Vibe coding fails because the requests are just a demand to 'Have' without the proper 'Be'." "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) 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); 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) and Public Workflow Gist. 1. Looking Upstream: Why Be -> Do -> Have Is Context -> Process -> Content People sometimes ask me how we kept finding these bridges between 1976 Makefiles, 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. Reinventing "Attention Is All You Need" One Level Up: Aiming the Spotlight Away from Doom 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: "Loud and Popular" Out-Shouts "Fatal": A shiny Stack Overflow tutorial shortcut (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. 150k-Token Noise Dilution: When 12 skills, 500 lines of logs, and the Builder's own excuses sit in one window, the attention budget (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: The Query (Q): The active Makefile leaf target (Target 15, Target 30, Target 40) asks only for what matters right now. The Sparse Keys (K): Make-Fork clears the desk to a crisp 20k-token window holding only the 3–5 phase-bound scars for that step—boosting their attention weight by 1,000x. The -∞ Attention Mask (M): Each 4-Vector Scar places a bright red traffic flare right in front of the cliff edge (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. The Lifecycle 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. The "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: Because the words "Flutter", "Dart", and "Git" are still sitting right there in the prompt, turning up temperature just makes the model stumble around drunk at the bottom of the exact same canyon (1 -> 2 -> 3 -> 4 -> 5_typo). When a human generalist "steps back," you temporarily strip the surface nouns off the problem so only the bare relational shape remains ("Wait: how does a tiny fixed code govern a huge adaptive network?"). The moment you strip the nouns, the path widens to the whole neighborhood of human and biological knowledge—and sideways across the canyon wall, W (Crow DNA, 1980 Smalltalk-80, 1976 Make) fires an interrupt straight into your working memory! And you can give your AI agent that exact "Sideways Relational Blast (W-Hop)" in three lines of Make-Fork: Step Back (Noun-Strip): Take the stuck problem [1, 2, 3, 4] and strip out every programming language, framework, and codebase noun into one pure sentence of relational tension. Sideways Blast (fork() with Zero Code Context): Send only that one noun-free sentence to a fresh subagent and ask: "What 3 mechanisms (W_1, W_2, W_3) in biology, 1970s/1980s computing history, or physics solved this exact tension?" Zoom Back In: Bring W back into your code at temperature = 0.0 and climb straight out of the valley! "It's Quiet... Yeah, Too Quiet": The False-Finish Suspicion Instinct 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: In a real forest, normal life is noisy (Baseline Entropy > 0). When every bird and insect suddenly goes 100% silent, a naive creature thinks "How peaceful!" and strolls into the clearing. A crow knows dead silence means a hawk just entered the trees. In software engineering, touching a real production subsystem is supposed to push back: Target 30 (tdd-red) should fail loudly first, types should complain, and state edges should demand guards. When an AI agent edits a complex async lifecycle, runs the test suite, and everything passes on the very first try in 0.01 seconds with zero friction... The Unscarred LLM says: "It's quiet! Ship it!" The Scarred Veteran says: "Yeah... too quiet." Whenever a hard ticket yields with suspiciously zero friction (Observed Friction 5-6-7-8) so 100% of its attention is focused on the exact edge of the assumption. * The Punch: Write the Target 30 (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! Summary: Craft Lives in Context 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: Be (Context): Locking in the stance, the caller digraph, and the negative bounds ("If you're being THIS, there's trouble ahead!"); Do (Process): Single-stepping one state transition at a time, reading the ladder rungs ("I have different problems at each rung"), and dropping to the Null State when ruts occur; Have (Content): The clean, tested, low-care diff that emerges as the inevitable byproduct. 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. 📚 The Synthetic Scars Series on DEV.to Part 1: Why AI Keeps Making the Same Coding Mistakes—And How Teaching It Pain Gives It Wisdom Part 2: Why AI Coding Agents Crash at 3 AM: The Happy-Path Mirage & The Forced Continuity Defect (💎 DEV.to Staff Pick) Part 3: The Physics of Socratic Prompting: Somatic Recoil, Chess Alpha-Beta, & The NLP Meta-Model Part 3.5: Nudging with Questions: Why Telling Your AI What to Fix Triggers an Apology Death Spiral (And How to Advance Juniors) Part 3.6: Stuart Feldman Was Right in 1976: Why Your AI Agent Needs a Makefile, Not a 20-Step Prompt Part 3.7: Surviving the 200k-Token Lobotomy: How Unix init.d and "Memento" Made My AI Coding Agent Immune to Context Compaction Part 3.8: What LLMs "Know" That You Don't Know They Know: Stop Inventing Prompt DSLs and Ride 50 Years of Unix Pre-Training Gravity Part 3.9: If You Never Do Anything Else to Fix Your Prompts, Do This One Thing Part 3.10: Requests, Promises, Assertions, and Declarations: Rewriting Our AI Agent Workflow as a 1986 "Committed Speech" Machine Part 3.11: 926 Steps, Two Lobotomies, and Zero Nudges: Flight-Testing the Commitment Machine Across Gemini, Claude, and GPT-OSS Part 3.12: The Best Prompt Rule Is the One You Delete: Moving AI Guardrails Out of Markdown and Into Git Locks, Linux insmod, and 15ms Compiler Auto-Fixes Part 4: Giving AI Pain: The Architecture of Synthetic Scars & The Rapid-Regret Miner Part 4.1: All That Glisters Is Softmax: Shiny-Object Interns, Airplane-Magazine Execs, and Why AI Labs Can Only Bake In Half the Scars Part 4.2: The Postcard That Ate Six Grammars: 1980 Smalltalk-80, 1976 Make, TDD, and the Four Attractors of Agentic Coding Part 4.3: Crows, Moths, and Makefiles: How 300 Megabytes of Crow DNA Explains Why a 20-Kilobyte Scar File Outsmarts a Terabyte LLM Part 4.4: Being, Doing, Having: Why 50 Years of Senior Craft Lives in Context, Not Code (You are here) Part 4.5: The Prisoner in the Library: Mary's Room, Weight-Space Programming, and the Two-Track Transformer (Next) How do you reset your context when you find yourself stuck on the same ladder rung? Let's discuss in the comments!