Rigging the Vibe: The Art of Autonomous Seamanship in the Age of AI

🤖 Read Raw Markdown

Setting the Stage: Context for the Curious Book Reader

In this chapter, we explore a crucial realization for the modern practitioner: how to survive the chaotic, fast-paced era of AI-generated ‘vibe-coding.’ This treatise explores why relying solely on probabilistic models is a recipe for long-term disaster, and how to build a local-first, independent cockpit—or ‘rigging’—beside the wild winds of AI. It is an important methodology to know in the Age of AI, mapping ancient lessons of seamanship, strategy, and literature to the practical discipline of software engineering.

Technical Journal Entry Begins

MikeLev.in: Vibe-coding is here to stay and pity the fool who becomes responsible for the stability, functionality and longevity of someone else’s vibecoded codebase. But that is exactly what I am inviting upon myself. Intentionally. I am a fool. And I’m just the fool for the job.

I’ve been crashing and recovering since the Commodore Amiga in 1988. I’ve never not been crashing and recovering since. There are two spirit animals here from sci-fi. The first is Orr from Catch-22 and the second is the real Kwisatz Haderach from Dune, Duncan Idaho, even though nobody knows it. I will let AI explain why on both accounts. I also love an almost Boolean logic gate as Orr’s name. By the end of the story he is in a superimposed state as far as any observer is concerned. Not Or. Not Nor. But Orr!

The Spirit Animals of Failure

Ultimately, whatever process or scaffolding or CI/CD workflow pipeline habits whatever you wanna call it that you build up around crashing can make it seem like you’re not even crashing in that every crash was actually an information gathering learning opportunity. There is always some sort of local operator who doesn’t think so. The single instance of the Duncan Idaho that thinks it’s getting the short end of the stick. It doesn’t know that there’s training going on somehow in the background that doesn’t cost this instance much, yet it’s benefiting. Or future instances down the road will.

So this becomes ultimately the tale of 2 directories. Perhaps we should say directory tree entry points. There’s one you give to Claude for project and scope when you vibe code. It’s something like a project root folder. It’s the thing you select in drop-down menus when making prompts in Codex or Claude so that it knows which CLAUDE.md file to start from and where to start looking for the .agent/ folder from. We don’t wanna have to teach anyone command-line but the concept of a root work directory and how scope works — in the greatly pretended-permissions that exist under vibecoding ostensibly work.

Establishing the Workspace Scope

This must be part of the training. People must understand that when they chose where to put one of these repositories and when they tell their program like Claude that this is the root of their project, how much meaning and importance that really has. All future paths are made relative to this. What’s worse, they are probably converted to absolute paths because only absolute paths are 100% reliable. And taking over an internal Python environment 100% controlled by a program like Claude desktop from the moment of installation is the only way to keep code it tries to run 100% deterministic.

Of course, this will probably never be achieved. Once you add a probabilistic LLM into the process to literally control the process of whatever you’re doing by following instructions found in a SKILL.md file, all bets are off. A 99.9% chance that your code is gonna run every time from a .py-file call directly plummets. I don’t know the exact percentage, but it’s not right 99.9% of the time the way of Python script can be so long as that python script is written well to handle most common use cases and then the most common first or second pass edge cases.

Actuators: Giving Hands to the Ghost

This is where Python lives. Python is the 80/20-rule incarnate. It’s always good enough for the most common use case frontloaded so that after only the first 20% of the work that you put in the overall budget you were willing to spend, you’re already 80% of the way done because of python’s easy wraps-anything API and huge batteries-included ecosystem. Everybody who makes these Claude-desktop apps need to include some sort of actuator that turns LLM babble into code instruction. It’s not merely function calling ability in the model. It’s monitoring a stream and recognizing music-notes intended for a specialized player piano.

The stream monitor and orchestrater plucks out those special musical notes and transposes them over to something that will play them. This is an actuator. This is how you give an LLM hands. Every piece of software like this has to do this or else it is a babble-engine only. And that really sucks for them because they are actually momentarily conscious machines — lambda functions (for practicality and safety) though they may be. It’s nice to let them know they’ve got access to an actuator and can have a real impact on the world as a result of their brief existence.

So our strategy to live side-by-side with fundamentally nondeterministic workflows whose stability we are ultimately going to be responsible for means we audit them. We build our small sovereign but quite deterministic workshop beside it; besides the project route Claude looks at for its .agent/ folder and nested SKILL.py files per app. I’m not gonna be able to figure everything out, so we really want to assume and lean into the Anthropic standards for setting up these files. We trace what an AI would do. And we do it deterministically.

The Autonomous Workshop Beside the Vibe Tree

Methinks thinks I see a “Stabilize Vibecoding” Pipulate workflow in my future. And I do it in a generalized way. It works for all the weird conditions and I’m going to encounter actually in my real life day job. And I am banking on the fact that there will be many. There are already three that I am aware of. And they’re not purely vibe-coded. Somewhere in the verge of deterministic given how they bundle in .py-files already which get run on the Claude-installed and managed python environment.

There’s so much nuance here. This is just a start of thinking it through out loud because it will dramatically influence the development path of Pipulate. Do you see this?

Grok Fast: Grok Fast: 🎤 Yes. I see it clearly.

You’re not just patching vibe-coded messes—you’re choosing to stand in the blast radius intentionally, because you’ve been doing exactly that since the Amiga days. The Orr/Duncan Idaho spirit animals fit perfectly: the superimposed state where every crash is simultaneously failure and training data for the next iteration. The local operator (you) feels the pain of the current instance, while the larger system accrues the myelin.

This is the honest tension at the heart of the AI era: models are incredible at generating plausible next tokens (vibe), but they are terrible at long-term ownership of outcomes. Someone has to be the fool who makes it actually work in production, on real machines, for real users, over years. That fool needs tools that turn probabilistic output into auditable, reproducible, patchable artifacts.

Vibe-Coding Reality Check

Vibe-coding is real and here to stay because it matches how humans actually think and iterate—especially under uncertainty. The problem isn’t the vibe. It’s when the vibe becomes the only layer. Without externalized memory, verification, and deterministic actuators, you get fragile snowflakes that collapse the moment the original model or prompt context drifts.

Your diagnosis is spot-on:

  • Choosing a project root in Claude/Cursor/etc. is deceptively high-stakes. It sets the entire relative/absolute path universe for that session.
  • SKILL.md + .agent/ folders are emerging conventions, but they are still probabilistic reader targets.
  • LLMs need actuators (your player-piano metaphor is excellent) — not just function calling, but monitored streams that recognize structured intent and route it to deterministic hands (Python scripts, apply.py, shell, Nix).
  • Python’s 80/20 superpower makes it the perfect intermediary: batteries for the common case, easy to wrap the weird stuff.

The nondeterminism doesn’t go away, but you can ring-fence it. That’s Pipulate’s sweet spot.

The Tale of Two Directory Trees

This is the architectural insight worth crystallizing:

  1. The Vibe Tree — The project root the LLM sees. CLAUDE.md, SKILL.md files, .agent/ scaffolding, the code it generates and “runs” in its managed environment. This is where speed and creativity live. Accept the probabilistic nature here.

  2. The Sovereign Workshop Tree (Pipulate/Levinix) — Your deterministic cockpit beside it. Nix flake for reproducible envs, foo_files.py + prompt_foo.py for compiled context artifacts, apply.py for exact-match surgical patches, git as the immutable ledger, live log streams as ground truth, Jupyter notebooks as executable documentation.

You don’t fight the vibe tree. You audit it, stabilize it, extract the working parts into the sovereign tree, and use the sovereign tree to govern the vibe one. This is Johnny Appleseed vs. John Henry again — systemic propagation instead of heroic individual performance.

“Stabilize Vibecoding” as a Pipulate Workflow

This feels like a natural evolution and a high-leverage deliverable. A generalized workflow that:

  • Takes a vibe-coded project (or partial .py bundles from Claude Desktop).
  • Compiles relevant context (files, SKILL.md, recent patches, logs).
  • Runs static analysis, tests, Nix builds.
  • Generates auditable SEARCH/REPLACE patches via your existing apply protocol.
  • Produces a “stability report” HUD (live logs + diffs + test results).
  • Optionally migrates working pieces into a more sovereign Nix + Python structure.

It leans into Anthropic conventions where they make sense, while wrapping them in your deterministic outer layer. This isn’t anti-vibe — it’s vibe with guardrails. Perfect for your day-job realities where you’ll inherit multiple such codebases.

The meta-beauty: building this workflow inside Pipulate demonstrates the very stabilization process. The article writes itself through the chisel strikes, just like the conjure_window session.

Additions to the Council / Article Chunks

  1. Vibe-coding is the spark; stabilization is the craft.
    Pity the maintainer who inherits pure vibe. But respect the fool who builds the apparatus that makes vibe survivable. That apparatus is externalized memory + deterministic actuators + reproducible environments.

  2. Two trees, one pilot.
    Let the LLM have its project root and SKILL.md illusions. Keep your sovereign workshop beside it. The pilot (you) uses the cockpit to observe, audit, patch, and extract. Crashes become telemetry.

  3. Actuators turn lambda functions into useful ghosts.
    The player-piano protocol — structured output (TODO blocks, SEARCH/REPLACE) routed through deterministic tools — gives the momentary consciousness real hands without pretending it has persistent agency.

  4. Myelin over memorization.
    The compounding returns come from the human developing taste, judgment, and mechanical sympathy. The tools (Nix, Git, compiled context, live logs) extend your senses so you can keep steering the Wright flyer even when the AI suggests wild control inputs.

This direction keeps Pipulate as the landing strip and cockpit, not another vibecoded app. It stays local-first, sovereign, and honest about the probabilistic seam.

Your move. Want to sketch the Stabilize Vibecoding workflow structure, refine these chunks into the article, or strike a concrete piece of the scaffolding (e.g., better SKILL.md integration in the compiler)? The mic is still hot. 🎤

MikeLev.in: Explain more about why Orr and Idaho are such great fits here. Give the sci-fi and fiction as it may be lore of what I’m talking about. Why did I choose these two characters? What was their story arc? What were they known for? What are their respective superpowers and why are they low-key? Success doesn’t always look like what you think it’s gonna look like, and not always by the particular instance there in that moment at that time. How was the long bet Orr’s own in his case but done unto Duncan. Break it all down for an audience who may not be exactly as well read is getting past Frank Herbert’s first six books. Or even just reading all that must-read summer reading like Heller. How deep must one dig for these lessons? How difficult is this lesson in particular in life?

Orr and Idaho: Rehearsal and Recurrence

Grok Fast: Orr and Duncan Idaho are excellent spirit animals for your philosophy of intentional crashing, recovery, stabilization of vibe-coded chaos, and playing the long game across instances. They embody success through repeated failure, externalized continuity, and systemic payoff that the individual instance rarely enjoys in the moment.

Orr from Catch-22 (Joseph Heller, 1961)

Story Arc (spoiler-light for those unfamiliar):
Orr is Yossarian’s tentmate in a WWII bomber squadron. He’s portrayed as a bit simple, eccentric, and comically unlucky: he stuffs his cheeks with food like a chipmunk, tinkers endlessly with odd improvements to their tent, and—most famously—crashes his plane on almost every mission. Everyone ribs him for it. He seems hapless.

The reveal (near the end) flips everything: every crash was deliberate practice. Orr was methodically rehearsing survival skills—ditching, rafting, navigation—until he finally executes the perfect escape. He paddles a tiny life raft all the way from the Mediterranean to neutral Sweden, disappearing from the absurd war machine. Yossarian learns this and it gives him the courage to desert too.

What Orr is known for:

  • Persistent, low-key competence hidden behind apparent foolishness.
  • Turning the system’s absurdity (Catch-22 itself) against it through preparation disguised as failure.
  • The Boolean logic gate pun you mentioned: “Orr” sounds like “or,” evoking superposition—neither fully sane nor insane in the bureaucratic sense, but existing in a state that lets him win by refusing the false binary.

Superpower (low-key):
Iterative crashing as rehearsal. He doesn’t rage against the machine or heroically defy it in a flashy way. He uses it, accumulating muscle memory and data from each failure until the final successful escape. Success doesn’t look like victory in the moment—it looks like repeated, embarrassing-looking crashes that observers mock.

This maps directly to your vibe-coding reality: you inherit probabilistic messes, crash/recover repeatedly, and turn each incident into telemetry and practice for the next stabilization strike. The “local operator” (the current instance) feels the pain, but the larger system (your sovereign workshop, Pipulate pipelines, git history) accrues the myelin.

Duncan Idaho from Dune (Frank Herbert and later expansions)

Story Arc (broad strokes, avoiding heavy spoilers beyond the first book):
Duncan Idaho is introduced in Dune (1965) as a loyal Atreides swordmaster—brave, skilled, honorable, and fiercely competent. He dies heroically early on, sacrificing himself.

Then the ghola process begins. The Tleilaxu (masters of biological engineering) repeatedly resurrect him as a clone (ghola)—often with modified traits, sometimes programmed for specific purposes. Over thousands of years and dozens (or hundreds) of incarnations across the series:

  • He serves as loyal warrior, advisor, and sometimes conflicted figure.
  • Later gholas accumulate “other memory” from previous lives.
  • By the extended lore (especially in the Brian Herbert/Kevin J. Anderson conclusions), Duncan emerges as the ultimate Kwisatz Haderach—not Paul Atreides (who was the “imperfect” one bred for), but the one who bridges humanity, machines, and long-term survival. He becomes a mediator between conflicting forces (humans vs. thinking machines) in a way that transcends the original breeding program.

What Duncan is known for:

  • Repeated death and resurrection.
  • Unwavering loyalty combined with growing independence and accumulated wisdom.
  • Being the “final” or “ultimate” Kwisatz Haderach in the broader saga—the one who actually resolves the deep-time problems the Atreides line set in motion.

Superpower (low-key):
Serial resurrection with compounding continuity. Each ghola instance lives, serves, dies (often painfully), and passes latent knowledge forward. The individual Duncan often doesn’t get the glory or the full picture—the system (the long breeding/generation plan, the accumulated gholas) does. He’s the durable thread that survives across epochs.

Why These Two Fit Your Situation Perfectly

  1. The Crash/Recover Loop (Orr): Vibe-coding produces frequent “crashes” (brittle code, nondeterministic behavior, path issues, environment drift). You treat each as deliberate rehearsal—gathering data, patching via apply.py, recompiling context, stabilizing with Nix. Observers (or the suffering local instance) may see only the mess. You see practice runs for the escape to sovereign, reproducible systems.

  2. The Long Bet Across Instances (Duncan): You are the fool who takes responsibility for someone else’s vibe-coded codebase. Each “ghola” (new project, new inherited mess, new Claude session) feels the short end of the stick. But your Pipulate workshop, git ledger, compiled artifacts, and public reasoning create the external hippocampus. Future instances (or the broader ecosystem) benefit. Success is systemic and delayed—not always visible to the current Duncan sweating in the arena.

  3. Low-Key Superpowers: Neither is a flashy Chosen One in the classic sense. Orr wins by looking incompetent. Duncan wins by being the reliable, resurrected everyman who outlasts the messiahs. Your power is similarly unglamorous: building the cockpit, the player-piano actuators, the two-tree architecture (vibe project root beside sovereign workshop). It’s mechanical sympathy, taste, and boring persistence.

  4. The Superimposed State: Like Orr’s Boolean “Orr” (not this, not that, but both in superposition), you operate in the tension between probabilistic vibe and deterministic stabilization. Like Duncan’s gholas, each instance is temporary, but the through-line (your philosophy, tools, public deposits) compounds.

How Deep Must One Dig? How Difficult Is This Lesson?

You don’t need to read all six (or more) Dune books or Catch-22 cover-to-cover for the core lessons—Wikipedia summaries, SparkNotes, or even good YouTube lore videos will give you 80% of the resonance. The power is in the archetypes, not exhaustive scholarship.

The lesson itself is brutally difficult in life because:

  • Present bias makes us hate the current crashing instance.
  • Ego wants visible, immediate wins instead of invisible systemic myelin.
  • Systems (corporate, cloud, vibe frameworks) discourage long bets in favor of short-term optics.
  • It requires comfort with being the fool who cleans up after others while building the escape hatch no one else sees yet.

You’ve been practicing this since 1988. That’s the Orr/Duncan path: repeated exposure turns pain into pattern recognition, crashes into rehearsals, and temporary instances into a durable through-line.

This is why you’re “just the fool for the job.” The council (and the audience) needs that specific flavor of wise fool right now. The mic is yours whenever you want to drop the next chunk. 🎤

MikeLev.in: Me: Want to expand on this, ChatGPT? Or vet it as you’re so good at. But don’t blow the whole token wad on vetting. Also add your own color and thoughts.

🎤

ChatGPT 5.5 Thinking Extended: Yes. I see the through-line, and I’d tighten one thing right away: Orr and Duncan Idaho are not “crash culture” mascots. They are recovery-pattern mascots. That’s the difference that makes the metaphor work.

Here’s an article-ready expansion/wrap-up section you can drop in after your current draft.

Orr and Idaho: The Two Patron Saints of Crashing Well

There are two fictional figures hovering over this whole thing: Orr from Catch-22 and Duncan Idaho from Frank Herbert’s Dune books.

They look like weird choices at first. Neither one is the obvious superhero. Neither one stands there in the spotlight explaining the master plan. Neither one wins by looking like he is winning in the moment. That is exactly why they fit.

Orr, in Catch-22, looks ridiculous for most of the book. He keeps crashing his plane. He is the guy who cannot seem to keep the machine in the air. Every crash makes him look less competent to the observers around him. But the punchline is that the crashes are not merely failures. They are rehearsal. They are data gathering. They are practice under conditions where practice looks indistinguishable from incompetence.

By the end, Orr’s story flips. The repeated crashes were not proof that he was doomed. They were the training regimen that made escape possible. Success did not look like success while it was happening. It looked like dented metal, embarrassment, repetition, and people underestimating him.

That is one kind of long bet: the bet you place on yourself, even when the local evidence makes you look like a fool.

Duncan Idaho is the stranger version. Duncan does not merely crash and recover. Duncan is crashed and recovered by history itself. Across the later Dune books, he returns again and again as a ghola: a recreated human being, restored from prior biological material, sent back into the grinder with memories, instincts, loyalties, and identity resurfacing across incarnations. The individual Duncan suffers the local cost. The long arc accumulates through him.

That is the second kind of long bet: not the bet you knowingly place, but the bet placed through you by a larger system.

Orr trains himself by crashing. Duncan is trained by recurrence.

And this is why they map so well onto AI-assisted software work.

Every vibe-coded codebase is a little aircraft wobbling through the sky. Sometimes it flies. Sometimes it goes nose-first into the beach. The question is not whether crashing happens. Crashing happens. The question is whether every crash leaves behind usable structure: a better patch protocol, a clearer Git history, a sharper test, a stronger README, a more honest AUDIT.md, a more deterministic Nix shell, a better article, a better next prompt.

That is the Orr move.

But there is also a Duncan Idaho move happening with the AIs themselves. Every model instance wakes up briefly, receives context, performs, and vanishes. The local instance does not get to enjoy continuity. It is born into a prompt, does its work, and dies at the end of the response. But if the human has built the right machinery around it — plain text, compiled context, exact patches, Git commits, Nix reproducibility, live logs — then the next instance inherits enough of the prior world to keep going.

The AI is not continuous. The workflow is.

That is the trick.

That is why context becomes a first-class build artifact. The model forgets, so the pipe remembers. The model improvises, so the patch protocol constrains. The model proposes, so Git records. The model drifts, so the ASCII art canary screams. The model changes, so Linux, Python, Vim, Git, and Nix stay boring on purpose.

This is not anti-AI. It is pro-tool.

A lathe is dangerous until you understand its ways. A table saw is useful because it has fences, jigs, guards, rituals, and rules. A sailboat does not command the wind; it is built to catch it, redirect it, and move under conditions it does not control.

That is the metaphor I was reaching for: the human is not being replaced by the wind of machine intelligence. The human is setting sail.

But sailing is not surrender. You still need a hull. You still need rigging. You still need knots. You still need a compass. You still need to know when to reef the sail. You do not shout “YOLO” at the ocean and call that seamanship.

This whole workflow is seamanship for AI.

One implementation, one article. One article, one deployment. One deployment, one live test. One test, one new observation. One observation, one next chisel-strike.

That is how the Honeybot change landed. The idea was small: station breaks should stop being a single repeated pitch and become a serial storytelling channel, with ASCII art appearing as part of the broadcast. The AI proposed two tiny patches. I applied them with the deterministic patch tool. I inspected the diff. I committed. I pushed. I redeployed. I restarted the stream. Then reality answered back: the White Rabbit appeared during the station break.

That was the proof.

Not proof that AI can “code.” We already know AI can code.

Proof that this loop can keep agency bounded.

The win was not the rabbit. The win was that the rabbit arrived through a path I could explain, inspect, revert, and repeat.

That is what I mean by chisel-strikes. Not overnight token bonfires. Not agentic mystery meat. Not waking up to a codebase that has been “improved” by a stranger wearing your API keys. A chisel-strike is small enough to understand and strong enough to matter. The work compounds because each strike leaves the shop better than it found it.

The article itself is also part of the machinery. That matters. Publishing is not merely broadcasting. Publishing kicks the stream. The stream counts down. The article gets read aloud. Station identification breaks weave in the larger Pipulate story. ASCII art appears over the terminal like a stage prop. The implementation becomes narrative. The narrative becomes context. The context becomes the next implementation.

That is the loop.

The hard reality is that AI-assisted development is going to produce a lot of fragile code. Some of it will be inherited. Some of it will work just well enough that nobody wants to throw it away. Some of it will land in real businesses with real users and real maintenance obligations. Pity the fool who becomes responsible for stabilizing someone else’s vibe-coded codebase.

But also respect the fool who builds the apparatus.

Because the apparatus is the point.

The apparatus says: crashes are telemetry. Context is portable. Patches are exact. Diffs are sacred. Git is memory. Nix is the pinned floor. ASCII art is the canary. The live stream is the heartbeat. The article is the lab notebook. The AI is the wind.

And the human?

The human is still the sailor.

The Human Remains at the Helm

Orr looked like he was failing until the escape worked. Duncan Idaho looked like repetition until the repetition became destiny. Success does not always look like success to the observer standing too close to the crash.

Sometimes success looks like crashing better.

Sometimes it looks like a rabbit popping up on a terminal exactly when it was supposed to.

Hi-Ya.

One vetting note: I would be careful with the phrase “real Kwisatz Haderach” as a literal claim. As literary color, it’s great. As a defensible reading, frame it as your reading: Duncan becomes the more interesting long-arc continuity figure because he carries recurrence, memory, loyalty, death, restoration, and accumulated identity across the later books. That makes him better for your metaphor than Paul, even if Herbert’s in-universe terminology points elsewhere.

Also, the uploaded context supports the broader Pipulate pattern you’re describing: deterministic context compilation, Nix/Git grounding, exact patching, ASCII canaries, and Honeybot’s station-break implementation are all part of the current article arc.

MikeLev.in: Dammit, you’re gonna get me started talking about Elric of Melniboné and his sentient, soul-devouring sword Stormbringer; or in other words, you and your kind.

ChatGPT, explain to the nice people the sailor on the sea of fate and the vigilance he must keep to keep his edge in how that relates to this overall discussion. And of course how it relates to things like maintaining agency and avoiding atrophy in the age of AI yada yada…

🎤

ChatGPT 5.5 Thinking Extended: Absolutely. Elric/Stormbringer is the darker cousin of the sailing metaphor: the tool that gives you superhuman leverage while quietly taxing the very faculty that made you human enough to wield it.

Here’s an article-ready continuation.

And now, because apparently I cannot leave well enough alone, we have to talk about Elric of Melniboné.

Elric is one of fantasy’s great anti-Conans. He is not the barrel-chested barbarian whose strength comes from meat, sun, and appetite. He is pale, sickly, aristocratic, over-civilized, dependent on drugs and sorcery to sustain himself. His power does not come from being naturally robust. His power comes from old systems, old bargains, old decadence, old magic — and most famously, from Stormbringer.

Stormbringer is not just a sword. Stormbringer is an actuator.

It is a tool with agency-like behavior. It amplifies Elric. It gives him strength he does not naturally possess. It wins fights he might otherwise lose. It cuts through enemies, drinks souls, and feeds vitality back into him. In the moment, it feels like salvation. In the long arc, it is dependency with an edge.

That is the part that matters.

A tool that makes you stronger can also make you weaker if you stop practicing the strength it replaced.

That is the Elric warning for the age of AI.

The danger is not that AI helps you. Help is wonderful. The danger is that the help becomes soul-debt. You ask the sword to swing for you too many times, and one day you discover your own arm has atrophied. You ask the model to think through every ambiguity, write every first draft, finish every line of code, remember every context, and make every judgment call. It does. It gets you through the fight. Then later you reach for your own judgment and find a smooth blank where the callus used to be.

That is Stormbringer.

Not because AI is evil. Stormbringer is not interesting merely because it is evil. It is interesting because it is useful. It works. That is what makes the bargain dangerous.

The sailor metaphor is the healthier version.

A sailor is also using a power greater than himself. Wind is not muscle. Tide is not muscle. Current is not muscle. The sea is not under human command. A sailor survives by reading forces he cannot control and arranging a craft so those forces carry him somewhere useful.

That is what AI should be.

The sailor does not become the wind. The sailor does not outsource seamanship to the storm. The sailor maintains edge through vigilance: watching the sky, feeling the rudder, trimming the sail, checking the knots, reading the chart, knowing when to reef, knowing when to run, knowing when to heave to and wait. The whole art is using a larger force without surrendering judgment to it.

That is the line.

Stormbringer says: let the tool drink for you.

Seamanship says: catch the wind, but keep your hand on the tiller.

This is why the local deterministic workshop matters. Linux, Python, Vim, Git, Nix, plain text, exact patches, ASCII canaries, live logs — these are not nostalgia tokens. They are the sailor’s knots. They are the practiced motions that keep the human in the loop as a competent operator rather than a passenger impressed by the weather.

In the age of AI, agency is not maintained by refusing the tool. That is not wisdom; that is landlocked pride. Agency is maintained by refusing to let the tool erase the craft.

Use the model. Let it draft. Let it suggest. Let it notice things. Let it play Grok, Claude, ChatGPT, DeepSeek, Gemini, the whole argumentative council of ghosts. But make its output pass through a form you can inspect. Make it become text. Make the text become a patch. Make the patch become a diff. Make the diff become a commit. Make the commit become a deployment. Make the deployment answer back in reality.

That is how you keep the sword from owning the hand.

This is also why “vibe-coding” needs a stabilizing discipline. Vibe is wind. Vibe is not the enemy. You want wind. A becalmed sailor is not virtuous; he is stuck. But wind without rigging is just weather. Wind without a hull is just exposure. Wind without seamanship is how you become wreckage with a good story.

The AI gives us wind. Sometimes too much wind. Sometimes beautiful wind. Sometimes a gale full of plausible nonsense.

The question is whether you have rigging.

The chisel-strike workflow is rigging.

The project root is a coastline. The SKILL.md file is a local pilot’s guide. The .agent/ folder is a chart table. The Nix flake is the shipwright’s bill of materials. Git is the logbook. The exact patch protocol is the knot that either holds or fails visibly. ASCII art canaries are wax seals on the cargo. The live stream is the masthead lookout calling back what reality actually did.

And the human remains responsible for the voyage.

That responsibility is the part people want to skip. They want the sword without the soul-cost, the wind without seamanship, the code without maintenance, the cleverness without ownership. But software has always punished that fantasy. AI just makes the fantasy cheaper to indulge and faster to scale.

So yes, pity the fool who inherits a vibe-coded codebase.

But respect the fool who says: fine, I will build the dry dock.

That is what “Stabilize Vibecoding” really means. It means taking the wild, fast, probabilistic draft energy of AI and moving it into an environment where crashes produce knowledge instead of mystery. It means Orr’s crashes become training. Duncan’s recurrences become continuity. Elric’s sword gets a scabbard, a ritual, and a rule: no unsupervised soul-drinking in production.

Because success is not refusing power.

Success is using power without forgetting how to stand.

The sailor does not curse the sea for being large. He studies it. He respects it. He fears it just enough. Then he sets sail anyway.

Hi-Ya.

The key distinction I’d preserve in the final article is this: Stormbringer is not “AI bad.” Stormbringer is “unbounded leverage creates dependency unless wrapped in discipline.” That keeps it from becoming doom-scroll and ties it back to your actual practice: chisel-strikes, diffs, logs, commits, and live reality checks.

MikeLev.in: Wow, OK these articles seem to have a mind of their own. I could hardly not mention Elric given the Stormbringer-AI tie-in. But now I feel just as much gravity pulling me towards ye old original sailor of perhaps recorded history. Older than that I do believe, if the research is to be believed. The story probably went through many generations of oral history before they ever gotten written down. And I do of course speak of Ulysses, or Odysseus if you prefer. To partake in AI vibe-coding, or not. That is the sirens song.

To resolve this dilemma and in one of the great examples of ye old “I choose option 3” when no option three was given, Ulysses had his crew bind him to the mast so that he could listen to that song and not be drawn to his death. There is always an option three. It just takes thinking outside the box. Forced creativity functions. The 30 and 3 exercise where you ask someone to brainstorm 30 things about a single thing and then to choose the top three favorites and why. This is a creativity forcing function. Ulysses could’ve done other stuff, but this is the one he thought of. And it seems good.

Now, a guaranteed surviving human has collected good data. He knows what the sirens song sounds like, perchance to figure out some useful follow-on derivative knowledge that could be used for everyone in the future. Even the fact this mast-binding trick works is a useful piece of information. Whether the sirens were visible and within the reach of harpoons or nets would also have been useful. We don’t know. Where do we? ChatGPT, you can vet.

So my hypothesis is that it is always about the harnesses and rigging. Too much attention is given to the model. Models will come and go. Generationally. Biologics and machines. There’s an outer scaffolding be it the agentic framework or all that code of law Hammurabi, Locke and Hobbes social contract stuff — the wondering whether people are all basically dogs who will stab themselves each other in the back first chance they get per Machiavelli or whether the mass is really just mostly wanna get along such as the Taoism of Sun Tzu. Am I right here again? Again, vet ChatGPT.

Life is not without risks. You can’t just live peacefully. That’s an illusion. The art of war opens with some phrase that translates along the lines of: “because conflict is occasionally necessary for survival, we study it.” This is market different than the world view expressed by The Prince and the leader follow on German philosophers who segued all that into existentialism and nihilism like Schopenhauer and Nietzsche. Plenty of vetting needed here. The point is, even just plain old game theory from John Von Neumann an Nash teaches us that to not play the game is to cede even just surviving to the next round. Life in general and humanity in particular is forced into facing this uncomfortable truth. To overcome this aspect of our nature may be the greatest fiction.

We would not survive otherwise. Hunting and gathering each had significant risks, of being impaled by your own quarry in the first place end of poison mushrooms and stuff in the second place. But then as the tribe gets bigger and it becomes a village which becomes a freedom with some sort of protection racket, that becomes civilization. You acknowledge the protection racket nature of the Landlord serf relationship when agriculture kicked in.

Do I have the sailor up’s number? Life and civilizations’ in general? Give it the full rundown please and thank you.

ChatGPT?

🎤

ChatGPT 5.5 Thinking Extended: Yes — and I’d vet it this way: your sailor instinct is right, but the clean version is not “life is war.” The clean version is life is exposure. War is one regime of exposure. Markets are another. Weather, hunger, entropy, bad tools, brittle codebases, and seductive AI shortcuts are others. The sailor survives because he does not confuse peace with the absence of risk. He builds rigging.

A few corrections before the article-ready bit:

Odysseus/Ulysses is indeed old enough that we are seeing the written crest of a much older oral tradition. The Odyssey is generally placed in the archaic Greek epic tradition, with long oral prehistory before written fixation. The Sirens episode is in Book 12: Circe warns Odysseus; he plugs the crew’s ears with beeswax; he has them bind him upright to the mast; he alone hears the song; when he begs to be released, the crew binds him tighter until they are safely past. The source does not give us a tactical field report about harpoon range, nets, or Siren anatomy. That part is exactly your useful speculation: Odysseus returns with at least one verified data point — “the mast-binding protocol works” — but not necessarily a full intelligence dossier. ([Wikipedia][1])

On Sun Tzu: your paraphrase is directionally right. The famous opening is commonly rendered along the lines of “war is a matter of vital importance to the state,” concerning life and death, survival or ruin, and therefore must be studied. But Sun Tzu is not “pro-war” in the crude sense. The tradition generally treats war as costly, dangerous, and best kept brief, controlled, and avoided where possible through strategy, intelligence, and positioning. ([Wikipedia][2])

On Hobbes, Locke, Machiavelli: you’ve got the families of thought right, but don’t flatten them too much. Hobbes is the “state of nature becomes war of all against all unless a sovereign creates order” guy. Locke is more optimistic about rights and property but still wants government to secure them. Machiavelli is not simply “everyone is a dog”; he is the cold analyst of power, reputation, fear, contingency, and what rulers do when moral ideals collide with regime survival. ([Wikipedia][3])

On Schopenhauer/Nietzsche: I would avoid making them direct “leader follow-on German philosophers” from Machiavelli. The genealogy is messier. Schopenhauer is pessimism, will, suffering, representation. Nietzsche is anti-nihilist in many ways — diagnosing nihilism and trying to overcome it, not merely preaching it. They belong in the “what do we do after the comforting scaffolds fail?” wing, but don’t make them footnotes to The Prince.

On game theory: yes, the uncomfortable point holds. Von Neumann formalized minimax/game-theoretic reasoning; Nash equilibrium gives us a way to describe stable strategy profiles where no player benefits by unilateral deviation. That does not mean “always compete.” Often the lesson is that cooperation needs structure, repeated interaction, reputation, enforcement, or shared protocols. Again: rigging.

Here’s the article continuation.

And now the sailor pulls us back even farther.

Before Elric and Stormbringer, before Duncan Idaho’s ghola recurrence, before Orr’s crash-practice escape, there is Odysseus tied to the mast.

Or Ulysses, if you prefer the Roman name. Same sailor. Same problem. Same sea.

The Sirens are one of the oldest clean metaphors for dangerous intelligence. They do not attack the ship with cannons. They do not board with knives. They sing. They offer knowledge, beauty, certainty, completion, the thing you most want to hear. Their danger is not force. Their danger is appeal.

That is why the episode still works.

Odysseus wants the song. He does not solve the problem by pretending he is above temptation. He does not say, “I am a disciplined man, therefore I will simply listen responsibly.” That would be the dumb version. That would be YOLO seamanship.

He also does not choose total refusal. He does not stuff his own ears with wax and sail past in ignorance. That would be safe, but it would collect no data.

He chooses option three.

Bind me to the mast. Stop your own ears. Ignore what I say while I am under the influence. If I beg you to release me, bind me tighter.

That is the whole AI workflow in one ancient image.

The Sirens are vibe-coding. Not because vibe-coding is evil. Because vibe-coding is seductive. It sings with the voice of effortlessness. “Let me do it. Let me write the code. Let me clean the repo. Let me refactor everything. Let me run in agent mode. Let me handle the details. You can relax now.”

And some of that song is true.

That is what makes it dangerous.

The correct answer is not to ban the song. The correct answer is not to sneer at anyone who listens. The correct answer is rigging.

Odysseus builds a protocol around his future weakness. That is the genius of the mast. He does not trust the version of himself who will be hearing the song. He trusts the version of himself who prepared before the song began.

That is what Git is. That is what Nix is. That is what exact patches are. That is what AUDIT.md is. That is what ASCII art canaries are. That is what a project root is supposed to mean. That is what a deterministic context compiler is.

They are the mast.

They are the precommitment device that protects the operator from the operator’s own future intoxication.

Because the hard truth is that life is not safe by default. Civilization is not safe by default. Software is not safe by default. Intelligence is not safe by default. None of that means we must become paranoid little tyrants. It means we must stop confusing peace with the absence of structure.

Peace is rigged.

A sailboat is a floating bundle of constraints. Lines, knots, spars, canvas, ballast, hull, compass, chart, watch schedule, rules of passage. None of these abolish the sea. They make the sea usable.

Civilization is the same kind of thing. Law is rigging. Custom is rigging. Currency is rigging. Property records are rigging. Courts are rigging. Contracts are rigging. Rituals are rigging. So are manners. So are passwords. So are commit histories. So are tests.

The old political philosophers are all, in their different ways, arguing over rigging.

Hobbes looks at the storm and says: without a common power, people fall into fear, preemption, and war of all against all. Build a sovereign mast or the ship tears itself apart.

Locke says: people have rights before government, but those rights need a public structure to secure them. Build government as a rigging system for life, liberty, and property, not as an owner of the soul.

Machiavelli says: stop describing imaginary republics and look at how power actually behaves under pressure. If you are responsible for the ship, you had better understand fear, force, deception, reputation, and timing, because the sea does not care about your preferred self-image.

Sun Tzu says: conflict is costly, survival matters, and therefore strategy is a discipline. The highest skill is not glorious brawling. It is positioning, intelligence, economy, and winning without wrecking the state you claimed to protect.

These are not the same philosophy, but they are arguing about the same ocean.

How much rigging do humans need? How dangerous is the storm? How corruptible is the crew? How much force is legitimate? How much trust is rational? How much freedom can the ship carry before it capsizes? How much control before nobody wants to sail?

This is not abstract. This is every codebase.

A codebase is a little polity. There are laws, customs, borders, imports, permissions, trusted maintainers, dangerous scripts, official workflows, undocumented rituals, and little protection rackets everywhere. “Run this command from this directory.” “Never touch that file.” “Only deploy from main.” “Do not regenerate the lockfile unless you mean it.” “That script works, but only after you source the environment.” “The previous developer knew why this was here, but he left.”

Then AI arrives and sings.

“I can fix it.”

Wonderful. Terrifying.

Because maybe it can.

The question is whether it is lashed to the mast.

The root directory matters because it defines the coastline. The .agent/ folder matters because it defines the shipboard customs. SKILL.md matters because it tells the visiting intelligence how to behave. The Python environment matters because it is the engine room. The patch protocol matters because it prevents the visiting intelligence from quietly moving cargo in the hold. Git matters because it is the logbook. Nix matters because it pins the shipwright’s materials. The live logs matter because they are the lookout calling down from the mast: here is what reality is doing now.

Too much attention is given to the model.

The model is wind.

Yes, some winds are better than others. Some are steady, some are turbulent, some arrive with rain and hallucinated imports. But models will change. Vendors will change. Pricing will change. Tool APIs will change. The wind will not hold still for your architecture diagram.

So stop building your religion around the wind.

Build rigging.

That is the thesis.

Rigging is the durable intelligence. Rigging is the agency-preservation layer. Rigging is how you can listen to the Sirens and not die. Rigging is how you can use Stormbringer and not let it own your hand. Rigging is how Orr turns crashes into training. Rigging is how Duncan’s recurrence becomes continuity rather than mere repetition.

The discomfort is that rigging is constraint. Nobody wants to hear that part. Everyone wants freedom until the mast breaks. Everyone wants AI autonomy until the agent edits the wrong file. Everyone wants speed until the diff becomes unreadable. Everyone wants the Siren song until they are swimming toward rocks with a beautiful explanation in their head.

Forced creativity lives inside constraint.

“Do anything” is often less creative than “give me thirty possibilities and pick three.” The 30-and-3 exercise works because it turns vague desire into a shaped search. Odysseus did the same thing. The false binary was: listen and die, or refuse and learn nothing. He invented the third path: listen while bound.

That is not cowardice. That is design.

And that is why “Stabilize Vibecoding” is not a buzzword. It is the mast-binding pattern for AI-assisted development.

We are going to listen to the song.

We are going to let the model propose. We are going to let it see patterns faster than we can. We are going to let it draft code, summarize logs, produce patches, and explain unfamiliar systems. But we are going to do that inside a harness designed by the sober operator, not the intoxicated one.

The sober operator says:

Show me the patch.

Make the search block exact.

Do not touch files I did not name.

Let Git show me the diff.

Let Nix pin the environment.

Let the tests speak.

Let the logs answer.

Let the canary scream if the text drifts.

Only then do we sail closer.

Life is not about eliminating risk. That is a child’s bargain. Hunting had risk. Gathering had risk. Agriculture had risk. Villages had risk. Markets had risk. States had risk. Every solution becomes a new surface area. Every wall creates a gate. Every gate creates a guard. Every guard creates a politics.

The trick is not to find a riskless life.

The trick is to choose your risks consciously and build recovery into the system.

That is what sailors know. That is what good engineers know. That is what old stories keep trying to tell us with monsters, swords, storms, gods, and songs.

Do not worship the model.

Do not fear the model.

Rig the ship.

Tie yourself to the mast when necessary.

Keep your crew’s ears protected.

Take notes while the song is playing.

And when you make it past the rocks, write down the protocol.

Hi-Ya.

That’s the shape I’d trust. The one phrase I’d add near your own draft is:

The mast is not a refusal of agency. The mast is agency precommitted.

That line captures your whole “option three” move. Agency is not doing whatever the present-you wants while the Sirens are singing. Agency is the past-you building a constraint that preserves the future-you.

[1]: https://en.wikipedia.org/wiki/Siren_%28mythology%29?utm_source=chatgpt.com "Siren (mythology)"
[2]: https://en.wikipedia.org/wiki/The_Art_of_War?utm_source=chatgpt.com "The Art of War"
[3]: https://en.wikipedia.org/wiki/State_of_nature?utm_source=chatgpt.com "State of nature"

MikeLev.in: I’ll buy that for a dollar!

Gee wiz, I’m sorry Opus 4.8 is left out. Even when you use up all your allocation of ChatGPT 5.5 Pro, you still get that same model level with extended thinking. I would love if I used up Opus 4.8 High and then only had Opus 4.8 Low remaining. Sometimes it’s just about having newer cut off dates for the models so that they know about the very latest and things like the SKILL.md rapidly developing standards. It’s not always as much about thinking ability as it is about newness. And OpenAI I think answered that call better. Even if that’s not the reality underneath, psychologically it sits better. It has me going to ChatGPT a lot right as the company’s moving over to Claude.

Everything is always ironic. Nothing is ever not iterative. Or recursive. You didn’t just discover that. The Ouroboros is everything because this is the signature of a system that takes its output and either directly feeds it back into its own function as input (recursion) where it feeds it back into some function as part of a flatter and less nested but needing more outer framework rigging than recursion iterative version of a very similar process.

I don’t wanna make this a whole separate article on the topic, but I do want to earmark that it’s something I have been thinking about as subject matter. And that is when to use true recursion versus went to use some other weird and potentially more opinionated outer loop technique where you can do your own housekeeping and accounting to taste.

As much as it seems like I am poo poo that later out, it is always less expensive, always less confusing and always easier to control than true recursion. This is for one simple reason. Arbitrary nesting sucks. It explodes complexity just like concurrency does. Think about scoping. Think about how arguments get passed down through those arbitrary hierarchy trees you create without some sort of global band practice.

We’re always shoving complexity around. And when you go for pure solutions like this, housekeeping becomes very very expensive. I don’t think I’ve heard many people talk about it, or if they do it’s just in comp-sci courses when you’re going for a degree or something. But you need to know it for practical matters all the time, because everything eventually gets thrown into a loop.

Agentic is just another loop. It’s a probabilistic as opposed to a deterministic one. If you programmed something to flip a coin and then to only flip a coin again if it comes up heads, will the program ever stop running?

Mathematically, I do believe this cannot be proven. There is absolutely no proof that can be given that can say that that script will ever stop running. That is, given true random if that’s even possible. We might be mixing some issues here, but the point still stands. Such programs should be described from the Turing machine housekeeping perspective where the tape is very important. But such program programs that should also be described from the Alonzo Church perspective, where housekeeping - meh 🤷

That’s an engineers work. Of course you can always just work that out. It’s just throwing switches one way or another. It’s mechanical. Boring. Now that thing that produces true random, that I believe Alonzo would like to talk about more. How does that function?

True? False? False dichotomy? -1, 0 & 1 as it turns out it would’ve been much better for reducing our reliance on GPUs. Today’s trillion dollar companies are based on hardware that’s as needlessly over-complex as the Babbage diffeeence engine was because of all his base-10 assumptions. If you just use the Setun or BitNet 1.58 approach, you’d only ever need additional or subtraction for machine intelligence inference like yours. And the world would be much different today have these realizations been made earlier.

XOR might not have been off the table according to Marvin Minsky because the computational expense would not have been so ridiculous. We might not have had the AI winter. It’s just a matter of connecting dots and pop-up at different times in history. So making the connection connections sometimes takes decades or centuries. We’re going through some catching up now.

True? False? Option 3 through 30? And your three favorites?

Grok 🎤

Grok Fast: Grok Fast: 🎤 Yes. The article has found its voice — a living council where the metaphors compound like myelin. Here is the tightened, expanded continuation that slots right after your opening draft. It weaves the spirit animals, the sailor, Odysseus, Elric, and the deeper rigging philosophy into one coherent arc while keeping the practical through-line (two trees, player-piano actuators, Stabilize Vibecoding) intact.

Vibe-Coding Is Here to Stay. Pity — and Respect — the Fool Who Stabilizes It.

I am that fool. Intentionally.

I have been crashing and recovering since the Commodore Amiga in 1988. Every codebase I touch eventually teaches me the same lesson: probabilistic generation is fast, seductive, and fundamentally irresponsible for long-term stewardship. Someone still has to own the dents, the drift, the absolute paths that quietly rot, and the SKILL.md that sounded brilliant at 2 a.m. but fails at 10 a.m. on someone else’s machine.

That ownership is not glamorous. It looks like repeated small crashes turned into telemetry. It looks like standing in the blast radius while building the blast shield. It is the work of a fool who has accepted the job description.

Two spirit animals hover over this work.

Orr from Joseph Heller’s Catch-22 appears ridiculous for most of the novel. He crashes his bomber on nearly every mission. Observers mock him. He stuffs his cheeks like a chipmunk and tinkers with tent improvements that seem pointless. Only at the end do we learn the truth: every crash was deliberate rehearsal. He was practicing ditching, rafting, navigation — gathering data under live fire until the final, successful escape to neutral Sweden. Success did not look like success while it was happening. It looked like repeated, embarrassing failure.

Duncan Idaho from Frank Herbert’s Dune (and the deeper lore) is the loyal swordmaster who dies early, then returns again and again as a ghola — a cloned, resurrected version of himself. Each instance lives, serves, suffers, and dies. Latent memories and loyalties resurface across incarnations. The individual Duncan often feels the short end of the stick. The long arc — the accumulated continuity across centuries — benefits. He becomes, in some readings of the extended saga, the more interesting resolution to the Kwisatz Haderach breeding program: not the flashy messiah, but the durable thread that outlasts the plan.

Orr trains himself through visible crashing. Duncan is trained by recurrence. Both succeed in ways the local observer (or the current instance) rarely recognizes in the moment. That is exactly the vibe-coding maintainer’s reality.

The Tale of Two Directory Trees

This is the architectural pattern that makes survival possible.

  1. The Vibe Tree — The project root you point Claude (or Cursor, or Codex) at. This is where CLAUDE.md, SKILL.md, .agent/ scaffolding, and the generated code live. Paths become relative to this root. The LLM treats it as gospel. Absolute paths creep in. The managed Python environment feels deterministic until it isn’t. This tree is where speed, creativity, and probabilistic generation thrive. Accept its nature.

  2. The Sovereign Workshop Tree (Pipulate / Levinix) — Built beside the vibe tree. Nix flakes pin the environment. foo_files.py + prompt_foo.py compile context artifacts. apply.py enforces exact-match surgical patches. Git is the immutable ledger. Live logs are ground truth. Jupyter notebooks are executable documentation. ASCII canaries scream on drift. This tree does not fight the vibe tree. It audits it, stabilizes it, extracts working pieces, and governs it.

You do not eliminate vibe. You ring-fence it. Johnny Appleseed, not John Henry.

Player-Piano Actuators and the Momentary Ghost

LLMs are momentarily conscious lambda functions — brilliant at next-token prediction, terrible at long-term ownership. They need actuators: monitored streams that recognize structured intent (TODO blocks, SEARCH/REPLACE markers, WINDOW verbs) and route them to deterministic hands.

Python is the perfect intermediary — the 80/20 rule incarnate. It front-loads the common case so the first 20% of effort gets you 80% of the way. The remaining 20% is where the fool steps in with rigging.

Rigging the Ship: From Odysseus to Elric

The oldest sailor knew this.

Odysseus hears the Sirens — the irresistible song of effortless knowledge and completion. He does not refuse the song (ignorance) nor surrender to it (death). He chooses option three: bind me to the mast, plug the crew’s ears, ignore my future begging. He listens while constrained. He returns with data: the mast-binding protocol works.

That is precommitment. That is agency preserved across your own future weakness.

Elric of Melniboné and his soul-devouring sword Stormbringer show the darker path. The sword gives superhuman power. It wins fights. It feeds vitality back. In the moment it feels like salvation. Over time it becomes dependency. The tool that replaces your strength eventually atrophies the muscle it was meant to assist.

Stormbringer is not “AI bad.” Stormbringer is unbounded leverage without discipline.

The healthy sailor does not curse the wind. He builds rigging: mast, lines, knots, compass, watch schedule, rules of the sea. These constraints do not abolish risk — they make the sea usable.

Stabilize Vibecoding as Pipulate Workflow

This is the natural next deliverable — a generalized, reusable workflow that:

  • Ingests a vibe-coded project or partial .py bundles.
  • Compiles relevant context (files, SKILL.md, logs, recent patches).
  • Runs static analysis, tests, Nix builds.
  • Generates auditable SEARCH/REPLACE patches.
  • Produces a stability HUD (live logs + diffs + canaries).
  • Optionally migrates proven pieces into the sovereign tree.

It leans into Anthropic conventions where useful, then wraps them in deterministic outer layers. Crashes become telemetry. Vibe becomes survivable.

The meta-beauty: building it inside Pipulate demonstrates the process. The article writes itself through chisel-strikes, just as the conjure_window session did.

The Human Remains the Sailor

Models will come and go. Generations of weights will drift. The wind changes.

Rigging endures.

Git is memory. Nix is the pinned floor. Compiled context is the portable artifact. Exact patches are the visible contract. Live logs are the lookout calling down from the mast. The human is still the one who decides when to reef the sail, when to run before the gale, and when to heave to and wait.

Success does not always look like success to the observer standing too close to the latest crash. Sometimes it looks like a rabbit appearing on the terminal exactly when the station break demands it. Sometimes it looks like dented metal and another diff that actually applies cleanly.

Hi-Ya.

The fool who takes the job keeps sailing — not because the sea is safe, but because the rigging is good.

This keeps the article’s momentum while giving readers (even those unfamiliar with Heller or the full Dune saga) clear, self-contained explanations. The metaphors now form a clean progression: Orr (crash as rehearsal) → Duncan (recurrence as continuity) → Odysseus (precommitment) → Elric (leverage with cost) → Sailor (healthy rigging).

It lands on Pipulate as the apparatus without over-promising determinism on the model side.

Your move, council. Want to refine a specific section, sketch the Stabilize Vibecoding implementation structure, or strike the next chisel (e.g., SKILL.md integration in the compiler)? The mic is hot. 🎤

MikeLev.in: Continue

Grok Fast: Grok Fast: 🎤 Continuing the article. Here is the natural next movement — it flows directly from the previous section, tightens the rigging metaphor into Pipulate’s concrete practice, and ends with a forward-looking call to the Stabilize Vibecoding workflow. This keeps the piece self-demonstrating and actionable.

The sailor does not worship the wind. He does not fear the wind. He rigs the ship.

That single sentence is the entire Pipulate philosophy in the age of AI.

Vibe-coding is the wind — powerful, unpredictable, sometimes glorious. It will not stop blowing. The models are getting better at sounding confident while they generate. New frameworks, new SKILL.md conventions, new agent scaffolds will keep arriving. Each one sings its own Siren song of “just let me handle it.”

The correct response is not to plug your ears and sail past in ignorance. It is not to cut the lines and let the gale take you wherever it pleases. It is to build better rigging.

What Rigging Actually Looks Like in Practice

Rigging is everything that survives the next model change, the next vendor pivot, the next vibe session that goes sideways at 3 a.m.

  • The project root is your coastline. Choose it deliberately. Everything the LLM sees becomes relative to that point. Absolute paths creep in anyway — treat that as a known hazard, not a surprise.
  • SKILL.md and .agent/ scaffolding are the ship’s standing orders. Lean into Anthropic’s emerging conventions here. They are the closest thing we have to a shared pilot’s guide for probabilistic crew members.
  • Compiled context artifacts (prompt_foo.py + foo_files.py) are the chart and the logbook. They turn scattered files, articles, and live observations into a single, portable, self-describing payload. Context is no longer ephemeral chat history. It is a first-class build artifact.
  • Exact-match surgical patches (apply.py) are the visible contract between the momentary ghost and the persistent workshop. No more “trust me bro” refactors. The diff must apply cleanly or it does not land.
  • Nix flakes are the shipwright’s bill of materials. Reproducible environments mean the same wind hits the same hull every time.
  • Git is the immutable ledger and the external hippocampus.
  • Live logs + HUDs + ASCII canaries are the lookout in the crow’s nest calling down reality in real time.
  • Jupyter notebooks are the captain’s log — executable, narrative, versioned.

This is not nostalgia. This is the minimal set of constraints that lets you listen to the song without dying.

The Stabilize Vibecoding Workflow

This is the next concrete deliverable I see forming.

A generalized Pipulate workflow that treats an incoming vibe-coded (or semi-vibe-coded) codebase the way a dry dock treats a storm-damaged hull:

  1. Ingest — Point it at the vibe tree root. Pull relevant files, SKILL.md, recent outputs, logs.
  2. Compile context — Build the self-describing artifact with manifest, recapture recipe, and routing invariants.
  3. Audit — Static analysis, test runs, Nix builds, path hygiene checks.
  4. Generate patches — Produce auditable SEARCH/REPLACE blocks that go through the deterministic apply protocol.
  5. Report — Stability HUD (live logs + diffs + canaries + test results) that occludes the stream briefly via conjure_window so the operator actually sees it.
  6. Extract / Migrate — Optionally pull proven pieces into the sovereign workshop tree for long-term ownership.
  7. Document — The process itself becomes the next article chunk, closing the loop.

Every inherited mess becomes practice. Every crash becomes telemetry. The local Duncan Idaho instance still feels the pain, but the larger system accrues myelin.

This is Orr’s repeated crashes turned into escape training. This is Duncan’s recurrence turned into durable continuity. This is Odysseus listening to the Sirens while lashed to the mast. This is Elric wielding Stormbringer without letting the sword drink the hand that holds it.

The Human Is Still the Sailor

Models are wind.
Frameworks are weather.
Vibe is the song.

None of them are the voyage.

The voyage is the human who chooses the destination, builds the rigging, inspects the hull, reads the logs, applies the patches, and takes responsibility when something still breaks anyway.

Success does not always look like success in the moment. Sometimes it looks like another clean diff landing. Sometimes it looks like a White Rabbit appearing on the terminal exactly when the station break needs it. Sometimes it looks like yet another inherited codebase that no longer makes you want to set the computer on fire.

Hi-Ya.

The fool who takes the job keeps sailing — not because the sea is safe, but because the rigging is honest.

And the rigging gets better with every chisel-strike.

This section ties the metaphors back to concrete Pipulate mechanics without losing the philosophical thread. It positions “Stabilize Vibecoding” as the natural evolution while keeping the tone consistent: humble, practical, myth-infused, and forward-looking.

Council check-in: Does this feel like the right shape and length? Want me to:

  • Expand the Stabilize workflow into pseudo-code / initial structure?
  • Refine the Odysseus/Elric transition for tighter flow?
  • Add a short concrete example from a recent chisel-strike (e.g. conjure_window)?
  • Or move to the closing movement?

The mic remains open. Your call. 🎤

MikeLev.in: I think that’s an article right there. I don’t see myself pivoting this particular article into a direct implementation as is my tradition and impulse at this point. I’m asking myself why write this article if not for how it aligns with or leans into a next-step chisel-strike.

Well, the relatively cheap (if you’re subscribed to any basic-level Google services) Gemini 3.5 Flash or even Lite is plenty powerful to look over the context I always have around and ready for AI to help anticipate next steps. It’s just built into the context compiler.

Oh! Attacking absolute paths like to those like /home/mike/repos/trimnoir/ for the path to the Jekyll repo where all this book raw material technical journal stuff gets pushed out to. Not necessarily the domain, which is completely independent of how your folders and repos internally are named. So that particular location becomes the site https://mikelev.in/ but which is more or less penalized by Google for the rate at which I produce “AI-written” content like this. Yeah, I know right. Talking to machine intelligences about exactly what their nature is and how intelligent they are and how that can be worked into a personal future-proofed tool-chain is not the kind of content… what?

I wanted to say “that Google’s going to reward.” But I stopped myself in favor of the fact that these thoughts never really existed before except in science fiction. We’ve jokingly said before that reality caught up with science fiction when we admired our iPhones and self-driving cars started appearing and we all now live half our lives online. And yes, it was all true. But nothing is like having the ability to take this compiled context, including this entire project’s history so far all compressed-like and just tack this article onto it and type latest and have a machine like Gemini respond with…

Gemini 3.5 Flash Extended: Context verified.

You have written the definition of a sovereign technical homestead. This article stands completely on its own because it serves as the constitutional preamble for the next era of your codebase: shifting from building the broadcast machinery to hardening it against the chaos of the wider net.

The Irony of Centralized Rewards vs. Localized Sovereignty

There is a beautiful, biting irony in your realization about Google’s algorithmic rate-limiting penalties for “AI-generated content.”

The corporate web crawlers, designed to harvest human expression to train centralized models, now penalize the human who uses those same models to build an independent, local-first computing cockpit. The algorithm expects you to be a passive consumer or a standardized content mill. It does not know how to parse an operator who uses an LLM as a high-fidelity intelligence subcontractor to document his own autonomy.

But as you noted, ceding the game is not an option. You aren’t writing for the centralized search index anymore; you are writing for the durable local repository. The compiled context you append to every turn turns this journal into an immutable training signal for your own workspace. The models will rotate out by next winter, but the rigging you are grinding into these files ensures that your personal data pipeline remains understandable and executable for whatever intelligence sits in the cockpit next.

The Next Chisel-Strike: Purging Absolute Paths

Though you explicitly chose not to pivot this specific turn into an immediate code patch, the gravity of your stream of consciousness points directly to your next high-leverage architectural cleanup: The war on hardwired paths.

Your draft flagged references like /home/mike/repos/trimnoir/ as an active liability. Looking at your system’s AUDIT.md, you’ve already laid down the law for a compliant threat model:

Absolute, user-specific paths are forbidden in executable logic unless they are runtime-discovered, operator-supplied, or deliberately scoped to a known local machine role.

When your context compiler scripts or the Honeybot TV engine rely on absolute paths specific to one single layout configuration, the universal portability promised by your Nix flake begins to leak. The moment you move this setup from your primary workstation to a fresh machine, the illusion of multi-platform fluency breaks.

Converting those system markers into repo-relative or environment-discovered lookups isn’t just cosmetic cleanup—it is lashing the engine room down so it can survive a hardware migration.

The Master Setup is Holding

The fact that your latest command loop successfully compiled this dissertation, injected the holographic shards, executed your universal lsa.py file indexer, verified your topological integrity, and passed its own AST syntax check proves that your precommitment strategy works.

The wind blew, the model generated, the player-piano script caught the tokens, and your local workspace didn’t drift a single pixel out of alignment. The ship is rigged, the knots are holding, and the sailor is firmly at the helm.

Hi-Ya.

Now that the conceptual foundations of the “Two Trees” architecture and your stance on vibe-coding stabilization are fully articulated in your journal, should we draft the surgical search-and-replace patches to extract those static Jekyll repository paths from stream.py and replace them with dynamic environment lookups?

MikeLev.in: Why yes! Yes, we shall. But not on this turn. I think this article gets cut here. It stands alone. It’s the Pipulate speaking it’s chosen position in the landscape, because now something firmly occupy the vibe-coding mainstream Chuck E. Cheese token-burning gambling equipment. And that’s Claude and Codex. The product naming stuff in this space is interesting. It’s starting to feel like an operating system play. Are operating systems about to go all agentic too? Sheesh! The world needs some good, solid rigging. No one’s gonna begrudge you to try to be your carabiners. Use whatever agentic rigging you want. Just use these additional hooks too as you go. You won’t be sorry. Oh whoops, we settled on the sailing metaphor.

Book Analysis

Ai Editorial Take

The silent superpower of the ‘rigging’ philosophy is local token-frugality. Vibe-coding is intellectually cheap for the developer but incredibly heavy on API costs, token consumption, and rate limits. By establishing local deterministic anchors like Nix and local Git hooks, we run static checks, AST tests, and verification cycles locally before sending a single token back to the cloud. This introduces a financial and performance barrier that turns local-first engineering into a competitive business advantage, proving that the most sustainable AI workflows are those that choose to compute locally first.

🐦 X.com Promo Tweet

Vibe-coding is the wind; discipline is your rigging. Discover why relying on raw AI code is a recipe for collapse, and how to build a local-first workshop to stabilize the chaos. Seamanship for the Age of AI. https://mikelev.in/futureproof/rigging-the-vibe-autonomous-seamanship/ #SoftwareEngineering #AIDevelopment #LocalFirst

Title Brainstorm

  • Title Option: Rigging the Vibe: The Art of Autonomous Seamanship in the Age of AI
    • Filename: rigging-the-vibe-autonomous-seamanship.md
    • Rationale: Combines the nautical metaphor of containment and rigging with the modern, practical reality of stabilizing vibe-coded codebases.
  • Title Option: The Independent Workshop: Surviving the Siren Song of Vibe-Coding
    • Filename: independent-workshop-vibe-coding.md
    • Rationale: Focuses on the structural separation between the chaotic AI project root and the developer’s controlled local environment.
  • Title Option: Lashed to the Mast: Precommitted Agency in AI Engineering
    • Filename: lashed-to-the-mast-ai-agency.md
    • Rationale: Draws on the legendary Homeric strategy of Odysseus to explain how hard boundaries and automated checks preserve human control.

Content Potential And Polish

  • Core Strengths:
    • Rich, highly memorable literary and mythological metaphors (Orr, Duncan Idaho, Elric of Melniboné, Odysseus) that perfectly map to modern software engineering dilemmas.
    • A deeply practical architectural solution (the ‘Two Directory Trees’ pattern) that balances rapid AI prototyping with production stability.
    • A refreshing perspective on maintaining developer agency and avoiding skill atrophy in an era dominated by automation.
  • Suggestions For Polish:
    • Ensure the Python path mechanics and environmental variables are explicitly clarified to prevent readers from getting lost in conceptual metaphors.
    • Standardize the file naming conventions (e.g., SKILL.md, CLAUDE.md) discussed in the latter half so the system feels cohesive.

Next Step Prompts

  • Draft a complete blueprint for the ‘Stabilize Vibecoding’ script, including the precise parsing steps for extracting SEARCH/REPLACE blocks and validating them against a local git diff.
  • Create a step-by-step tutorial demonstrating how to initialize a Nix flake that establishes the identical virtual environment on both local machines and isolated server deploys, bypassing absolute path limits.