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

Randal L. Schwartz argues that the Be -> Do -> Have framework maps onto Context -> Process -> Content, and that "vibe coding" fails because prompts demand a result (Have) without first establishing identity and boundaries (Be). He proposes a workflow using a baseline sources file, a scar registry, and a Makefile DAG that runs a deterministic tdd-red -> tdd-green -> critic sequence, so verified code falls out once context and process are locked upstream.

"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