gavmor

I've experimented with _Munder Difflin_, but it didn't provide enough transparency. I went back to micromanaging with _Agents of Empire._

I've also made extensive use of Hermes' built-in Kanban plugin, but somehow it's better than Munder Difflin's, even though I've _less_ transparency into individual Hermes kanban agents in "bot" mode.

These were on different projects, with different teams, so I probably have wildly different definitions of done, and wildly different expectations.

But now I might try Munder Difflin again...

> the exact stack you've been working on that whole time happens to be the perfect stack

Yes, because it was really only ever about communication with myself, and with teammates. There are a thousand different ways of characterizing the behavior of the system, and this is the one that makes sense to me in my language.

No, because I am always looking to expand my vocabulary and characterize behavior in new terms.

Up to ~25, and they're not exactly "children", but I do have a coordinator agent that can selectively intrude on their sessions. I use `aoe` to spawn and communicate between worktree-isolated sessions:

https://www.pasteboard.co/XirzoTywU6lz.png

Oh, well this makes a lot of sense! Let's see how it handles node_modules.

What if the bits I'm transferring are "I don't remember the precise syntax, but here's a link to the relevant documentation."

Maybe this can help me prune my knowledge base of uninteresting pages. Then again, if they never consulted, are they really an obstacle?

I've been using a combination of `weave` and ad hoc "blackboard pattern" skills—some self-made, some borrowed—but I haven't really felt they've earned their keep. Maybe I'm not working in parallel enough, or else maybe I'm relying too much on a parent coordinator session to resolve conflicts.

Also the motivation behind CLIs and SDKs, right? And the way agents write Python regularly, these days, I am hopeful what can be offloaded to deterministic systems will be.

Remember that quality output is a necessary but insufficient property of a generative model.

Prompt-adherence is really hit-or-miss—especially if one lacks the visual vocabulary. Likewise with coding, I find junior devs don't think to prompt re: respecting this-or-that interface, or refactoring to point-free style, etc.

So, as others have said, the artist knows better.

Thanks, it introduces a little "jitter" that keeps the egg from rolling down the same face of the ridge every time. Possibly, the same could be accomplished with a judicious application of the temperature parameter.

But how to tell the model which section is supposed to be populated with spicy tokens?

Nice! I use an old madlibs library I built for D&D: https://github.com/gavmor/Dunmanifestin

"A DDOS on free resources" is called "moral hazard", AFAIK.

It's not saying there's something material out there which is relatable—it's saying that there's some ontological category, i.e. some Platonic or geometrically congruent notion, that is representative (if not constitutive) of the experience of being you.

I'm decompiling an obscure 1998 computer game using an LLM agent skill that I'm simultaneously developing from papers and books on reverse-engineering (a subject I've never previously engaged with) with the aim of migrating it (well, at least its assets) to the browser: https://esoteria.pages.dev

Here's the skill: https://github.com/gavmor/x86-cpp-reversing-skill

It's all slop, but it's battle-tested and producing results. It's quite fun and inspiring to see some of these assets like textures and geometry that are improperly decompiled, bit shifted or something like that. produces a lot of abstract, glitchy art.

To make sure that my process and results are reproducible, I've gotten back into maintaining Concourse CI pipelines. They were very useful when we were shipping a fork of k8s for VMware, and now they are a fun way of shipping cyberpunk billboard sprites to Cloudflare buckets.

I got back into Concourse in order to attempt a more rigorous approach to generative AI experimentation as well. Unfortunately, there are just so many odd techniques, configurations, loras, and utilities striking my fancy that my experiment pipelines have exploded into the dozens, and Concourse is not a large enough or a high-level enough organizing principle.

Spoiler alert for the dark forest trilogy but the overall series thesis revealed at the very end is that the human capacity to extend goodwill towards the unknown principally rescues us from the dark forest.

It was the oppressed daughter of the scientist whose first act of extending trust to an uncontacted alien species set on course the events that would be uniquely ours in defiance of the dark forest theory.

Ultimately, our two species do come to peacefully cohabitate. This would not be possible if we all thought as the unknown third species who destroyed the star targeted by the spell.

Well, for non-general tasks, of course. For example particular tooling that's required for the environment.

I will often make a skill out of the docs for any of the frameworks or libraries that we're using but with which I'm unfamiliar. When I'm creating that skill, I focus on idiomatic implementation and usage. It's not enough for the code to work—I want it to work "with the grain" and "through the front door", as it were.

By default, these models are just all too willing to reinvent the wheel and monkeypatch as they go.

If your "opt-in platform features" and "interface to allow permissioned access to data and capabilities between different apps" is more expressive/discoverable than eg Cloud Foundry's "Service Broker" approach[0], then I am pretty excited! I run a lot of disparate services which don't interoperate except through explicit workflow automation pipelines (I use ConcourseCI to eg upload images to Immich [1] albums, but others might use n8n[2] for the same purpose).

The "workflow automation" approach is a lot of resource overhead and broker-config maintainance, but my kingdom to be able to arbitrarily compose apps' states, eg commutimemap.com + Craigslist.

0. https://www.cloudfoundry.org/technology/open-service-broker-...

1. https://github.com/gavmor/immich-concourse-resource

2. n8n.io

What's the transition threshold at which paying down tech debt becomes worthwhile? Maybe it's a gradient.

I believe the conspiracy was real, but was itself an emergent manifestation of the conspiracy hunters' paranoia.

As the occultist Agliè explicitly champions, "in its loftiest sense syncretism is the acknowledgment that a single Tradition runs through and nurtures all religion, all learning, all philosophy". He asserts that "true esotericism does not fear contradiction".

None of what was published could falsify the syncretic paranoia-therefore whatever existed was the cult, since no tradition could be excluded.

My agent didn't like it. Indirection causing noise and failure outweighed the token savings.

https://regular-reviews.pages.dev/rtk

Oh, of course. Brilliant.

I'm thinking more in terms of the case where my coworkers' agents aren't working via graft, and changes are made without the post-edit update hooks.

Is this still cheaper when stale?

I don't know anything about investing, but I know a lot about naivete. :)

Or is it just an unproven attempt? Seems like a pretty straightforward value proposition. Caveat emptor.

It takes place on another planet, and isn't alien biology "science" speculation, enough?

Besides, it's not even her best work.

Looking forward to reading your story! You might consider Ted Chiang.

I like setting arbitrary project milestones or timelines. They don't have to kill the project, but it's good to cast efforts in relief against external developments.

My daily driver is Agent of Empires (https://github.com/agent-of-empires/agent-of-empires)

I just started experimenting with GSX and GSXUI

https://github.com/gsxhq/gsxui

https://github.com/jackielii/structpages is what I might call a framework that GSX sits nicely in.

Also one ai haven't tried: Templ.

https://github.com/a-h/templ

"DRY" and "KISS" are, possibly, the least interesting principles to which a software designer might adhere.