NoRaincheck

Self-Hosted Agentic Engineering

Sun, 13 Sep 2026 00:00:00 +0000

Recently I’ve been playing around a lot more with local-first software from kenn-io. I have been enjoying it a lot, and it has made me think about the viability of single-software-engineer ’teams'.

The key parts are:

agentsview is tremendously helpful in measuring and assessing the quality of agentic sessions, which is important when optimising your harness and the tooling around it (e.g. if you are using the Pi harness).
roborev is incredible as a local-first tool. I now essentially have it running on all my personal projects as an async (in the background) way of ensuring code review is done on my commits. Even when working with a team, this is an amazing piece of software since it allows/enforces reviews before pushing/working on a PR in your team’s centralised version control.
kata is an interesting alternative to beads. Although I haven’t used it in anger, I can definitely see its applicability, particularly in managing issues and the like locally as opposed to being dependent on a SaaS platform. Even using it as a local Trello (where your agents can access tasks and receive feedback) is useful enough as a tool.

Outside of the kenn-io tooling, I’ve also been looking at LeafWiki as a simple locally hosted wiki. Combined with a simple Go server that allows for scaling to zero (e.g. self-hosting the wiki or an MCP server), it has really allowed local development to take off without worrying too much about local resource consumption.

Reflecting on Mitchellh's AI Adoption Journey Blog Post

Sun, 16 Aug 2026 00:00:00 +0000

I’ve been re-reading Michellh’s blog post and reflecting on my usage of SKILL and Agentic coding, and have realised its somewhat similar and there are lessons I can learn.

Chatbot Sucks

The interactivity of chatbots is nice when you’re exploring something. However it is rare that you are exploring something when you are trying to deliver with agents. Instead the pattern ends up being:

Build a prototype
Review a prototype
Re-build the prototype

LLMs have gotten so fast, so quickly, that in the interest of speed having prototypes are cheap (think about the Github graveyard of ideas).

LAN Messenger and Agents

Sat, 08 Aug 2026 00:00:00 +0000

Been thinking about home-lab setups for agents and finally settled on: pi-msg.

Advantages:

Serverless. Uses XEP-0174 for peer-to-peer messaging — no server required.
Simple. You chat with the bot like you’re chatting with someone.
Easy to extend. Create a new agent by pointing to a new project or workspace.

Disadvantages:

Limited parsing. Depends on client support — full HTML rendering has historically been uncommon in XMPP clients.

Still thinking about the approach:

Notes on Resizing Images

Sat, 18 Jul 2026 00:00:00 +0000

Notes on Resizing Images

July 2026

Given the influx of AI and readily available tools for things like super resolution (e.g. RealESRGAN), better ways to enhance images when resizing downwards becomes important as well.

The broad idea we should use looks like:

 1orig_w, orig_h = img.size
 2new_h = round(TARGET_WIDTH * orig_h / orig_w)
 3
 4# Gaussian blur pre-filter for anti-aliasing
 5blurred = img.filter(ImageFilter.GaussianBlur(radius=0.5))
 6
 7# One-step Lanczos downscale
 8resized = blurred.resize((TARGET_WIDTH, new_h), Image.LANCZOS)
 9
10output_path = OUTPUT_DIR / f"page_{page_num:03d}.png"
11resized.save(output_path, "PNG", optimize=True)

Where setting something like radius being related to the size of the image scaled. For example, if the resulting image is half the size log the original image, a radius=0.5 is probably appropriate. Whereas if it is 1/5 of the size maybe radius of 1 to 1.5 is better. If you’re after an equation, radius=math.log(scale) is pretty close to the target.

Beating FastAPI

Wed, 15 Jul 2026 00:00:00 +0000

One thing which Go does a lot better than Python is single binary deployments. As an experiment I thought, why not have a way to package up Go as part of a Python package, similar to maturin - and also have a way to spin up a Python webserver that is packaged as a Go binary.

The results were definitely interesting:

Go binary had 9x more throughput than stdlib Python’s http library, and ~5x more throughput than FastAPI
Idle memroy usage was `3x higher for FastAPI, and the peak memory usage was ~2x higher than Go binary

Of course the pocket python restriction may be too much for more complex applications.

Skills are meant to be vendored

Sat, 11 Jul 2026 00:00:00 +0000

Skills are meant to be vendored

July 2026

Agent skills aren’t ‘code’ which you use as-is. They’re designed to be vendored, forked, modified for your use.

Go copy them and modify them! Something has been ’lost’ in the software community where there is this obsession with ‘DRY’.

But seriously, SKILLS are the equivalent of writing a gist or dumping something to pastebin. Stop taking it so seriously.

With that in mind, teams that insist on a harness via a skill or Claude plugin - to me that is madness. You’re standardising on how a person should write their code, or “work”. Unless the goal is for everyone to be a prompting machine I think thats the wrong outcome.

Vibe Benchmarks

Sat, 04 Jul 2026 00:00:00 +0000

Vibe Benchmarks

July 2026

A quick round of informal benchmarking across a few local coding models. Nothing rigorous — just a few problems run through each model and seeing how they handled it. The goal was to get a sense of the trade-offs between quality, speed, and practical usability.

The models

Qwen Coder Next — the best quality by a fair margin. It understood the problem, produced clean code, and generally got it right on the first try. The problem is that it’s too large and too slow. The latency was noticeable, and the larger context windows it supports actually work against it — with more context comes more tokens to process, and the slowdown compounds.
Qwen 35B MoE — the best on balance. It matched Qwen Coder Next on most problems, was noticeably faster, and didn’t suffer from the same context-window bloat. For practical daily use, this is the sweet spot.
Cohere North Mini — extremely fast. Almost instant responses. But it failed to solve several problems that Qwen 35B solved after one or two turns. North Mini kept going in circles — same wrong approach, repeated, unable to course-correct. Speed is great when it works, but not much use if it can’t actually solve the problem.
Qwen 27B — too slow for my taste. I’d need to try it again under different conditions before forming a firm opinion. It had decent quality but the latency was a real drag.
Gemma MoE — okay. Nothing wrong with it, but Qwen models were consistently higher quality. Gemma felt like it was trying its best but falling short on the harder problems.

TL;DR

Qwen Coder Next is the best. Qwen 35B MoE is the best on balance. Cohere North Mini is extremely fast but unreliable on actual problem-solving. Gemma MoE is fine but Qwen wins on quality. Qwen 27B needs another shot.

OpenCV 5 Python Bindings Is Here

Wed, 01 Jul 2026 00:00:00 +0000

OpenCV 5 Python Bindings Is Here

July 2026

OpenCV 5 for Python has finally been released to pypi and comes with QoL for running large models through their pipeline. One interesting way to use this pipeline is to use SAM model with LaMa together in a single code base

1sam_result = sam_segment(img)
2if sam_result is None:
3 print(" SAM failed, aborting")
4 return
5mask, point_coords = sam_result
6
7inpainted = lama_inpaint(img, mask)

Where each of the functions are:

 1
 2def sam_segment(img, point_coords=None):
 3 """Segment object using SAM2.1 with point prompts."""
 4 encoder_path = MODELS_DIR / "sam_encoder_v2.onnx"
 5 decoder_path = MODELS_DIR / "sam_decoder_v2.onnx"
 6 if not encoder_path.exists() or not decoder_path.exists():
 7 print(f" [!] SAM models not found in {MODELS_DIR}")
 8 return None
 9
10 t0 = time.time()
11 h, w = img.shape[:2]
12
13 scale = SAM_IMAGE_SIZE / max(h, w)
14 new_h, new_w = int(h * scale), int(w * scale)
15 resized = cv.resize(img, (new_w, new_h), interpolation=cv.INTER_LINEAR)
16 padded = np.zeros((SAM_IMAGE_SIZE, SAM_IMAGE_SIZE, 3), dtype=np.uint8)
17 padded[:new_h, :new_w] = resized
18
19 pixel_values = padded.astype(np.float32) / 255.0
20 pixel_values = (pixel_values - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225]
21 pixel_values = pixel_values.transpose(2, 0, 1)[np.newaxis]
22
23 encoder = cv.dnn.readNetFromONNX(str(encoder_path), engine=cv.dnn.ENGINE_NEW)
24 encoder.setInput(pixel_values, "image")
25 image_embed = encoder.forward("image_embed")
26 high_res_0 = encoder.forward("high_res_feats_0")
27 high_res_1 = encoder.forward("high_res_feats_1")
28
29 if point_coords is None:
30 point_coords = [(w // 2, h // 2)]
31 point_labels = [1] * len(point_coords)
32 print(f" Point prompts: {point_coords}")
33
34 scale_x, scale_y = new_w / w, new_h / h
35 pts = np.array([[[int(x * scale_x), int(y * scale_y)] for x, y in point_coords]], dtype=np.float32)
36 labels = np.array([point_labels], dtype=np.float32)
37
38 mask_input = np.zeros((1, 1, 256, 256), dtype=np.float32)
39 has_mask_input = np.array([0.0], dtype=np.float32)
40
41 decoder = cv.dnn.readNetFromONNX(str(decoder_path), engine=cv.dnn.ENGINE_AUTO)
42 decoder.setInput(image_embed, "image_embed")
43 decoder.setInput(high_res_0, "high_res_feats_0")
44 decoder.setInput(high_res_1, "high_res_feats_1")
45 decoder.setInput(pts, "point_coords")
46 decoder.setInput(labels, "point_labels")
47 decoder.setInput(mask_input, "mask_input")
48 decoder.setInput(has_mask_input, "has_mask_input")
49
50 masks = decoder.forward("masks")
51 iou_predictions = decoder.forward("iou_predictions")
52
53 best_idx, best_score = 0, -1
54 for i in range(masks.shape[1]):
55 sig = 1.0 / (1.0 + np.exp(-masks[0, i]))
56 area_ratio = sig.mean()
57 if 0.02 < area_ratio < 0.80:
58 score = iou_predictions[0, i]
59 if score > best_score:
60 best_score = score
61 best_idx = i
62 if best_score < 0:
63 for i in range(masks.shape[1]):
64 sig = 1.0 / (1.0 + np.exp(-masks[0, i]))
65 area_ratio = sig.mean()
66 if area_ratio < 0.95:
67 score = iou_predictions[0, i]
68 if score > best_score:
69 best_score = score
70 best_idx = i
71 if best_score < 0:
72 best_idx = int(np.argmax(iou_predictions[0]))
73
74 mask_logits = masks[0, best_idx]
75 mask = (1.0 / (1.0 + np.exp(-mask_logits)) > 0.5).astype(np.uint8) * 255
76 mask = cv.resize(mask, (w, h), interpolation=cv.INTER_NEAREST)
77
78 kernel = cv.getStructuringElement(cv.MORPH_ELLIPSE, (15, 15))
79 mask = cv.dilate(mask, kernel, iterations=3)
80
81 elapsed = time.time() - t0
82 coverage = (mask > 127).mean() * 100
83 print(f" SAM: IoU={iou_predictions[0, best_idx]:.3f}, coverage={coverage:.1f}% [{elapsed:.2f}s]")
84 return mask, point_coords

 1
 2def lama_inpaint(img, mask):
 3 """Remove object using LaMa inpainting model."""
 4 model_path = MODELS_DIR / "lama.onnx"
 5 if not model_path.exists():
 6 print(f" [!] LaMa model not found: {model_path}")
 7 return None
 8
 9 t0 = time.time()
10 h, w = img.shape[:2]
11
12 resized_img = cv.resize(img, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
13 resized_mask = cv.resize(mask, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
14 _, resized_mask = cv.threshold(resized_mask, 127, 255, cv.THRESH_BINARY)
15
16 image_blob = cv.dnn.blobFromImage(resized_img, 1 / 255.0, (LAMA_MODEL_SIZE, LAMA_MODEL_SIZE))
17 mask_blob = cv.dnn.blobFromImage(resized_mask, scalefactor=1.0, size=(LAMA_MODEL_SIZE, LAMA_MODEL_SIZE), mean=(0,), swapRB=False, crop=False)
18 mask_blob = (mask_blob > 0).astype(np.float32)
19
20 net = cv.dnn.readNetFromONNX(str(model_path), engine=cv.dnn.ENGINE_AUTO)
21 net.setInput(image_blob, "image")
22 net.setInput(mask_blob, "mask")
23 output = net.forward()
24
25 result = output[0]
26 result = np.transpose(result, (1, 2, 0))
27 result = np.clip(result, 0, 255).astype(np.uint8)
28 result = cv.resize(result, (w, h))
29
30 elapsed = time.time() - t0
31 print(f" LaMa: inpainting complete [{elapsed:.2f}s]")
32 return result

Austerity Measures

Mon, 01 Jun 2026 00:00:00 +0000

In today’s world we’re reaching higher and higher levels of inflation and unemployment. This, coupled with growing uncertainty and declining confidence in corporate white-collar work due to continual layoffs, has got me thinking that a “two-income” household isn’t really “two-income” at all. It’s more like a one-income household with a backup plan. Given the pervasiveness of consumerism and social media culture, it would be surprising for the average person not to believe they should be living in austerity.

Inpainting with Generative AI

Mon, 01 Jun 2026 00:00:00 +0000

Inpainting with Generative AI

If anything, trying to do generative AI (images) via CLI is unusually ‘hard’. Mostly because most flows use ComfyUI. I have found ComfyUI to be great when trying things out, or doing things interactively.

The easiest way to use CLI/scripting has definitely been stable-diffusion.cpp: https://github.com/leejet/stable-diffusion.cpp

For inpainting, it looks like the below

 1./bin/sd-cli \
 2 --diffusion-model flux-2-klein-9b-Q4_0.gguf \
 3 --vae flux2_dev_diffusion_pytorch_model.safetensors \
 4 --llm Qwen3-8B-Q3_K_M.gguf \
 5 --init-img bench.jpg \
 6 --mask dog-bench-mask.png \
 7 -p "a lovely dog" \
 8 --cfg-scale 2 \
 9 --sampling-method euler \
10 -t 24 \
11 --color \
12 --steps 9 \
13 -H 512 \
14 -W 512 \
15 --vae-tiling \
16 --vae-tile-overlap 0.125 \
17 -o dog-lovely-bench.png

What is important (to me) is that I find that binary masks that ‘grows a bit’ is better than providing a fuzzy mask, on my hardware this runs reasonably quickly (~15s per step at 512x512).

On Syntax-Guided Program Reduction

Mon, 01 Jun 2026 00:00:00 +0000

Program reduction is an interesting problem: given an objective (e.g., a unit test), can we automatically create the minimal viable program by deleting unnecessary code?

This repo (nappe) and PyPI package is an implementation of an existing approach with extensions to solve this. As this problem is NP-hard, it’s not surprising that it is a tad ’expensive’ to do this well. However, it is interesting as it tackles things like removing dead code which perhaps tools like ruff don’t succeed with.

Constrained Procedural Generation

Fri, 01 May 2026 00:00:00 +0000

Constrained Procedural Generation

I’ve always been interested in procedural generation, the maps and algorithms to make ‘realistic’ and ‘dynamic’ environments. This post is more to post some musings and experiments.

One thing that I’ve found is that its often difficult to constrain the generation. For example if I want to use diamond-square, then the map itself needs to be square shape. How might we constraint or have a sliding window approach to generate non-square areas?

Testing Go with Monty (Python)

Wed, 01 Apr 2026 00:00:00 +0000

Testing Go with Monty (Python)

April 2026

Not much to say right now besides it works.

 1package main
 2
 3import (
 4	"context"
 5	"fmt"
 6	"log"
 7
 8	monty "github.com/ewhauser/gomonty"
 9)
10
11var a = `
12def add(x):
13 return x + 1
14
15add(x)
16`
17
18func main() {
19	runner, err := monty.New(a, monty.CompileOptions{
20		Inputs: []string{"x"},
21	})
22	if err != nil {
23		log.Fatal(err)
24	}
25
26	value, err := runner.Run(context.Background(), monty.RunOptions{Inputs: map[string]monty.Value{"x": monty.Int(10000)}})
27	if err != nil {
28		log.Fatal(err)
29	}
30
31	fmt.Println(value.Raw())
32}

It will be interesting if this enables greater scripting capabilities when integrating things into other languages.

A look at Campfire for self-hosted Slack alternative

Sun, 01 Mar 2026 00:00:00 +0000

A look at Campfire for self-hosted Slack alternative

March 2026

Campfire is not really a commonly suggested alternative to Slack/Discord. Afterall its missing various features including voice chat, threads or other features. It makes up for it by being incredibly easy to self-host and easy to write a bot that can interact in such an interface.

Campfire can be hosted from a single Dockerfile using sqlite as its database. For majority of low-numbered user-count situations this is more than sufficient.

Maya1 vs Kokoro vs Kitten TTS Review

Sun, 01 Mar 2026 00:00:00 +0000

Maya1 vs Kokoro vs Kitten TTS Review

March 2026

I finally got to test TTS models, and got them running locally with a variety of notes.

Kitten: advertised as the smallest model, its also the easiest to setup
Kokoro: an extremely good model for its size. I found getting it setup with the onnx wrapping to be the most straightforward (supports quants!)
Maya1: supports gguf. I ended up hosting it in LM Studio with a wrapper to have it working. This is the best quality but also the slowest

TLDR: Use Kokoro if you want a good balance of speed and quality, otherwise Maya1 is a suitable model if you’re willing to wait a bit

Python Debugger and VSCode

Sun, 01 Mar 2026 00:00:00 +0000

Python Debugger and VSCode

March 2026

I find myself copy + pasting (or ChatGPT) the debugging configuration more often than I would like specifically for pytest so replicating it here.

 1{
 2 "configurations": [
 3 {
 4 "name": "$NAME",
 5 "type": "debugpy",
 6 "request": "launch",
 7 "module": "pytest",
 8 "args": ["tests/test_name_of_file.py::test_name_of_func"],
 9 "justMyCode": false
10 }
11 ]
12}

Starting Up Matrix with Docker Compose

Sun, 01 Mar 2026 00:00:00 +0000

Starting Up Matrix with Docker Compose

March 2026

Matrix has a lot of complicated self-hosting docs, mainly to do with federation and hosting. If you’re just self-hosting and not worried about setting up ingresses/federating, its actually fairly simple to setup Matrix. Here is a docker-compose.yml file that will do it. The only bit of configuration is to pull up the element_config.json though that can be left as default values (you can override them later)

Ralph Loop and Frequent Intentional Context Compaction

Sun, 01 Feb 2026 00:00:00 +0000

Ralph Loop and Frequent Intentional Context Compaction

February 2026

There’s been a few things I’ve been playing around and thinking about, specifically around how one might ‘implement’ the ideas.

Beads
Ralph Wiggum Loop
Context Compaction and Management

To that end, I have a single Python script example.

This aims to address a few items:

Manage cross tasks through the use of ’tickets’ (similar to beads), but in a more prescriptive way, where the tickets are created and actively closed outside of the agent loop (n.b. the agent can also create tickets, this way is more intentional which I’ve found works better for a ‘human’ reviewer, cause then the determinism guarentees that the ticket is seen and reviewable.
The Ralph Wiggum loop manages the completion by assessing the ticket queue and seeing whether or not it is complete or not
As part of injecting context to the Ralph Wiggum loop (since context is not preserved), we make use of Context Compaction workflow which is the ‘Research, Plan, Implement’ steps, whereby explicit guidance for researching, then planning is made to populate the context before finally implementing

In general this loop works well, particularly for more complex tasks. The Ralph loop guarentees that it will at least see the task to completion.

Thoughts of ffmpeg and whisper filters

Thu, 01 Jan 2026 00:00:00 +0000

Thoughts of ffmpeg and whisper filters

January 2026

I’ve been experimenting with ffmpeg and the whisper filters. In general I think its awesome that such functionality exists, but at the same time, I don’t believe it addresses the particular painpoints when you go beyond the ‘obvious’ thing.

Installation

On macos to install ffmpeg with the whisper filters, the easiest way is via brew:

brew tap homebrew-ffmpeg/ffmpeg
brew install homebrew-ffmpeg/ffmpeg/ffmpeg --with-whisper-cpp

Considerations

One of the cool functionalities of whisper-cpp is the ability to integrate voice activity detection (VAD). This works out of the box with the whisper filter. Unfortunately what does not work is integrating translations, instead it is expected you create the translation yourself.

Faster AutoML Random Search

Mon, 01 Dec 2025 00:00:00 +0000

Faster AutoML Random Search

December 2025

In today’s modern world of ML it is increasingly uncommon to perform full cross-validation when tuning models. Instead a lot of the focus (particular in the DL space) is to make use of train/validation split with a separate holdout with ablations.

Based on this trend, I believe when training non-DL models, we should employ the same approach.

When doing benchmarking for this, it ends up ranging from a 2.4x to 27.8x speed improvement for doing hyperparameter tuning.

Thinking Local LLMs and AI

Mon, 01 Dec 2025 00:00:00 +0000

Thinking Local LLMs and AI

December 2025

Running models locally is nothing new. Infact I’ve always had a particular affinity to llama.cpp. Recently, there is the newly introduced local text to image (z-image-turbo) generation model that can ‘comfortable’ be run locally (albeit perhaps a bit slow without a dedicated GPU).

Usage would look something like (using justfile to template it) using stable-diffusion.cpp:

 1[no-cd]
 2sd_generate:
 3 PROMPT=$(gum input --placeholder "prompt for image generation"); \
 4 OUTPUT=$(gum input --placeholder "output png file"); \
 5 DYLD_LIBRARY_PATH=/path/to/dyld/library \
 6 sd --difffusion-model z_image_turbo-Q4_0.gguf \
 7 --vae /path/diffusion_pytorch_model.safetensors \
 8 --llm Qwen3-4B-Instruct-2507-Q6_K.gguf \
 9 --cfg-scale 1.0 \
10 --offload-to-cpu \
11 --diffusion-fa \
12 -H 512 -W 512 --steps 9 \
13 -p "$PROMPT" \
14 -o "$OUTPUT"

On M1 Macbook Pro with offload cpu enabled it will take roughly 2 minutes per a step, whereas not offloading will improve performance at the cost of memory consumption (n.b. you should have --offload-to-cpu turned on if you are using a low memory variant).

Examining Pokemon AI as Inspiration for Scoring Systems

Sat, 01 Nov 2025 00:00:00 +0000

Examining Pokemon AI as Inspiration for Scoring Systems

November 2025

With LLMs all the rage, there is a desire for it to make more informed decisions. Perhaps there are multiple (good) choices one can make – how would we induce an LLM to select a ‘good’ choice?

One way to do this is using LLM as a judge. This boils down to a score card style system. The loop looks like this:

Some Python Helix Language Server Configurations

Sat, 01 Nov 2025 00:00:00 +0000

Some Python Helix Language Server Configurations

November 2025

Getting Helix to play ’nicely’ with custom configuration wasn’t too straightforward, specifically wanting ruff formatter to also do auto-fixes (e.g. fixing imports). I also wanted the binaries to be managed by uvx rather than polluting $PATH so needed a bit of customisation there as well.

Doing this ended up to be not too complicated, just need to find the correct setup.

On MacOS

Using Outlines for LLM Constrained Generation

Wed, 01 Oct 2025 00:00:00 +0000

Using Outlines for LLM Constrained Generation

October 2025

Constrained generation is something that has interested me recently. Mostly as an extension of structured generation. For example in the newest gpt-5 models you can now have Regex as a constrained output. Now outlines is not particularly new, though what is interesting to me is the design of their APIs.

Chat Templates

Are created via:

1# Fill in nested templates
2prompt = chat_template(
3 system=system_template(instruction="You are a helpful assistant."),
4 user=user_template(query="What is machine learning?")
5)

Constrained outputs

In Appreciation of Go Generate

Mon, 01 Sep 2025 00:00:00 +0000

In Appreciation of Go Generate

September 2025

Go is a rather minimal language. It does away with macros and (direct) metaprogramming, but it does offer code generation as a first-class citizen via go:generate . On multiple counts, it is rather unassuming and underwhelming, after all the code generation needs to be directly committed for it to be used; there’s no generators or run time generation, but rather it forms part of the distribution.

A quick look at `onnxscript`

Fri, 01 Aug 2025 00:00:00 +0000

A quick look at `onnxscript`

August 2025

onnxscript is a weird project that I’ve been keeping tabs on. It’s weird because its like an ORM. It’s functionally useless if you aren’t familiar with lower level onnx concepts or don’t know how to construct an onnx graph from low level primitives, in that debugging will be a nightmare, and yet there are a lot of abstractions that safe you a lot of time and effort.

Embedding Alignment

Fri, 01 Aug 2025 00:00:00 +0000

Embedding Alignment

August 2025

Why?

Given the increasing use of vendored vector store solutions and dependencies on AI for mission critical systems, it is important to determine ways to ensure systems stay reliable when third party APIs degrade. Embedding alignment can be an approach to re-map embeddings from one vendored system to another in the hope that systems stay reliable at the cost of minimal degradation at inference time. This approach requires only maintaining a linear mapping between embeddings rather than duplicating vector stores for multiple vendors which can be expensive in terms of ownership, processes and infrastructure.

Prompt Coding

Tue, 01 Jul 2025 00:00:00 +0000

Prompt Coding

July 2025

Perhaps another paradigm that is worth considering is just prompt coding, whereby a single prompt produces a script end to end, no edits, no rework. This means that you are just saving and rerunning the prompts rather than relying on (perhaps flaky and difficult to reproduce) diffs and iterations. This way also removes the reliance on AI IDEs, and you can use (free) chat interfaces to create code.

What if I tried self-hosting LLM Code Tooling?

Tue, 01 Jul 2025 00:00:00 +0000

What if I tried self-hosting LLM Code Tooling?

July 2025

Currently Code AI tooling is going through a weird cycle. We have the Windsurf x OpenAI deal falling through, Cursor with some interesting (bad) pricing changes, Claude Code being a loss leader – which leads me to think, so what would self-hosting this on a laptop look like?

Firstly, there are a lot of options which exist already, however the reality is that my using of AI auto-complete and agentic mode is fairly limited. With that in mind, I think my current setup is rooted mainly in the llama.cpp world of things.

Inlay Hints and LSPs

Sun, 01 Jun 2025 00:00:00 +0000

Inlay Hints and LSPs

June 2025

It’s currently 2025, and there is a massive amount of interest in LLM/AI powered IDEs. But I think there is something more powerful - making good use of your LSPs. In particular inlay hints. Now inlay hints are a somewhat recent addition, but its something that helps with inferring type hints or annotating your code with these hints to reduce mental strain.

Python: pyrefly adds support by default
Rust: rust-analyzer adds support by default
Go: gopls adds support – you may need to enable it in settings

In VSCode settings it would look like:

My Custom Iosevka Font

Thu, 01 May 2025 00:00:00 +0000

My Custom Iosevka Font

May 2025

I’ve started using my own custom Iosevka font. Many of the customisations are there to allow for greater legibility; not necessarily there to improve aesthetics or to improve screen estate. Of note, the things I focussed on are:

the inclusion of old-style numerals, where numerals have varying height. This helps distinguish between numbers and letters much easier
changing the default width. This relaxes the ’look’ slightly
adding tails, and/or curvature to the appropriate letters. This is more a preference item to distinguish and provide the characters a ‘softer’ look

The full config as of writing is shown below:

Maintaining Scripts using Just and Gum

Tue, 01 Apr 2025 00:00:00 +0000

Maintaining Scripts using Just and Gum

April 2025

I’ve found maintaining shell scripts and aliases to be a bit of a mess. I know people have their own systems with dotfiles, but it never ‘stuck’ with me. I’m trialing a new approach using gum and just, both which can be installed via brew. This makes it so there less memorisation of what different programs do, and their parameters, since you can control and name variables to a flow that you like. Combined with just’s ability to target justfile from different directories, this makes centralising scripts and cli commands very straightforward.

Python MCP - Mounting to an Existing FastAPI ASGI Server

Tue, 01 Apr 2025 00:00:00 +0000

Python MCP - Mounting to an Existing FastAPI ASGI Server

April 2025

You can mount the SSE server to an existing FastAPI ASGI server dynamically. The way I’ve made it work is as follows:

 1sse = SseServerTransport(...)
 2
 3...
 4app.router.routes.append(Mount("/messages", app=sse.handle_post_message))
 5
 6@app.get("/sse")
 7async def handle_mcp_connection(request: Request):
 8 async with sse.connect(sse(request.scope, request.receive, request.send) as (
 9 read_stream,
10 write_stream,
11 ):
12 await mcp._mcp_server.run(
13 read_stream,
14 write_stream,
15 mcp._mcp_server.create_initialization_options(),
16 )

This seemed to work pretty well, along with having Redis as an intermediary broker for dealing with state.

Syncify Python Async Functions

Tue, 01 Apr 2025 00:00:00 +0000

Syncify Python Async Functions

April 2025

There’s a lot to unpack with Python shenanigans. Including why nest-asyncio even exists. Here is yet another pattern (note: you really should look into https://asyncer.tiangolo.com/ if it fits for you).

1def syncify(func, *args, **kwargs):
2 def wrapper(coro):
3 return asyncio.run(coro)
4
5 with ThreadPoolExecutor(max_workers=1) as executor:
6 result = next(executor.map(wrapper, [func(*args, **kwargs)]))
7 return result

Which delegates/moves the execution to a threadpool to bypass potential issues. This is definitely not a ‘performant’ option, but it may save your skin.

I’ll point out in general, where your event loop is not nested, you could just use asyncio.run.

Setting SQL for Feature Transformations as a Standard

Sat, 01 Mar 2025 00:00:00 +0000

Setting SQL for Feature Transformations as a Standard

March 2025

So Spark’s SQLTransformer is probably the first (and only?) documented, formal, specification for doing SQL transformations specifically for machine learning preprocessing. I think that is interesting for a variety of reasons, with the biggest one being opportunities for standardisation, in particular for real-time flows. Having a well-optimised SQL transformation engine could be immensely valuation. The reason why this hasn’t occured is probably because industry standard today still relies on Python as the execution engine, however this because untenable in scenarios where Python is an inappropriate production programming language choice. At the same time, Spark is typically too expensive of a dependency to justify low latency workflows. Nevertheless lets quickly look at the specification and considerations for using the language with an alternative computation backend.

The Comic Book Font

Sat, 01 Mar 2025 00:00:00 +0000

The Comic Book Font

March 2025

One random thing I learnt is that the comic book font that you see in hand-drawn style comics is actually typically done via technical lettering tools like Leroy Lettering System. I’ve been thinking of improving my handwriting and quite enjoy that “Gothic Router” aesthetic (which is used in this blog) due to its “draft-like” look, and unrefined appearance which emphasises on the informal nature of my writing. To that end I came across this lettering guide which I will probably lean on in the future.

Dependency Injection via SQLModels isn't worth it

Sat, 01 Feb 2025 00:00:00 +0000

Dependency Injection via SQLModels isn’t worth it

February 2025

It’s been something I’ve been mulling over for a while now. I’m not convinced using Session with Dependency Injection is worth it. The abstraction is nice, visually, but the lack of context makes things really hard to reason with, especially if you’re doing something beyond a simple getter/setter. This happens if you’re building an application that performs a flow or some business logic rather than a pure CRUD, then you may need to do multiple commits in a single query which may not need to all be rolled back. This of course breaks some kind of assumption to do with “a single unit of work”.

rqlite - a Production Experiment

Wed, 01 Jan 2025 00:00:00 +0000

rqlite - a Production Experiment

January 2025

rqlite is a distributed version of sqlite using the raft consensus algorithm. The great thing about rqlite actually has nothing to do with the underlying tech, but more to do with broad developer experience and that is the defaults with the provided helm charts.

It just feels like I’m the target audience - someone who wants to quickly push rqlite to production with the minimal dependencies and gives me enough to shoot myself in the foot. Compared with postgres helm charts, rqlite presumes that you may want to just use it as-is, without even a values file. That is a welcome change, whereas almost anything from the bitnami one expects you as a developer will make modifications. Something in that model does not feel quite right. This friction (although seemingly trivial) converted me to use rqlite (the other reason is I was using sqlite for my tests which meant I didn’t need to worry about changing any code to ensure compatibility between different sql dialects).

LLMs - in Review (2024)

Sun, 01 Dec 2024 00:00:00 +0000

LLMs - in Review (2024)

December 2024

2024 was the first year where I took LLMs seriously. I successfully hosted a Llama 70b parameter model in production which was used as with continue.dev for a self-hosted co-pilot replacement, along with a code autocomplete like Qwen Coder or Deepseek, these were fine replacements and surprisingly robust. Huggingface’s TGI along with Triton Server were the main heroes for this project, (Triton was used to serve onnx models for embeddings) though I’ve yet to find a “good” embedding model. At this stage in time, most of the vector database solutions “feel” the same and can all seemingly be trivially hosted via Kubernetes.

Python & TypeScript - in Review (2024)

Sun, 01 Dec 2024 00:00:00 +0000

Python & TypeScript - in Review (2024)

December 2024

One thing that I like to stress is the importance of tooling and relying on defaults. By being able to speak consistently within ones own projects or using commonly seen patterns reduces the mental overhead. These could be folder structures or idioms, especially things which permeate across different programming languages or frameworks.

Here are some of my thoughts on Python and TypeScript; coming from someone who is predominantly a Python developer and does minimal front-end work.

About

Mon, 01 Jan 0001 00:00:00 +0000

Welcome to my blog

A collection of thoughts - short essays, reflections, personal opinions
A collection of experiments - ‘vibe’ coding, things that may not work, tests and things which maybe purposely imperfect or incomplete
A list of future projects - ideas and plans for the future, whatever may happen
A list of things I use - mostly because I sometimes lose track of settings/configuration I have in my setup, as I have a tendency to tinker with these things a lot
A list of bookmarks - stuff I have a tendency of referring back to infrequently and sometimes lose track of it; things mostly not written by me

Agentic Engineering

Mon, 01 Jan 0001 00:00:00 +0000

Based on Agentic Engineering (Aug 2026).

Agentic engineering follows a structured “research, plan, implement” loop. The key focus is distinguishing where a “human leans in” versus where an “agent runs it.”

🧠: Human leans in
⚙️: Agent runs it

Research

🧠🔬 Design Together: Engage with every brainstorming decision and design section yourself. Design is never delegated to agents; delegated design is slop.
- When Unsure: Seek an adversarial second opinion. A separate agent session on a different model family should judge the decision or design section. (Note: This applies to both brainstorming decisions in Step 1 and spec review in Step 3).
⚙️📡 Write the Spec: Specs are written for agents, not humans. If you actively engaged in the design phase, you do not need to line-read the document for reassurance.
⚙️📡 Adversarial Spec Review: A separate agent session reviews the spec and reports findings. Fix, re-review, and repeat until the output converges. (This creates a revision loop between Steps 2 and 3).

Plan and Implement

⚙️🦾 Plan, Then Subagent-Driven Implementation: Convert the converged spec into an implementation plan, then execute it with a fresh implementer and reviewer per task. (writing-plans → subagent-driven-development)
- Review Cadence: If the plan has > 10 tasks, pause every ~5 tasks to run roborev-fix so reviews never pile up. If the plan has ≤ 10 tasks, closing out reviews at the end is acceptable.

Review

🧠🔍 Close-out Gate: Before any PR is raised, ensure every roborev review is closed out, and all generated specs and plans are either converted to durable documents or deleted. (These documents should only land in the main branch for a specific reason, e.g., a follow-up PR requires them).

Decision Register

🧠📖 Make the Work Durable: Durable artifacts must state their invariants directly in domain language, using stable paths, role-based runbooks, and meaningful metadata. Planning documents may point to durable artifacts, but never the reverse. Delete the planning tree post-merge: the repository must still explain itself, and the default branch alone should be sufficient to operate and recover the system.
- Terminal Action: Explain the change, open the PR, and own the merge.

Addendum

Domain-Driven Design (DDD), as presented by Eric Evans, shrinks the communication gap between business and technical teams. By relying on ubiquitous language and bounded contexts, DDD translates business needs directly into technical implementation, ensuring both sides speak the same language. With agents in the loop, this link matters even more: it dictates how we state our requirements to the model and how we interpret its reasoning in return.

Bookmarks

Mon, 01 Jan 0001 00:00:00 +0000

Bookmarks and Stuff

Here are things that I didn’t invent, but I find myself constantly referring back to.

Copilot with Local Provider

1export COPILOT_PROVIDER_TYPE=openai
2export COPILOT_PROVIDER_BASE_URL=http://192.168.0.60:1234/v1
3export COPILOT_PROVIDER_API_KEY=unset
4export COPILOT_MODEL=qwen3.6-35b-a3b-mtp
5export COPILOT_OFFLINE=true
6
7# this should work
8copilot

Super Resolution

Real Super Resolution models are surprisingly accessible: https://github.com/xinntao/Real-ESRGAN

The Catherine Project

Very rarely does something come along that makes me think about lifelong learning, or rather the act of learning itself. The Catherine Project is definitely one such initiative. How can critical thinking be taught or encouraged? How should we introspectively write about ourselves and the thoughts of others?

Experiments

Mon, 01 Jan 0001 00:00:00 +0000

Experiments

A collection of experiments, code dump etc, that are more for the vibe than for the writing (i.e. these may be heavily written by AI, but are still “cool”).

2026

Speech Diarizer

A fairly vanilla speech diarizer without torch or unusual dependencies. Only onnxruntime. See https://github.com/NoRaincheck/Speech-Segmentation

 1import urllib.request
 2import wave
 3import numpy as np
 4import onnxruntime as ort
 5
 6model_id = "onnx-community/pyannote-segmentation-3.0"
 7
 8model_path = "model.onnx"
 9urllib.request.urlretrieve(
10 f"https://huggingface.co/{model_id}/resolve/main/onnx/model.onnx",
11 model_path,
12)
13
14url = "https://huggingface.co/datasets/Xenova/transformers.js-docs/resolve/main/mlk.wav"
15audio_path = "mlk.wav"
16urllib.request.urlretrieve(url, audio_path)
17
18with wave.open(audio_path, "rb") as wf:
19 sr = wf.getframerate()
20 frames = wf.readframes(wf.getnframes())
21 audio = np.frombuffer(frames, dtype=np.int16).astype(np.float32) / 32768.0
22
23target_sr = 16000
24step = 270
25
26if sr != target_sr:
27 old_len = len(audio)
28 new_len = int(old_len * target_sr / sr)
29 audio = np.interp(np.linspace(0, old_len - 1, new_len), np.arange(old_len), audio)
30
31session = ort.InferenceSession(model_path)
32logits = session.run(
33 None, {"input_values": audio[np.newaxis, np.newaxis, :].astype(np.float32)}
34)[0]
35
36frame_logits = logits[0]
37exps = np.exp(frame_logits - frame_logits.max(axis=1, keepdims=True))
38probs = exps / exps.sum(axis=1, keepdims=True)
39
40preds = probs.argmax(axis=1)
41confidence = probs.max(axis=1)
42
43segments = []
44current_spk = None
45current_start = None
46max_conf = 0.0
47
48for i, (cls, conf) in enumerate(zip(preds, confidence)):
49 if cls in (1, 2, 3):
50 if cls != current_spk:
51 if current_spk is not None:
52 segments.append(
53 (
54 current_spk,
55 current_start * step / target_sr,
56 i * step / target_sr,
57 float(max_conf),
58 )
59 )
60 current_spk = cls
61 current_start = i
62 max_conf = conf
63 else:
64 max_conf = max(max_conf, conf)
65 else:
66 if current_spk is not None:
67 segments.append(
68 (
69 current_spk,
70 current_start * step / target_sr,
71 i * step / target_sr,
72 float(max_conf),
73 )
74 )
75 current_spk = None
76 current_start = None
77 max_conf = 0.0
78
79if current_spk is not None:
80 segments.append(
81 (
82 current_spk,
83 current_start * step / target_sr,
84 len(preds) * step / target_sr,
85 float(max_conf),
86 )
87 )
88
89for spk_id, start, end, conf in segments:
90 print(f" SPEAKER_{spk_id:02d} {start:7.2f}s - {end:7.2f}s (conf={conf:.3f})")

pre-commit hook for anonymous git commits

 1#!/bin/sh
 2# Pre-commit hook to check that git config contains $NAME
 3NAME='~myname'
 4
 5# Define color codes
 6RED='\033[0;31m'
 7GREEN='\033[0;32m'
 8YELLOW='\033[1;33m'
 9NC='\033[0m' # No Color
10
11# Check if user.name
12USER_NAME=$(git config user.name)
13if ! echo "$USER_NAME" | grep -q "${NAME}"; then
14 echo "${RED}❌ Error: git config user.name does not contain '${NAME}'${NC}"
15 echo "${YELLOW}Current user.name: $USER_NAME${NC}"
16 exit 1
17fi
18
19echo "${GREEN}✅ Git config validation passed: user.name and user.email contain '${NAME}'${NC}"

Full Text Search (sqlite3 FTS5)

Semantic search gets all the attention, but full-text search with BM25 scoring is fast, dependency-free, and surprisingly effective for local RAG pipelines. Python’s built-in sqlite3 ships with FTS5 support — no pip installs, no external databases. Just create a regular table for your documents (plus JSON metadata), an FTS5 virtual table for indexing, and a few triggers to keep them in sync.

Looking Forward

Mon, 01 Jan 0001 00:00:00 +0000

In Progress

Helix Tutorial

Ideas

Write janky games (under NoRI - No Raincheck Interactive), using ebiten with extensions Tetra3d. For sprite-based games consider this tileset: Dungeon Tileset II. We can try DALL-E 3 to TRELLIS pipeline with Mixamo for Animations with Blender to generate the spritesheets. Or using Odin: https://odin-lang.org/news/calling-odin-from-python/
Perform Chinese Word Segmentation on arbitary text for building an application to learn chinese better. See Chinese word-segmented writing (ex. package ckiptagger), with the idea that it can process things batch/offline and host a static version on a static website.
Example TidalCycle (or other live coding music environments like Strudel)
Write some Obsidian plugins so that things display in docsify format and vice versa (e.g. the ability to embed/include files in docsify, or the Kanban extension in Obsidian to make it display in docsify)

My Setup

Mon, 01 Jan 0001 00:00:00 +0000

Shell and Fonts

Iosevka - because I work off my laptop screen alot, specifically a custom variant.

For general “stuff”, I currently enjoying the “gothic” router font aesthetic, which is used in this blog.

For my shell:

Themes

Catppuccin has started to replace Dracula as my daily driver, though I still use some Dracula themes like the terminal which I believe to be superior option still. Alternatives I’ve considered are Rosé Pine which I’ve briefly toyed with, but haven’t taken seriously.

Quotes

Mon, 01 Jan 0001 00:00:00 +0000

Quotes

Famous quotes from TV shows.

“When you know who you are and what you like about yourself, changing for other people isn’t such a big deal.”

Abed Nadir, Community

“To live life you need problems. If you get everything you want the minute you want it what’s the point of living?”

Jake the Dog, Adventure Time

Tutorials - Helix

Mon, 01 Jan 0001 00:00:00 +0000

Moving to Helix

Helix (hx) is a modern modal editor built in Rust. Unlike Vim/Neovim, Helix ships with a built-in LSP client, tree-sitter integration, and multiple cursor support out of the box — no plugins required.

Why Helix over Vim/Neovim?

Zero-config LSP — language servers are detected and configured automatically from your project. No more nvim-lspconfig or Mason.
Tree-sitter natively — syntax highlighting, text objects, and navigation all use tree-sitter. No plugins needed.
Multiple cursors — a first-class feature, not an afterthought.
Built-in file picker — fuzzy finding via fzf-like interface, no Telescope.
Selection-driven editing — Helix flips the Vim model: motions extend the selection first, then you act on it. This is more intuitive once you adjust.

Key Differences from Vim

Concept	Vim / Neovim	Helix
Normal mode	motions act immediately	motions extend the selection
Insert mode	`i` to enter	`i` enters insert (same)
Select then act	`d2w` (delete 2 words)	`2w` extends selection, `d` deletes it
File explorer	Requires plugin	Built-in `<space>f` or `:open`
LSP	Plugin required	Built-in, auto-configured
Config	Lua / Vimscript	`~/.config/helix/config.toml`
Language config	Per-plugin setup	`~/.config/helix/languages.toml`

Getting Started

1# macOS
2brew install helix
3
4# Arch
5sudo pacman -S helix
6
7# or build from source
8git clone https://github.com/helix-editor/helix
9cargo install --path helix-term

Configuration

Helix uses toml for everything. See the official config docs.

NoRaincheck

Self-Hosted Agentic Engineering

Reflecting on Mitchellh's AI Adoption Journey Blog Post

Chatbot Sucks

LAN Messenger and Agents

Notes on Resizing Images

Notes on Resizing Images

Beating FastAPI

Skills are meant to be vendored

Skills are meant to be vendored

Vibe Benchmarks

Vibe Benchmarks

The models

TL;DR

OpenCV 5 Python Bindings Is Here

OpenCV 5 Python Bindings Is Here

Austerity Measures

Inpainting with Generative AI

Inpainting with Generative AI

On Syntax-Guided Program Reduction

Constrained Procedural Generation

Constrained Procedural Generation

Testing Go with Monty (Python)

Testing Go with Monty (Python)

A look at Campfire for self-hosted Slack alternative

A look at Campfire for self-hosted Slack alternative

Maya1 vs Kokoro vs Kitten TTS Review

Maya1 vs Kokoro vs Kitten TTS Review

Python Debugger and VSCode

Python Debugger and VSCode

Starting Up Matrix with Docker Compose

Starting Up Matrix with Docker Compose

Ralph Loop and Frequent Intentional Context Compaction

Ralph Loop and Frequent Intentional Context Compaction

Thoughts of ffmpeg and whisper filters

Thoughts of ffmpeg and whisper filters

Installation

Considerations

Faster AutoML Random Search

Faster AutoML Random Search

Thinking Local LLMs and AI

Thinking Local LLMs and AI

Examining Pokemon AI as Inspiration for Scoring Systems

Examining Pokemon AI as Inspiration for Scoring Systems

Some Python Helix Language Server Configurations

Some Python Helix Language Server Configurations

Using Outlines for LLM Constrained Generation

Using Outlines for LLM Constrained Generation

In Appreciation of Go Generate

In Appreciation of Go Generate

A quick look at `onnxscript`

A quick look at onnxscript

Embedding Alignment

Embedding Alignment

Prompt Coding

Prompt Coding

What if I tried self-hosting LLM Code Tooling?

What if I tried self-hosting LLM Code Tooling?

Inlay Hints and LSPs

Inlay Hints and LSPs

My Custom Iosevka Font

My Custom Iosevka Font

Maintaining Scripts using Just and Gum

Maintaining Scripts using Just and Gum

Python MCP - Mounting to an Existing FastAPI ASGI Server

Python MCP - Mounting to an Existing FastAPI ASGI Server

Syncify Python Async Functions

Syncify Python Async Functions

Setting SQL for Feature Transformations as a Standard

Setting SQL for Feature Transformations as a Standard

The Comic Book Font

The Comic Book Font

Dependency Injection via SQLModels isn't worth it

Dependency Injection via SQLModels isn’t worth it

rqlite - a Production Experiment

rqlite - a Production Experiment

LLMs - in Review (2024)

LLMs - in Review (2024)

Python & TypeScript - in Review (2024)

Python & TypeScript - in Review (2024)

A quick look at `onnxscript`