Journal 2025-06-06

Weightless Thought

Ok, Vibe Coding proper, that's mostly hands free on purpose. But recently I've done a fair bit where I've had a fairly solid plan (even if it isn't written down), just let the LLMs have at selected parts, in some vague approximation of systematic order. Not a dissimilar situation to working with other people. I've only very occasionally had a management role IRL, but have collaborated on loads of projects of different sizes and shapes over the years. To move forward you have to have trust in your colleagues. Ok, you occasionally encounter arseholes with some kind of destructive contrariness, or folks with more pressing issues on their mind. Through no fault of their own, they aren't fitting the role you expect. Fair enough, you get used to those kinds of unreliability, work around as necessary. You make allowances, and from a personal standpoint do your best to mitigate disaster, avoid winding up the proverbial río de mierda, senza paddle.

Then there's AI. I think it would be fair to say that although it lacks a sense of responsibility, accountability in the usual sense, it can evaluate and judge and make decisions. It's entirely on us how we project those things into practice. We are the cybernauts, we have our hand on the tiller.

I'm rambling right now because on the other screen I have Windsurf AI (their own custom VS Code build, plus a pretty good model that's free right now), ploughing away writing tests. I need to keep checking, easiest being Source Control tab, that it's not straying where I don't want it. I'm typing during a thoughtless wait. Not to be confused with thoughtless weight, that was the boss I had in my first proper job (long) after leaving school. He was a self-important, what passes for fat cat in Buxton, arsehole.

Aren't they good at making things up!!?

There's gaslighting and AI gaslighting. The other day I had a big push forward with #:semem, rapid progress. Too rapid. I was well aware that most of the material that Claude or whoever was producing would mostly only serve as placeholders, I'd have to go back over everything systematically. One chunk did get under my radar. A whole bunch of material I thought was getting persisted through SPARQL was in fact being looked after by the graphology JS lib. I had to look it up. But I've been careful to keep most things loosely coupled, so rather than revert-backtracking I can refactor. But still.

What prompted me to mention all this is I just realised that a feeling I get from working from these agents is much like that I've had with some of the things I've experienced in the past. A concrete scenario would be visiting a country with a culture that's far removed from what I'm used to (which, for someone that grew up in rural Derbyshire, is most). But a closer parallel would be some of the things I've tried studying. The things that take a suspension of disbelief. Ok, this test-building is taking too long, I'll have to intervene. So I'll dead-end the train of thought here by mentioning one of the more notable things I've tried studying (several times) : Category Theory. Yeah, that's what I mean by Weightless Thought. When things are seriously untethered. Mind-altering substances when you are not used to them; Category Theory; AI-assisted dev.

Journal 2025-06-05

You should be able to talk to all apps, surely..?

For some interpretation of talk.

The Joy of REPL

Read-Eval-Print-Loop

I do have a GUI in progress for #:transmissions, but that'll most just be an editor for now. Some of the things I've been trying recently are a bit of a pain just using the command-line directly :

That a bit of fun I was having with the Eye reasoner. It became clear I needed a bit more interactivity. Bring on the REPL!

That was playing with bits like this :

import clients from 'hyperdata-clients';

const client = createClient(provider, clientOptions)
const response = await client.chat([
            { role: 'user', content: message.content }
        ])

Journal 2025-06-04

So I might have fixed the path error I'd made for myself. This is a test post to find out. I'd better check image paths too. Here's Claudio having a walk -

Ok, a definite improvement. It has revealed another little issue. Escaping, that other bugbear. My pipelines need some escaping because representations of this content - markdown & HTML - are going through SPARQL queries. Looks like I've got a bit of it in the wrong place. While the image of Claudio resolves correctly in the index.html recent posts, that's not the case for the single-page renderings. The image link there looks like :

<img src=\"/images/2025-06/claudio-walk.jpeg\" alt=\"walking dog\">

Escaped quotes. Ops.

Eye Reasoner

That was pleasing. I've been wanting to do something with a reasoner in #:transmissions for a while now but never really had practical justification. I just did it for fun. Took about 30 mins.

The Eye Reasoner is Euler Path-based, works with N3. The JS lib couldn't be easier in use. Here's the Processor (pipeline node) which contains it :

(source)

Here's the transmission (pipeline) :

(source)

• and it in action :

Journal 2025-06-03

The Tensegrity Suite

It occurred to me that if anyone shows interest in the stuff I've been playing with then there needs to be a good place to discuss things. The domain (AI) is pretty hot right now, but my particular corner is niche. Still, things need to be public, must be easy to maintain. It occurred to me sticking things in Git would be useful. Then I discovered GitHub supports Discussions on repos. That'll do. So I've set up a repo called tensegrity and on it enabled Discussions. It's new to me, but I think it should work. If you are reading this then you should probably go say hello over there.

Bloody Paths!

What I have going on with this stuff right now is that a #:Transmissions pipeline reads content from markdown files in a particular dir tree, posts this off (lightly annotated with metadata) to a SPARQL store. This initial use case I call #:Postcraft, pulls this back out again and renders it as a static Web site. Like what you are looking at. This is massively over-engineered for a static site builder, but it's what seemed like a good sanity check for getting such data in and out of the store.

The thing is I've also got #:Semem looking at the contents of that store. This is intended as an LLM-oriented knowledgebase. I'd already got some bits in place, like generating embeddings from the content and use of them for semantic search in the vector store similarity sense.

I had a big push on this in the past week or so, sorting out the #:Ragno ontology for describing knowledgebases and maybe implementing a bunch of knowledge augmentation and retrieval algorithms. I say maybe because a large part of the coding was done by AI assistants, and they're not exactly great at checking their own homework. But this report on interactions gives me cautious optimism.

One thing I know for sure, this stuff is currently very fragile. And confusing. I don't know why I bothered asking ChatGPT for an illustration of this post because I could simply have taken a pic of my office.

So anyway, the bloody paths thing. To kick the tyres of #:Semem I needed a smaller set of docs than this blog stuff. I've hardly put any content in the #:Postcraft part of #:Semem itself yet. It will eventually look after the docs, but as of now, sod all there.

So I ran the #:Postcraft transmissions over it. Bugger! Totally berserk paths. The primary motivation behind #:Transmissions is to make complex processing easier to manage. However, the decomposition comes at a cost. Here are the current commands I have to run to render this site:

cd ~/hyperdata/transmissions # my local path
./del-dan.sh # clear SPARQL graphs
./trans postcraft-statics ~/sites/danny.ayers.name/postcraft #
./trans md-to-sparqlstore ~/sites/danny.ayers.name/postcraft
./trans sparqlstore-to-html ~/sites/danny.ayers.name/postcraft
./trans sparqlstore-to-site-indexes ~/sites/danny.ayers.name/postcraft

Here's the transmissions.ttl for sparqlstore-to-html :

@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix : <http://purl.org/stuff/transmissions/> .

:sparqlstore-to-html a :Transmission ;
   :pipe (:p10 :p20 :p30  :p40 :p50  :p55  :p60 :p70
          :p80  :p90 :p100) .

:p10 a :SPARQLSelect ;
     :settings :selectArticles .

:p20 a :ForEach ;
    :settings :resultIterator .

:p30 a :Restructure ;
    :settings :prepArticle .

:p40 a :MarkdownToHTML ;
    :settings :mdHTML .

:p50 a :Templater ;
    :settings :articleContentTemplate .

# store the HTML snippet
:p55 a :SPARQLUpdate ;
     :settings :updateArticleHTML .

# make the page
:p60 a :Templater ;
    :settings :articlePageTemplate .

:p70 a :PathOps ;
  :settings :filenameConstructor .

:p80 a :PathOps ;
  :settings :filenameExtension .

:p90 a :FileWriter ;
  :settings :htmlField .

:p100 a :SPARQLUpdate ;
     :settings :recordRendering .

Each of the :settings objects is a little block of statements. Each of the processors in the pipeline is a JS module. But each part is constructed simply, and I do have tolerable debugging facilities in place. It's just a bloody drag to trace through the pipeline nodes to find where I've done something stupid in path resolution. Hey ho. Claudio tells me it's walk time again. When we get back I may just have play with some of the other stuff that's cluttering up the office right now.