Blog on 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.

Blog on 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`