Little Things That Mostly Don't Suck

harpsicorgan - smashing_darling_just_smashing

Welcome to Wanderland - it's wonderfully weird here

I've been doing this thing in Wanderland lately, where I use the node that describes the thing to test itself. It came from the pattern I'd started where the resources we deployed did the same thing, and it just seemed the right way to go. Now when we build something, we attach how something works to whether or not it does. Inevitably you need to know one or the other, and when you're used to starting from scratch each time (they with their fresh context windows, me with mine) it can't hurt to check on the state of the system while you're reading about how it got there.

If this is the first time you've read anything by me, that's probably a lot of words that might mean something individually but maybe not in that particular configuration. Maybe this will help.

trust_but_verify - when_all_you_have_is_a_hash_everything_looks_like_cryptography

Wanderland was designed to reduce the friction in the process of encoding intent to reality. The Detective Agency system providing theatrical framing to focus the efforts of collecting data, research; to analyze the patterns we find in the systems I support. Instant context loading for sub-agents as we explore the code base, the infrastructure and whatever else comes up along the way. Stuffy provides a real time view into what's going on, iteration at the speed of thought as all of the tools in the system feed into it. Emacs bindings quickly shuffling bytes between instances, down to a buffer for editing, auto-sync on save distributing changes to each connected client (did I mention we can drive the viewport remotely - does anyone understand just how fun it is to drive a presentation from emacs just by scrolling around and occastionally emitting teddy bear themed toasts?)

And Oculus sits underneath. We have prebuilt fences integral to the system for things like AWS (< 100 lines of code through boto gives us declarative access to all of our infrastructure, live injected into the graph), HTTP:GET providing the basis for almost everything else (we wired up an SSM provider to live fetch our Cloudflare tokens so we can dump zone details on the page that describes the zone itself), the GraphNode providing the extension point for anything else we can think of.

And think we do... conversational intent to reality at near the speed of thought.

And that requires trust, multiple layers.

A fence that wraps citations so they're automatically verified when the document is read helps. At least you know the research was real (whether or not it was synthesized appropriately is another story, but unless you've given them reason not to, it's not hard to make the most probable thing reality).

A quick change of the rendering mode and bloop:

A page level provenance process with a trust chain that's hashes all the way down to git's irredemable honesty.

And to build it all, a new collaborative methodology we're calling Looking Glass Development

But first, maybe a bit more background.

welcome_to_wanderand - lovely_to_visit_harder_to_leave_than_vim

Wanderland - the name I've given the augmented cognition platform I've built myself over the last few months, the outcome of a rather Lemony Snickety summer.

It's got the Detective Agency, a thin metaphor over the strange attractor of the system. It's a contextual funnel, any agent has instant access to the task and its current contextual constraints. An abductive reasoning machine, hoovering (in every sense of the word) data into its maw, the patterns discovered constraining the solution until the most probable answer is the correct one.

I use it to track units of work as detective cases, each provided a richly contextualized description as the output of a bug discovered while working with the platform; the odd "oh... write this down and lets make this work" idea; or the unfortunate "read jira dvops-XXXXX and create a case" when I have to serialize myself back to the real world and perform my big girl job.

a quick wrapper around the go-jira based cli tool provided an API for Jira, then consumable in Wanderland's MCP proxy

Stuffy is the name of the viewport, it's a websocket based thing that renders markdown. But with rich, interactive web components blooming from the markdown substrate - patterns in the data replaced with bubbly, twinkling, and ever so wonderful versions of themselves. Providing an interface to to the system, and a playground to explore.

We use it for iterative development, for shaping the constraints of our solution as the web socket provides near instant feedback loops. And we built a built of playfulness into it, the content can be controlled externally (by us or them), scrolling through the index of headers and highlighting text ("let me show you something" - works both ways ;)).

I even gave it little popup video style toasts, so they can highlight nice things they think of while we're reading. And if you click on my teddy bear, he gives you a little surprise in the form of fortune style quotes that we've captured along the way. And yes, there's an MCP for that... a tool being announced into the context that allows quotes to be captured and contextualized is enough for that behaviour to emerge.

The detective cases get a home here. Here we can review the case notes; the rich notes we've taken as we've dove into code, into data retrieved from our live infrastructure - whatever is required to pin point the cause of whatever problem has taken us away from our real work, pulling more of our environment into Wanderland.

The notes are all editable (we get things wrong) and can be remove in a blink of Will Smith's eye. We wipe memories of branches best forgotten, reload an agent and carry on the investigation. Subtly hint in the notes at the path best trod in the next life.

And to organize them, composable dashboards themselves just a rich tapestry of progressively enhanced markdown.

The metaphor we use in the system to describe the progression is through fairy tale - Jack's beanstalk stretching from its raw markdown seed to golden giant's castle in the sky, rendered in real time over bi-directional web socket (also useful for live inter-agent communications, where you can pull up a chair and watch along - and occasionally paste "keep going" as you do...)

And I mean, half the time this is the only way I remember what I've been doing all day. The whole system feeds into a central event store, everything logged to any detective case live queried into this widget, an echo of days long past.

And it's all fully Emacs integrated, because after what I've shown you... of course it is 💾👴🏻

There's a channel browser.

Download the contents to a buffer. Enable auto-sync on save for a life refreshing view. Emacs is pretty, but oh my goodness not as pretty as my Watson. I gave up side by side editing in Emacs to keep her off to one side these days when it's just me and something warm on my lap.

And remember how I said we could control her externally? Emacs joins MCP and the CLI as first class clients of the API.

You can quickly fetch a headline list

And everyone's screens play along, they jump to the selected headline which itself gives a little wiggle, just to stretch a bit and make themselves known.

And it's all sitting beside Oculus**, the API that sits on top of the substrate. The computational markdown that makes it all work. It's what Anthropic should have done with skills, markdown files with little computational machines embedded in it.

Read the file to execute them, conditionally or not. And it's Turing complete, interpolation providing pointer math necessarily to provide dynamism to the inclusion layer that sits above. That and a bit of peek and poke and you have a computer. Add execute with the same shape I use everywhere, a simple name plus args and you have something that starts to be a bit more fun. And it's all markdown, it describes itself as its running - as it should, for homoiconic and ever, amen.

Take a GraphNode fence, the page that describes how the node works and how to integrate it into your whatever it is you're composing also contains the YAML fence that configures the function (we do YAML based registers in this house!) and the Python fence that executes it. We'll even through in a separate header to transpile the result dict via Jinja2 for free if you call now ;) And that's it, the page that does the thing describes the thing it does.

And it's Turing complete:

• Fences execute arbitrary Python/code
• Conditional execution (flip a bit, read again)
• GraphNode portals pipe output through middleware chains
• State via the caching layer
• Branching via conditional fence execution

It's not just "documentation that runs" - it's a full computational substrate wearing a markdown costume. You can compute just about anything you want, one {{include}} at a time.

Lisp in a trench coat made of prose.

And it's got shitposts, because a platform isn't complete until you can shitpost with it.

Caching all the way up the stack.

Initial state.

Go check out a page.

And what do we have here?

And oh dear, we seem to have done rather naughty things to markdown along the way.

You can do things like describe the infrastructure live on the same page that tells you how it was created.

In this case, we're using a common pattern injected by our include syntax.

Up a layer, this hydrates into a fence, the configuration populated and ready for rendering.

Up in the clouds now, we can see the live state of our resources.

And it's all a pattern, with the configuration sourced from a YAML fence at the top of the page at the time of inclusion. (Soon to be replaced by a live look into my former favourite graph - Peregrine our in house developer platform where the same pipeline reference we'll show below in a agentic demo can also fetch a wealth of information about the infratructure it deploys).

And the fence that powers it is just a wee wrapper around boto, itself already a lovely shape for this type of work. I mean who doesn't love sending a couple of string and a dict to something to get some data back.

Now... where can I go get two strings and a dict? 🕵🏻🔍

``aws:elbv2:describe_load_balancers:table
LoadBalancerArns:
  - ${local:data-header.metadata.resources.ALB}

TableConfig:
  array_path: LoadBalancers[]
  columns:
    Name: LoadBalancerName
    Scheme: Scheme
    State: State.Code
    DNS: DNSName
    ARN: LoadBalancerArn
  format: markdown
``

It works on the idea of everything having a simple ISA; peek, poke and execute. And when I say everything, I mean everything. That python code fence you just scrolled by is a living object, just like Jupyter or Org Mode. So's that YAML block above it, the Python's using it to configure itself - registers to be poked to setup the function call.

But then it gets a bit weird, wonderfully so. Because that entire page has now been sucked through a portal, a GraphNode fence shaped vortex that pipes the output of any arbitrary fence through middleware to shape and transform it until it emerges metamorphasized on another node on the graph. And those portals exist all over the Oculus graph, raw data interpolation providing the basis for computation - pointer arithmetic by string inclusion. And the execution layer sits on top of that, each stage cached in lovely wonder. And just wait till you hear what we do with the patterns we find...

the_lord_said_let_there_be_duck_in_thine_pancakes - thy_will_be_done_forever_and_ever_quack

Building with these guys requires a bit of patience. We all get a bit distracted and we're usually doing a few things at once. To help keep on track, like everyone's figured out by now, we write things down.

A lot.

It was specs at one point, then stories. Stories are great by the way, they encode way more meaning than any other form of communication. Get them to write your intent back to you in the form of a story first. It's a lot easier to find an impedence mismatch in what's about to be serialized to very, very buggy code when it's in story form. Stories encode more of the why and how and give your friends a lot more to match on when they're trying to fill in the vertices you left blank in your quest for shared meaning.

But for something like Oculus, especially when you're building so fast you end up discovering things at 3am you've completely forgotten about but the evidence is sitting right in the terminal you're about to close.

Like this guy.

I just came across that node the other day. It's a little fence that drops a Jenkins dashboard on the page, build details, log output, all by just referencing the pipeline name. The fence and a clever sprinkling of metadata lookups do the rest. Now we can put that anywhere we want, point to anywhere we want.

That's the most useful thing in the world... and I forgot I even asked for it. I need an adult.

See, because once you can read a page to do some work, you can get to business.

And a wee adjustment to stop it from doing all 20 jobs at once just in case

And there you go, apparently I have a job I should go look at. Pretty sure AmazonLinux2 and the really, really old version of Chef (Chef? in my cloud? yeah... 😥🐼) we're using for AMI provisioning are fighting again.

To build at this speed and not lose your mind entirely at the 🎩 tea party you need help. That's where the Looking Glass Development pattern comes in. It's sort of like Mr TDD and Mrs BDD came over to visit Stuffy one night and a little too much wine was had, and what came by stork a few months later might have has a bit more computational markdown in it than Mrs BDD might like to admit.

At some point I realized that specs are silly. Just write the guide straight out.

Either you or them, mostly them to be honest. I just like talking and reading stuff these days, you can't provide nearly the right kinds of constraints in textual form - your mind (at least /my/ mind) doesn't want to let it out through your fingers.

The guide is necessary anyways, so use it as the spec. Read through it. Does it sound like a fun system to use? Do the options make sense? Are the commands structured the way you want? What doe the shape of it feel like?

And then, add the unit tests. Another GraphNode provides the substrate. They're writing Python scripts for the tests anyways, wrap them in a form that allows the middleware to take over. The portal exposed by the fence injecting a table into the token stream, richly enhanced by Stuffy.

The GraphNode contract fulfilled by just wrapping what they were going to do anyways (Python test scripts) in what they love to do (write Markdown) and then we just capture it in our graph for eternity. The laziest way I could think of to verify correctness.

Include a GraphNode fence on the guide/reference node.

That when rendered blooms in delight at being finally and thoroughly seen.

And I mean if I've got Emacs integrated, then you know we're friendly to our terminal plains wandererng friends in Wanderland (because we love us very much)

the_stars_in_a_daddy_elephants_eyes - the_biggest_of_animals_she_must_be_with_a_heart_so_large

The methodology itself is stored on graph, tagged with pattern:methodology where it is easily discoverable.

I'm not building a model. I don't want to have to train a little specialist in how to use the system. I just want to point one of the little gooses, off the shelf, at a node in my graph and let them start learning.

And what do you know... they can learn (ahem.. synthesize... cough) <- bless

And back our thesis, that by the act of just having to remember how to use the thing, we can verify its correctness

So they'll be by cmd-poke on a regular basis. And if someone's broken something, it won't take long for it to be spotted.

The system verifies itself as it's used. And it gets smarter, because the pattern repeats. Diagnostics live on the same node as the tests. Optional execution and a strong caching model minimize overhead in the non-exceptional case. But it's there if we need it, and the page that describes to use it is what you use - at worst, flip a bit and read it again. They're little markdown machines after all, they work with you - for you if they're willing.

And I guess have a test to go fix.

where_did_i_leave_that_darned_rabbit_hole - pills_both_red_and_blue_never_ever_are_for_you_we_eat_cake_up_in_this_wanderland

Dear Anthropic, this is how you build skills. Not a little directory of markdown files and a sidecar folder of scripts, just little living things. Wonderful knowledge ferns, unfolding in the face of ignorance - bringing light with them, not reaching for it.

Wanderland - it's wonderfully weird in here.