Feb 18^th 2026 · 2 min read · #apple #bugs #macos #qa #software #tahoe

macOS Tahoe 26.3 is Broken

I have no idea of what is happening since I can’t even find any decent logs in Console.app, but it seems that the latest update to macOS Tahoe (26.3) has a serious bug.

My desktop (a Mac Mini M2 Pro) has been crashing repeatedly since the update, and the symptom is always the same: it suddenly becomes sluggish (the mouse cursor slows down, then freezes completely), and then after a minute both my displays flash purple and then go black as the machine reboots.

For a machine that used to be on 24/7 with zero issues, this is a definite regression.

I’ve tried keeping ActivityMonitor open to see if I can spot any process that is consuming too much CPU or memory (the obvious suspect would be WindowServer), but everything looks normal until the crash happens, and there is only so much attention one can spare while, you know, doing productive stuff.

I have a sneaking suspicion that it might be Apple’s container framework, but I have no way to confirm that other than (I guess) stop using it for a few days.

But, again, the fact that I can’t find any logs or error messages in Console.app and that searching for anything inside it is still a nightmare is a testament to Apple’s general software quality and ability to troubleshoot anything these days…

I filed it as FB21983519 in case anyone cares.

Update, a few hours later: It’s not the container framework. I just came back to my machine after lunch and it had crashed again, so I guess it’s something else. Again, nothing shows up on the console logs other than the BOOT TIME entries for the reboot. There were no hardware changes, no new peripherals, and I’ve removed most of my login items (not that I have that many, and neither of them was recently updated).

Update, a day later: The crashes continue. My MacBook Pro also mysteriously crashed while asleep–the first time this has happened to me in recent memory, and also running 26.3. I have no idea if it’s related, but it seems to be a similar issue. Again, no logs or error messages in Console.app other than the BOOT TIME entries.

Update, two days later: A few people have suggested this might be a buggy interaction between container and Time Machine, which would be serendipitous given my recent problems with it, and although I did indeed remove ~/Library/Application Support/com.apple.container from my desktop early on and still had a crash, my MacBook Pro never ran container in the first place, so I don’t think that’s the issue. And somehow, Touch ID stooped working on my MacBook Pro, which is just the cherry on top of this whole mess.

Feb 16^th 2026 · 10 min read · #3d #3dprinting #ai #engineering #mesh #openscad #reverse #stl #til

TIL: Claude Opus 4.6 Can Reverse Engineer STL Files

So, I finally got around to opening the Maclock I’ve had sitting around for a while, and I was looking at the STL files for the screen bracket that are over on Printables.

Since I want to fit a lot more electronics into the case, one of the things I need to do is modify that bracket a bit so I can actually use the brightness knob to drive a potentiometer instead of just a dummy knob.

But you can’t really edit STL files, and I don’t have the original CAD files, so I thought “well, maybe I can just ask an LLM to reverse-engineer the STL into an OpenSCAD file, and then I can modify that”.

So I created a SPEC.md file with the following content, spun up a new agentbox container to handle it, and gave it to pi:

# STL to OpenScad reconstruction

You are running inside a Debian system with sudo, brew, python3 and whatever you need to accomplish this task.

Your job is to take the STL file in this workspace and reconstruct a copy of it using OpenSCAD.

If the STL is too large or complex, you can try decimating it/using octrees/segmenting it/using marching cubes as needed.

## Requirements

- The final STL file must be within 0.1mm accuracy of the original
- The OpenSCAD code must be modular, readable, and have relevant constants surfaced at the beginning for a customizer
- You should focus on building reusable tools, not one-off scripts
- You should maintain a plan.md file with your progress checklist and tick off items (including failed approaches) as you make progress

Much to my surprise, Claude Opus 4.6 was able to handle this task pretty well, and it produced a stupefyingly accurate OpenSCAD file:

// WonderMac Screen Bracket - OpenSCAD Reconstruction
// Reconstructed from STL analysis
// All dimensions in mm

/* [Main Dimensions] */
// Total width of the bracket (X direction)
bracket_width = 68;         // X: -50 to 18
// X offset (left edge position)
bracket_x_offset = -50;

/* [Back Plate] */
// Height of the tall vertical back plate
back_plate_height = 21.5;   // Z: 0 to 21.5
// Thickness of the back plate (Y direction)
back_plate_thickness = 2;   // Y: -16.5 to -14.5
// Y position of back plate inner edge
back_plate_y = -16.5;

/* [Top Shelf] */
// Bridge depth (connects back plate to top lip)
bridge_depth = 5.5;         // Y: -14.5 to -9
// Bridge height
bridge_height = 2;          // Z: 0 to 2
// Top lip depth
top_lip_depth = 2;          // Y: -9 to -7
// Top lip height
top_lip_height = 5;         // Z: 0 to 5

/* [Frame] */
// Frame outer Y bounds
frame_outer_y_min = -66.5;
frame_outer_y_max = -14.5;  // matches back plate
// Frame inner bounds (lower section Z=0-7)
frame_inner_x_min = -47;
frame_inner_x_max_lower = 18;  // open right side
frame_inner_y_min_lower = -64.5;
frame_inner_y_max_lower = -16.5;
// Frame inner bounds (upper section Z=7-9)
frame_inner_x_max_upper = 13;
frame_inner_y_min_upper = -62.5;
frame_inner_y_max_upper = -17.5;
// Frame heights
frame_lower_height = 7;     // Z: 0 to 7
frame_upper_height = 2;     // Z: 7 to 9

/* [Bottom Lip] */
// Lip extension below frame
lip_y_min = -70.5;
lip_y_max = -66.5;
lip_z_min = 3;
lip_z_max = 5;
lip_height = 2;             // lip_z_max - lip_z_min

/* [Extended Plate] */
// L-shaped plate at Z=5-7
plate_z_min = 5;
plate_z_max = 7;
plate_height = 2;
// Bottom part of L (full width)
plate_bottom_y_min = -9;
plate_bottom_y_max = -3;
// Left part of L (extends upward)
plate_left_y_max = 15;
plate_left_x_max = -30;

/* [Screw Post] */
// Cylindrical post with through-hole
post_center_x = -41;
post_center_y = 10.5;
post_outer_radius = 2;
post_inner_radius = 1;
post_z_min = 0.5;
post_z_max = 5;             // meets plate bottom

/* [Screw Holes] */
// Hole radius for mounting holes
mount_hole_radius = 0.75;
// Lip mounting holes
lip_hole_left_x = -47.75;
lip_hole_right_x = 15.75;
lip_hole_y = -69;
// Plate mounting holes
plate_hole_left_x = -46;
plate_hole_right_x = 15;
plate_hole_y = -5;

/* [Resolution] */
$fn = 64;

// ============================================
// Modules
// ============================================

module back_plate() {
    translate([bracket_x_offset, back_plate_y, 0])
        cube([bracket_width, back_plate_thickness, back_plate_height]);
}

module bridge() {
    translate([bracket_x_offset, back_plate_y + back_plate_thickness, 0])
        cube([bracket_width, bridge_depth, bridge_height]);
}

module top_lip() {
    translate([bracket_x_offset, -9, 0])
        cube([bracket_width, top_lip_depth, top_lip_height]);
}

module frame_lower() {
    difference() {
        // Outer rectangle
        translate([bracket_x_offset, frame_outer_y_min, 0])
            cube([bracket_width,
                  frame_outer_y_max - frame_outer_y_min,
                  frame_lower_height]);
        // Inner cutout
        translate([frame_inner_x_min, frame_inner_y_min_lower, -1])
            cube([frame_inner_x_max_lower - frame_inner_x_min,
                  frame_inner_y_max_lower - frame_inner_y_min_lower,
                  frame_lower_height + 2]);
    }
}

module frame_upper() {
    difference() {
        // Outer rectangle (same as lower)
        translate([bracket_x_offset, frame_outer_y_min, frame_lower_height])
            cube([bracket_width,
                  frame_outer_y_max - frame_outer_y_min,
                  frame_upper_height]);
        // Inner cutout (smaller = thicker walls)
        translate([frame_inner_x_min, frame_inner_y_min_upper, frame_lower_height - 1])
            cube([frame_inner_x_max_upper - frame_inner_x_min,
                  frame_inner_y_max_upper - frame_inner_y_min_upper,
                  frame_upper_height + 2]);
    }
}

module bottom_lip() {
    translate([bracket_x_offset, lip_y_min, lip_z_min])
        cube([bracket_width, lip_y_max - lip_y_min, lip_height]);
}

module extended_plate() {
    // Bottom part of L (full width, Y=-9 to -3)
    translate([bracket_x_offset, plate_bottom_y_min, plate_z_min])
        cube([bracket_width,
              plate_bottom_y_max - plate_bottom_y_min,
              plate_height]);
    // Left part of L (Y=-3 to 15, X=-50 to -30)
    translate([bracket_x_offset, plate_bottom_y_max, plate_z_min])
        cube([plate_left_x_max - bracket_x_offset,
              plate_left_y_max - plate_bottom_y_max,
              plate_height]);
}

module screw_post() {
    translate([post_center_x, post_center_y, post_z_min])
        cylinder(r=post_outer_radius, h=post_z_max - post_z_min);
}

module screw_post_hole() {
    translate([post_center_x, post_center_y, -1])
        cylinder(r=post_inner_radius, h=back_plate_height + 2);
}

module lip_holes() {
    // Left lip hole
    translate([lip_hole_left_x, lip_hole_y, lip_z_min - 1])
        cylinder(r=mount_hole_radius, h=lip_height + 2);
    // Right lip hole
    translate([lip_hole_right_x, lip_hole_y, lip_z_min - 1])
        cylinder(r=mount_hole_radius, h=lip_height + 2);
}

module plate_holes() {
    // Left plate hole
    translate([plate_hole_left_x, plate_hole_y, plate_z_min - 1])
        cylinder(r=mount_hole_radius, h=plate_height + 2);
    // Right plate hole
    translate([plate_hole_right_x, plate_hole_y, plate_z_min - 1])
        cylinder(r=mount_hole_radius, h=plate_height + 2);
}

// ============================================
// Assembly
// ============================================

module bracket_assembly() {
    difference() {
        union() {
            back_plate();
            bridge();
            top_lip();
            frame_lower();
            frame_upper();
            bottom_lip();
            extended_plate();
            screw_post();
        }
        // Subtract all holes
        screw_post_hole();
        lip_holes();
        plate_holes();
    }
}

bracket_assembly();

But what is more important is that I was able to capture the entire process in a SKILL.md file, and it makes for an amazing read:

# SKILL: STL to Parametric OpenSCAD Reconstruction

## Goal

Reverse-engineer a binary/ASCII STL mesh file into a clean, parametric OpenSCAD source file that reproduces the original geometry within a specified tolerance (e.g. 0.1mm Hausdorff distance).

## When to Use

- You have an STL file of a mechanical part and need an editable parametric source
- The part is primarily composed of prismatic (box-like) and cylindrical features — not organic/sculpted shapes
- You need the output to be human-readable and customizable, not just a mesh re-export

## Prerequisites

- **Python packages**: `numpy`, `trimesh`, `scipy`, `shapely`, `networkx`, `rtree`, `numpy-stl`
- **System packages**: `openscad`
- Install with: `pip3 install numpy trimesh scipy shapely networkx rtree numpy-stl` and `sudo apt-get install openscad`

## High-Level Approach

### Phase 1: Mesh Triage

Load the STL with `trimesh` and gather key statistics to understand the scope:

- **Vertex/face count**: Determines complexity. Under ~5k faces is likely a machined/printed part with clean geometry.
- **Bounding box and extents**: Gives the overall dimensions.
- **Volume and watertightness**: Confirms the mesh is valid and closed.
- **Euler number**: Computes genus (number of through-holes). Formula: `genus = (2 - euler_number) / 2`. This tells you how many holes to find.

### Phase 2: Identify Z-Level Structure

For prismatic parts (brackets, enclosures, mounts), the geometry is almost always built from features extruded along one principal axis. Identify which axis that is by examining the unique coordinate values of vertices.

1. **Find unique vertex coordinates** along each axis (rounded to ~3 decimal places). The axis with the fewest unique values is the extrusion/stacking axis.
2. **List the discrete levels** on that axis. For this bracket, Z had only 8 unique values: `[0, 0.5, 2, 3, 5, 7, 9, 21.5]`. Each pair of adjacent levels defines a "layer" of constant cross-section.
3. **Count up-facing and down-facing face areas** at each level. Up-facing faces at a Z-level mark the *top* of a feature; down-facing faces mark the *bottom* of a feature starting at that height. The area values serve as checksums for your reconstruction.

### Phase 3: Cross-Section Analysis

Take planar cross-sections at the midpoint of each layer using `trimesh.section()`:

1. **Slice the mesh** at each intermediate Z value (e.g. Z=0.25, Z=1, Z=2.5, etc.).
2. **Convert to 2D polygons** via `section.to_planar()` and examine the `polygons_full` property.
3. **Simplify polygons** with Shapely's `.simplify()` to reduce curved arcs to key vertices while preserving corners.
4. **Transform back to world coordinates** using the planar transform matrix to get actual XY positions.
5. **Record each polygon's exterior and interior (hole) boundaries**. Note how many vertices remain after simplification — a 5-point polygon is a rectangle, a 9-point polygon is an L-shape, a 17-point polygon is a circle approximation, etc.

Track how the cross-section *changes* between layers — this reveals where features start, end, merge, or split.

### Phase 4: Identify Geometric Primitives

From the cross-section data, decompose the shape into CSG primitives:

- **Rectangles** (5 simplified vertices = box cross-section): Record corner coordinates, extrusion height range.
- **L-shapes / U-shapes** (9+ vertices): Decompose into union of rectangles, or model as rectangle-minus-rectangle.
- **Circles / arcs** (17+ vertices after simplification): Compute center as midpoint of extremes, radius as half the span. Verify by checking vertex distances from the computed center — they should all equal the radius.
- **Rings/annuli** (polygon with circular hole): Outer and inner radius from the exterior and interior boundaries.

For each primitive, determine:
- XY bounds or center+radius
- Z range (which layers it spans)
- Whether it's additive (part of the union) or subtractive (a hole to difference out)

### Phase 5: Cross-Validate with Vertex Grouping

For extra confidence, directly examine the raw vertices at each Z-level:

- Group vertices by their Z coordinate.
- For levels with few vertices (≤20), print them all — these directly reveal rectangle corners.
- For levels with many vertices, look for clusters. Compute distances from suspected circle centers and verify constant radius.
- Check that circle parameters (center, radius) are consistent across multiple Z-levels.

### Phase 6: Build the OpenSCAD Model

Structure the `.scad` file for readability and customization:

1. **Constants at the top** in OpenSCAD Customizer sections (`/* [Section Name] */`). Every dimension gets a named variable with a comment showing its physical meaning and original coordinate range.
2. **One module per feature**: `back_plate()`, `frame_lower()`, `screw_post()`, `lip_holes()`, etc. Each module is self-contained and uses only the global constants.
3. **Assembly module**: A single `bracket_assembly()` module that `union()`s all additive features, then `difference()`s all holes. This keeps the boolean logic clean and makes it easy to toggle features.
4. **Resolution control**: A single `$fn` parameter controls circle smoothness globally.

Modeling patterns:
- **Rectangular frame**: `difference()` of outer `cube()` minus inner `cube()`.
- **L-shaped plate**: `union()` of two overlapping `cube()` calls.
- **Through-hole**: `cylinder()` with height extending past the material (add 1mm on each side with `-1` offset and `+2` height to ensure clean boolean cuts).
- **Ring/post**: `cylinder()` for the outer, with a through `cylinder()` subtracted.

### Phase 7: Render and Compare

1. **Render** with `openscad -o output.stl model.scad`.
2. **Compare** using a reusable Python comparison tool that computes:
   - **Bidirectional surface distance**: Sample 50k points on each surface, find nearest point on the other surface using `trimesh.nearest.on_surface()`. Report mean, max, 95th/99th percentile.
   - **Volume difference**: Compare `mesh.volume` values.
   - **Bounds match**: Check bounding boxes agree within tolerance.
   - **Topology match**: Compare Euler numbers.
3. **Iterate** if the Hausdorff distance exceeds the tolerance. Common fixes:
   - Wrong dimension by a small amount → re-examine vertex coordinates at that Z-level
   - Missing feature → look at the worst-mismatch sample points to locate the problem area
   - Circle approximation error → increase `$fn`

### Phase 8: Verify the Accuracy Target

The final gate is the bidirectional Hausdorff distance. For this task the target was 0.1mm; the achieved result was 0.004mm (25× better than required). The residual error comes entirely from polygon approximation of circles (`$fn=64` gives a theoretical max error of `r × (1 - cos(π/64))` ≈ 0.0024mm for r=2mm).

## Key Lessons

1. **Z-level analysis is the critical insight for prismatic parts.** If the mesh has only a handful of unique Z values, the part is a stack of extruded profiles and can be exactly decomposed.
2. **Cross-sections + simplification finds the primitives fast.** Shapely's `simplify()` with a small tolerance (0.05–0.1mm) collapses arcs to their key points while preserving sharp corners.
3. **Euler number tells you how many holes to find.** Don't stop looking for features until you can account for all `(2 - χ) / 2` topological handles.
4. **Face normal grouping separates flat vs. curved surfaces.** Axis-aligned normals (±X, ±Y, ±Z) are planar faces; all others are cylinder walls. The Z-component of non-axis normals reveals whether cylinders are vertical (Z=0) or angled.
5. **Up/down face area sums serve as checksums.** Compute the expected area of each horizontal surface from your model parameters and verify it matches the STL. This catches dimension errors before rendering.
6. **Model in original coordinates, not relocated.** Keeping the STL's native coordinate system avoids translation errors and makes comparison trivial.
7. **Build the comparison tool first.** A reusable `compare_stl.py` with surface sampling and Hausdorff distance makes iteration fast and objective.

## Reusable Tools

All tools live in `tools/` with CLI interfaces, `--help`, and `--json` output.
See `tools/README.md` for full usage.

| Tool | Phase | Purpose |
|------|-------|---------|
| `tools/stl_info.py` | 1 | Mesh triage: stats, topology, genus, components |
| `tools/stl_zlevel.py` | 2 | Find discrete height levels, face areas, vertex coords |
| `tools/stl_cross_section.py` | 3–4 | Slice mesh, extract & classify 2D polygons |
| `tools/stl_normals.py` | 4 | Face normal grouping, cylinder feature detection |
| `tools/compare_stl.py` | 7 | Bidirectional Hausdorff distance, volume, topology |

### Quick-start workflow

python3 tools/stl_info.py part.stl                          # What am I dealing with?
python3 tools/stl_zlevel.py part.stl --vertices              # Layer structure + corners
python3 tools/stl_cross_section.py part.stl                  # Auto-slice cross-sections
python3 tools/stl_normals.py part.stl                        # Find cylinders and holes
python3 tools/stl_cross_section.py part.stl --axis x --at 0  # Hidden internal features
# ... write OpenSCAD model ...
openscad -o output.stl model.scad
python3 tools/compare_stl.py part.stl output.stl             # Verify accuracy

## Deliverables

| File | Purpose |
|------|---------|
| `tools/` | Reusable analysis toolkit (see `tools/README.md`) |
| `bracket.scad` | Parametric OpenSCAD source with customizer sections |
| `bracket_output.stl` | Rendered STL for comparison |
| `plan.md` | Progress checklist with identified components and results |

…and yes, it also created tools for its own use. It’s not a chimpanzee using a stick to get at termites, but it is pretty close: it’s an LLM creating its own toolchain to get at the underlying geometry of a mesh.

This is far more sophisticated than I expected, and it shows that LLMs can be used for scoped reverse-engineering tasks with the right prompting and constraints–but it also shows that you need to be able to understand the problem domain and guide the model with the right structure and checks to get a usable result.

The caveat is that this is a very specific use case (STL to OpenSCAD for prismatic parts), and I wouldn’t expect the same approach to work for more complex shapes or different file formats without significant adjustments. But it’s very much above and beyond what we could do a year ago.

Now excuse me while I go and give it a development board’s dimensions and ask it to design a custom case for it…

Update: Pretty impressive results on the custom case as well–here’s a first draft of it, which is already pretty close to what I need:

An Orange Pi 6 Custom Case, generated after a few web searches and image references

Feb 15^th 2026 · 3 min read · #ai #go #notes #porting #testing

Notes for February 8-15

This was a grueling week at work, but I managed to keep polishing my tools, even if I decided to reinvent a couple of wheels in the process.

`go-te` and `webterm`

Since I kept coming across weird edge cases in pyte, I decided to create go-te, a Go equivalent that complies with the esctest2 test suite. This was rather a roundabout way to ensure I could port webterm to Go, but the icon alone was totally worth it:

Gophers masquerading as terminals are doubly cute

After that was done, porting webterm to use go-te and improve responsiveness only took a couple of hours.

Go is great for AI-assisted porting

I am very happy with Go as a target language for most of my new projects–I had been meaning to switch to it wholesale a few years back, but the opportunity to have AI deal with all the messiness of its error handling and map out the standard library for me has been unparalleled.

Right now, it’s the best language for my use cases, since it has:

Native speed (with some runtime overhead, but much better than Python).
Full portability (including WASM, which I’ve found very useful in go-rdp and webterm).
The standard library is still not fully “batteries included”, but there is now a huge range of stable libraries that are direct slot-ins for most of my needs, and the ecosystem is finally mature.
Extreme LLM/AI friendliness (Go’s strict interface definitions and formatting conventions mean it’s almost impossible for an LLM to confuse similar symbols, and I’ve had pretty much zero compilation errors over several projects)
Great support for testing and fuzzing (even if a tad too basic sometimes)

And yeah, I could probably have done Rust instead, but I prefer code I can read without delving into too many abstraction layers, and I haven’t yet come across a Rust-shaped problem (even if I am eyeing some C++ embedded hardware project ideas).

Test-driven porting is the way to go

As far as doing AI-assisted porting, the best results I’ve had have been when I can leverage an existing test suite to steer the LLM towards the right behavior and edge cases. This is especially true when the original codebase is large and complex, and when the target language has a different paradigm or ecosystem.

The Preact port of the Node-RED dashboard I did over the holiday season didn’t have a lot of tests, but the existing JS code could be coaxed into play. I’ve been poking at it slowly because bun still has broken WebSocket support, but it was one of the first major test-driven ports I did with Codex 5.1, and it showed me how to steer LLMs effectively at medium scale.
go-rdp plays off the MSRDP specs to build its test suite (and there are copious references on the Internet), and I could leverage a lot of my knowledge and background into steering the models directly towards testing the weird edge cases. I’m using it daily (although I need to clean up and push some tweaks).
go-ooxml is in a bit of a weird spot right now because the ECMA specifications have some gaps and modern Office versions have enriched the schemas in compliant but formerly unforeseen ways, but it is very much usable and will be part of a future project I’m planning out.
go-busybox is still churning through the original busybox test suite, and the real sticking point right now is ash and OS signal handling (which I might not even need in a WASM environment, but which I would like to have working).
go-te, my pyte replacement, used both the pyte and esctest2 test suites to validate terminal behavior and build a completely usable library overnight.
webterm was ported to Go in less than two hours, largely because the test suite was translatable across as well.
go-textile is my Go port of the Textile markup parser, which uses a variant of the RedCloth test suite to ensure compatibility with the reference implementation.
sashimi, my ongoing port of this site’s Python engine to Go, is using that and is pretty much done as well, except for the changes I want to make going forward. The core was “done” in less than two hours, and I had over 9000 “test cases” of live site content (then I spent two more hours having it optimize a custom wordcloud generator to ~87ms, which was a fun intellectual puzzle).

None of these things are perfect, and they’re at most 80% production-grade if you intend to make them load-bearing for a business venture, but they are excellent for my use cases because I had zero alternatives that matched my requirements.

And I am focusing on libraries and tooling on purpose–right now, I don’t think I can trust AI to build a full product from scratch without a lot of human oversight, but this way I can trust it to build the building blocks that I can then stitch together and harden as needed.

Feb 14^th 2026 · 1 min read · #ai #hardware #inference #llm #opinion #rant

The Haves and The Have Nots

One thing I’ve noticed over the past few weeks is the huge gap in both perception and availability of AI.

William Gibson is, again, right: The future is already here—it’s just not very evenly distributed.

Take a dive into the churning cesspool of Twitter/X, and it’s pretty obvious: on one side we have obvious influencers (and people with what has to be significant disposable income) claiming to run OpenClaw with the most expensive Claude Opus subscriptions, and on the other side people who are bargain-hunting inference endpoints or trying to make do with open-source models.

But what amazes me are the people who are paying north of $20,000 for fully kitted out Mac Studios—sometimes in pairs or trios—to run local inference. I will freely admit I wish I had that amount of money lying around (I am still trundling along with a 3060 and a pretty much vanilla MacBook), but the key thing I’m noticing is that people without the means to access frontier AI models (or even decently performing local ones) are quite likely not going to be able to form any sort of grounded opinion on AI usefulness.

Open-source models are being hyped as one of the things that will change this, but the latest GLM and Kimi releases (or even the Qwen3 variants) all require an eye-watering amount of resources, so they aren’t going to help bridge this gap.

The result is that we have a growing divide between the haves and the have-nots in the AI space. Those with access to powerful models and resources are able to experiment, innovate, and create new applications, while those without are left behind, or (even worse) unable even to realize what is happening.

I have no solution for this, especially not when personal hardware is getting so expensive, but I hope we’ll sort it out over the next few years—preferably by moving models to the edge and making them more efficient, which has been one of my pet peeves for a while now.

Feb 10^th 2026 · 1 min read · #classic #emulation #hardware #mac #macclock #raspberrypi

Hacking the Maclock ➹

I’ve been sleeping on doing mine, which has been sitting next to the larger 3D printed version for a couple of months now.

Even though I spent quite some time to try to improve Basilisk II performance, I kind of lost the plot with all the other AI hackery that took place since, but I I have all the right parts and everyone seems to have sorted out how to open the case without breaking anything, so this is very high up on my list of things to do over Mardi Gras.

Feb 9^th 2026 · 1 min read · #french #games #rpg #screenshots #xbox

Clair Obscur

Le cul de sac — I've actually never played RPGs before, but Expedition 33 has a… certain style to it. Maybe it's the French dialogue.

Feb 9^th 2026 · 1 min read · #android #nvidia #shield #updates

Nvidia's 10-year effort to update the Shield TV ➹

We’ve had one of these in the house for years, and it’s insane how good and genuinely smooth it’s been throughout.

Ours has survived two Apple TV generations and is still our go-to to watch most things, to the point where I’m starting to dread replacing it because there just isn’t anything else out there that is at least half as good in the Android space.

Feb 7^th 2026 · 3 min read · #agents #ai #docker #golang #notes #productivity #python #swift #weekly

Notes for February 2-7

Half my working week was spent at an internal company thing, so I decided to make the best of my weekend and start cutting down on coding a bit.

I still want to spend most of my free time building things, but there is a bit of a grind associated with the current state of the agent ecosystem and I need to get back to building physical things.

Polishing The Grindstone

But I just can’t stop myself from polishing stuff, and I was having a niggling issue with webterm and pyte, so I dove into ANSI land again and fixed tmux alternate-screen handling so that full-screen redraws don’t overlay stale content in the SVG snapshots, and finally figured out that Ink (the React TUI framework–yes, people are using React for TUIs…) had some quirks around screen clearing, so I ended up monkey-patching pyte to handle those.

The highlight of that was that I got some repeatable skills out of that–I used tmux itself as a debugging tool, and then got Copilot to write down the screenshot debugging workflow as a repeatable SKILL.md it can reuse later.

vibes got some ACP protocol fixes and now restarts the agent more consistently–I’ve been using it to update link tables in the wiki and add TODOs for myself, using Copilot and gpt-5-mini as a back-end, and I’m starting to question whether I need to keep developing python-steward–I kept poking at it, but I just don’t have the time to fully kit out an agent harness.

But I made sure to add some of the key missing pieces: It can scan .github/skills, load Copilot-style instructions, preserve SKILL frontmatter correctly, and structures the context correctly for caching, so I learned a lot about the “plumbing” of agent workflows, and I can always add more features later if I decide to keep going with it.

agentbox now ships with more built-in SKILL.md files and all the little conventions (how I structure workspaces, how I debug things, how I ship), so every new project starts with a decent set of skills to get the ball rolling, and I can just ask Copilot to adapt them to the project at hand.

The Fun Bits

To help me recover my Obsidian vault, I built daisy, a live disk usage sunburst visualizer, completely on a whim on my Linux laptop, and then ported it to the Mac (with a native Swift CLI version as well) because I wanted something with live updating and better performance than the existing options.

It’s also a nice demo for something I’ve been arguing (and occasionally annoying people with): SPEC-driven, agent-assisted development can be ridiculously fast when the problem is well-scoped and the feedback loop is tight.

Since I would be spending two days at the office, I decided to fix one of my gripes with Tailscale (the fact that it can’t resolve .local hostnames when you’re on the road) and ended up building mdnsbridge, a mDNS to DNS bridge that runs on a node that can see the LAN, queries avahi-daemon for .local names, and answers normal DNS queries with the results using Tailscale split DNS feature.

This also reduces an important bit of friction for me: I can use .local URLs and machine names for everything from everywhere, without having to worry about weird DNS names or tunneling into the LAN with a full remote desktop session just to get access to local-only services.

Another thing I’ve been tinkering with is apfelstrudel, an “AI Agent for music coding” that uses the strudel.cc engine.

It's not very musical on its own, but I'm trying to make it so

And, finally, I published go-busybox, a busybox clone written in Go, because I wanted a sandboxable, WASM-ready set of Unix utilities that I can use as a base for building more complex agents and tools without having to worry about the security implications of running arbitrary binaries.

As usual, the icon was the most fun part to design, AI or not:

All those cute, industrious Go Gophers

I think I have enough side projects for now, so I’m going to focus on circling back to some of the stuff I started during the holiday season and get it to a more polished state. But before that, I want to spend some time doing some electronics work and building some physical things…

Feb 6^th 2026 · 3 min read · #ai #engineering #llm #media #openclaw #opinion #rant #skills #tools

Accelerando, But Janky

The past couple of weeks have been sheer madness in the AI hype space, enough that I think it’s worthwhile capturing the moment for posterity.

The Madness

A key insight I’ve had this Thursday is that I think I’m regretting going back to Twitter/X, because everything is so loud there. I went back to follow Salvatore, Armin and Mario, so my “For You” feed is now all AI, all the time, and although I can tune out the FOMO it induces, the pace is exhausting, particularly around OpenClaw.

OpenClaw might be a blip, but right now it has spawned another Cambrian explosion of DIY agents, with everyone and their lobster creating minimal/more secure/tailored versions of it. If sandboxing was already high on everyone’s mind, the fact that people are actually giving API keys and “money” to a set of convoluted digital noodles running in a JavaScript runtime with administrative privileges drove everyone over the edge in various ways.

In short, it’s the Wild West, and there are no stable, clear patterns emerging yet.

Which is why I’ve decided that my current sandboxing solution is going to stay the way it is for the foreseeable future. I’m still developing a sandboxable/WASM-ready busybox clone, but I’m going to wait it out until proper reusable patterns emerge (spoiler: I don’t think we’ll get to a consensus this year, unless sticking to containers is a consensus).

The Frontier

Both Anthropic and OpenAI launched their incremental updates this week, pretty much on schedule and confirming my years-long assertion that the decreasing returns phase of LLMs would be compensated by relentless optimization—but no amazing breakthroughs.

Still, both are pretty decent upgrades. Since I have pretty big SPEC-driven projects built with their previous iterations, I’ve let both loose on those codebases (I have taken to asking for a code smell/best practices/logic and security audit, including writing fuzzing tests) and both Opus 4.6 and Codex 5.3 spotted a few things.

What they both lack, sadly, is taste. Claude models tend to be much better at creating UIs than Codex but write absolutely shit tests, and Codex will often design API surfaces that make sense but are cumbersome to use—and neither of those traits (nor the annoying “personality” twists some stupid product managers insist on instilling on the models) was fixed by this week’s updates.

The demos are, of course, amazing, but what should matter at this point is accuracy (against specs), correctness (of code), and speed (which is what Codex 5.3 improved for me). I don’t particularly care about other people’s use cases, and neither should you.

Engineering Skills

I’ve been sticking to the new GitHub Copilot CLI because I can get any frontier model on it, so I’ve been isolated from the OpenCode/minimal agent hype. I do like Pi and it’s minimal, shell-like workflow and approach, but am still convinced that we need higher-level tooling (because, again, my ultimate goal is not to build coding agents).

Regardless of tools, people have finally cottoned on to skills—and although I think there is a relapse to the voodoo/cargo-culting of early prompt engineering approaches, there are a few useful nuggets out there worth collecting and adapting.

My take on it has been to fold them into a skel folder in agentbox, and asking Copilot to "take the skills, workflows and instructions from this URL and adapt them to the scope of our SPEC.md" for every new project - both Codex and Claude are smart enough to not just duplicate the structure, but also to rewrite the skills to better suit the project, which is delightful.

Then during the project I will often ask Copilot to capture a specific workflow into a new skill (for instance, this week I got some feedback on Swift development, and that is now codified in this file).

And after things stabilize a bit, I can take any truly new skills or useful updates and put them back into my little archive, rather than collecting random stuff off the Internet that might never really suit my workflow and tooling.

Media

One of the few worthwhile outcomes of dipping into Twitter/X is that I can gauge the mass market impact of image and video generation with a broader view than just hanging around r/StableDiffusion, and this week was quite interesting in that regard.

Kling has been seeding social media with pretty amazing (but still detectable) AI shorts. They claim Hollywood is dead, but realistically I’d say video advertising (where impactful short content rules and there is maximal return) is going to be revolutionized, because good creatives will certainly know what to do with it.

That is worrying on several fronts, especially considering that even official sources seem to be using AI-generated media these days.

But I am cautiously optimistic that once visual inconsistencies are sorted out (or at least minimized and papered over by human SFX editors) we might see some actually good content coming out of it.

Feb 3^rd 2026 · 1 min read · #ai #anthropic #apple #development #mcp #openai #xcode

Xcode 26.3 adds Claude/Codex and MCP ➹

(Checks notes.) is this… Apple finally doing… AI?

Xcode 26.3 getting official Claude and Codex integration without the usual guardrails is interesting enough, but having MCP in the mix is… unusually open for Apple.

Given Claude’s propensity to botch up Swift semantics, though, I’m happy they announced both–and although I’m not surprised they didn’t add any Apple models, I would have expected Gemini to be in the mix, even this early.

But at least they seem to have done their homework where it regards the in-editor agent harness–not sure how deep they went into IDE primitives (file graph, docs search, project settings), though, and the apparent lack of skills and other creature comforts that all the VS Code–based tools have is a bit of a bummer.

The fact that they put the chat interface on the left in total defiance of everyone else’s design is, of course, because they just had to mess with our heads.

Design is how it works, after all.

Feb 1^st 2026 · 2 min read · #agents #ai #go #notes #python #rdp #specs

Notes for January 26 - February 1

I’ve had some feedback that my last few weekly notes (especially over the holidays) have been a bit too long and that I should try to keep them shorter and more focused on a single topic.

Well, this week I wrote a lot thanks to the inclement weather and some insomnia, so I broke most of it out into separate posts:

Seizing The Means Of Production (Again) covers my ongoing efforts to build a minimal-friction agent management setup using agentbox and webterm.
Vibing with the Agent Control Protocol dives into my new Slack-like web interface for chatting with AI agents via ACP, called vibes.
Thoughts on AI-Assisted Software Development in 2026 is a quick brain dump of some of the lessons I’ve “learned” this week.

This is the age of TikTok, after all, and attention spans are shorter than ever, so I might as well try to adapt.

But there was a lot more going on this week, so here’s a quick roundup of two other things I worked on:

`go-rdp` Improvements

My web-based RDP client got UDP transport support—experimental, gated behind a --udp flag, but apparently functional. So far it’s going well, even if MP3 audio support is not all there yet (and yes, I know it’s a bit much for a web client).

This is one of my “things that should exist” projects that I’ve been using to experiment how to spoon-feed AI agents with highly complex protocol specs, and it’s been working out great so far, largely because RDP is so well documented.

The test suite now includes Microsoft Protocol Test Suite validation tests for RDPEUDP, RDPEMT, RDPEDISP, and RDPRFX. It’s the kind of spec compliance work that’s tedious but essential, and that I am increasingly convinced can be massively sped up with AI (after all, it took me less than a working week of continuous effort to do the whole thing, instead of the months it would have taken me otherwise).

`go-ooxml` from OO to… Hero?

As another data point, I decided to build my own Office Open XML library in Go this week, called go-ooxml. It too is meant to be a clean-room implementation, and I intend it to be a comprehensive replacement for the various format-specific Python libraries out there–I’ve already been using Go as an accelerator for Python in things like pysdfCAD, so I know it works.

And it also fits into the “things that I think should exist” category, because existing Go libraries for this are either abandoned, incomplete, or have APIs that make me want to cry.

And on the AI front the ECMA-376 spec is perfect:

It is a real thing people used for other implementations, and progress has been ridiculous–agents are genuinely useful for this kind of spec-driven implementation work.
In about two days (less than four hours of “actual work”), I went from initial project setup to enough to handle basic document creation (mostly Word, which is the most complex)

Is it production-ready? Of course not.

But it’s already more complete than many alternatives, and having the foundation right means I can add features as I need them without fighting the architecture.

Agents make the breadth possible, but they don’t remove the need for taste: deciding what the public API should look like, what’s testable, and what’s going to be maintainable six months from now is, of course, the hard part still to come…

At least I’m aware of it, I guess.

Feb 1^st 2026 · 1 min read · #agentbox #agents #ai #cicd #docker #go #ios #notes #specs #webterm

Thoughts on AI-Assisted Software Development in 2026

A few things I jotted down during this week’s bout of coding with AI agents–i.e., while building out my agentbox and webterm setups and other things.

Agents love specs. My go-ooxml project went from nothing to 60% spec compliance in days because I fed the agents the actual ECMA-376 spec documents and told them to implement against those. No hallucination about what XML elements should be called, no invented APIs—just spec-compliant code.

Mobile is an afterthought until it isn’t. Half the webterm fixes this week were iOS/iPad edge cases. If you’re building tools you’ll use on multiple devices, test on all of them early, because agents can only help you with things that they can test for autonomously.

The unglamorous work matters. I did a lot of CI/CD cleanup jobs, release automation, Docker pipelines, and invested quite a few hours in creating solid SKILL.md scaffolding–none of this is exciting, but it’s what separates a tool you can rely on from a tool that occasionally bites you, and right now, for me, at least, it’s what makes AI agents genuinely useful.

There’s going to be more software. With such a low barrier to entry into new languages, tools or frameworks, any decent programmer is soon going to realize that their skills are transferable to the point where they can take on work in any technology.

There’s going to be more shitty software because, well, there are a lot of overconfident people out there, for starters, and the law of averages is inevitably going to kick in at some point. I am acutely aware that I am treading a fine line between “productive developer leveraging AI” and “architecture astronaut”, but my focus is always on shipping self-contained, small tools that solve real problems (for me, at least), so I hope I can avoid that pitfall.

The number of truly gifted developers is going to stay roughly the same, because programming, like any form of engineering, is a mindset much more than it is a skill.

Some of these are debatable, of course, but they are my current take on things. Let’s see how they hold up over time.

Feb 1^st 2026 · 4 min read · #acp #agents #ai #iphone #mcp #preact #sqlite #sse

Vibing with the Agent Control Protocol

Although most of my actual work happens inside a terminal, I have been wanting an easy way to talk to the newfangled crop of AI agents from my iPhone.

Feb 1^st 2026 · 5 min read · #agents #ai #ansi #docker #llm #notes #python #terminals #wasm #webgl #webterm

Seizing The Means Of Production (Again)

Since last week, I’ve been hardening my agentbox and webterm setup through sheer friction. The pattern is still the same:

Feb 1^st 2026 · 3 min read · #docker #proxmox #smb #synology #til #timemachine #zfs

TIL: Apple Broke Time Machine Again On Tahoe

So… Here we are again.

Today, after a minor disaster with my Obsidian vault, I decided to restore from Time Machine, and… I realized that it had silently broken across both my Tahoe machines. I use a Synology NAS as Time Machine target, exporting the share over SMB and that has worked flawlessly for years, but this came as a surprise because I could have sworn it was working fine a couple of months ago–but no, it wasn’t.

For clarity: It just stopped doing backups, silently. No error messages, no notifications, nothing. Just no backups for around two months. On my laptop, I only noticed because I was trying to restore a file and the latest backup was from December. On my desktop, I had a Thunderbolt external drive as a secondary backup.

After some research, I found out that the issue is with Apple’s unilateral decision to change their SMB defaults (without apparently notifying anyone), and came across a few possible fixes.

What Seems To Be Working Now

I found this gist, which I am reproducing here for posterity, that seems to be working for me, but which entails editing the nsmb.conf file on the Mac itself–which is not exactly ideal, since I’m pretty sure Apple will break this again in the future.

sudo nano /etc/nsmb.conf # I used vim, of course

…and adding the following lines (the file should be empty):

[default]
signing_required=yes
streams=yes
soft=yes
dir_cache_max_cnt=0
protocol_vers_map=6
mc_prefer_wired=yes

The explanation here is that macOS Tahoe changed the default from signing_required=no to stricter control, and NAS devices with relaxed SMB settings cannot handle this without explicit configuration.

Another common pitfall is name encoding issues in machine names, so you should remove Non-ASCII Characters from the .sparsebundle name (that wasn’t an issue for me, but YMMV).

On the Synology side, the recommendation was to go to Control Panel > File Services > SMB > Advanced and set:

Maximum SMB protocol: SMB3
Enable Opportunistic Locking: Yes
Enable SMB2 Lease: Yes
Enable SMB Durable Handles: Yes
Server signing: No (or “Auto”)
Transport encryption: Disabled

That doesn’t quite match my DSM UI, but it’s close enough, and my settings now look like this:

My SMB settings, as of DSM 7.3.2-86009-1

My Backup Backup Plan

Since I’m tired of Apple breaking Time Machine every few years and the lack of transparency around this (it’s not Synology’s fault), I have decided to implement a more robust solution that doesn’t depend on Synology’s SMB implementation.

I already have a Proxmox server with ZFS as the backend storage that has an LXC container running Samba for general file sharing, so I decided to look into that as a possible Time Machine target.

As it happens, mbentley/timemachine is a Docker image specifically designed for this purpose, and it seems to be well-maintained, so I’m testing it like this:

services:
  timemachine:
    image: mbentley/timemachine:smb
    container_name: timemachine
    restart: always
    network_mode: host
    environment:
      - TM_USERNAME=timemachine
      - TM_GROUPNAME=timemachine
      - PASSWORD=timemachine
      - TM_UID=65534 # 'nobody' user
      - TM_GID=65534 # 'nobody' group
      - SET_PERMISSIONS=false
      - VOLUME_SIZE_LIMIT=0
    volumes:
      # this is a pass-though mountpoint to the ZFS volume in Proxmox
      - /mnt/shares/timemachine:/opt/timemachine
    tmpfs:
      - /run/samba

Right now the first option seems to be working, but I will probably switch to the Docker solution in the near future, since it gives me more control over the SMB implementation and avoids relying on Synology’s software.

But if anyone from Apple is reading this: please, stop breaking Time Machine every few years. It’s a critical piece of infrastructure for many users, and the lack of communication around these changes is frustrating.

The Third Way: Borg Backup

I have been using Borg for some time now on Fedora, and I am considering using it for my Macs as well. Vorta seems decent, I just haven’t tried it yet.

A Minor, Yet Annoying, Additional Problem

Plus I’m annoyed enough that earlier this morning I tried to set up a new iOS device and the infamous Restore in Progress: An estimated 100 MB will be downloaded… bug (which has bitten me repeatedly over the last six years) is still there.

The usual fix was hitting Reset Network Settings and a full hardware reboot, plus reconnecting to Wi-Fi… But this time it took three attempts.

Come on, Apple, get your act together. Hire people who care about the OS experience, not just Liquid Glass.

Jan 29^th 2026 · 1 min read · #accelerando #ai #assistant #automation #calendar #chatbots #email #madness #moscow #nt #productivity #telegram #whatsapp #windows

OpenClaw, Accelerando in our timeline ➹

As someone who (until a few days ago) owned the lobsters.social domain and has long been into the gag of digitized lobsters evolving into self-aware AI (yes, Accelerando is one of my favorite books of all time), I have been following the madness around this for a bit, although i did not commit to the insanity of devoting hardware to it and was not (still am not) impressed by the code quality or utter lack or any substantial guardrails (security or otherwise).

It’s bad enough to use insecure public IM to talk to one of these things, but giving it root on a machine is madness (never mind the influencer gags around buying a Mac mini for it), so after running it on a VM for a couple of days and seeing how it was “designed”, I punted and kept doing my own (sandboxed) thing.

I’ll let other people go for the AI Darwin awards, or at least try to sandbox it sanely in the cloud.

But what sets it apart from most other personal agents for me is the huge (if uneven and creaky) skill library it’s generating–people are using it for completely off the wall stuff, and going through the list feels like Reddit on crack.

My own agent is much more contained (I made it a point of not letting anything permanently loose or with access to any of my personal data), so I’m just making popcorn until one of these things causes real damage, financial ruin, or both.

Still, the idea is worth a look because it’s aiming at the right interface: chat is where people already are, and turning that into a command line for personal admin is a sensible direction (when it’s done with guardrails).

And it makes you wonder if Apple will ever do this properly with Siri/Gemini in any useful way that matters–but I’m not holding my breath here.

Update: They rebranded again, so I’m updating the link… Like the original lobsters, things are a bit chaotic over there, but I really liked the vibe of this interview.

Jan 25^th 2026 · 8 min read · #agents #ai #docker #llm #notes #productivity #weekly

Notes for January 19-25

Since last week, I’ve been heads-down building a coding agent setup that works for me and using it to build a bunch of projects, and I think I’ve finally nailed it. A lot more stuff has happened since then, but I wanted to jot down some notes before I forget everything, and my next weekly post will probably be about the other projects I’ve been working on.

Jan 25^th 2026 · 13 min read · #hardware #minipc #n150 #nas #openmediavault #review #ssd

The NestDisk

This one took me a while (for all the reasons you’ll be able to read elsewhere in recent posts), but the NestDisk has been quietly running beside my desktop for a month now, and it’s about time I do it justice.

Jan 24^th 2026 · 1 min read · #apple #bugs #engineering #ios #mac #metrics #productivity

Bugs Apple Loves ➹

A+. No notes… Oh well, OK, I’ll say my piece.

“Total time wasted by humanity because Apple won’t fix these” is a wonderfully blunt premise, and the math is… lovely: Base Impact is Users Affected × Frequency × Time Per Incident was enough of a zinger, but the Power User Tax (Σ (Workaround Time × Participation Rate)) and the Shame Multiplier (Years Unfixed × Pressure Factor) just pile it on.

Clearly nobody at Apple is measured by these OKRs, or we wouldn’t be constantly finding new UX disasters like breaking the Finder column view (which now stupidly lets the scroll bar overlap the resizing handles).

Hey Craig, why don’t you adopt the Shame Multiplier for your directs, or at the very least start having some sort of AI-driven Apple Feedback pipeline that actually tries to fix the code instead of acting as a black hole?

Jan 18^th 2026 · 5 min read · #agentic #ai #dev #grafana #homelab #notes #observability #sandboxing #syncthing #synology #telemetry

Notes for January 1-18

Return to work happened mostly as expected–my personal productivity instantly tanked, but I still managed to finish a few things I’d started during the holiday break–and started entirely new ones, which certainly didn’t help my ever-growing backlog.

Jan 17^th 2026 · 10 min read · #ai #automation #feeds #news #python #rss #sqlite #summarization

My Rube Goldberg RSS Pipeline

Like everybody else on the Internet, I routinely feel overwhelmed by the volume of information I “have” to keep track of.

Jan 17^th 2026 · 1 min read · #9front #agents #ai #plan9

A Plan9 AI agent ➹

I actually considered doing something like this during my holiday break, but ended up fixing drawterm instead and never got around to it.

But I don’t think I could have done a better job than Jasmin did in this writeup, and the agent itself is pretty neat. If I wasn’t behind schedule on pretty much everything right now, I’d be hacking on it myself, and it’s just depressing to ponder when I’ll be on vacation again…

Jan 17^th 2026 · 1 min read · #comics #corporateculture #dilbert #eulogy #humor #scottadams

The Dilbert Afterlife ➹

Scott Adams passed away this week, and regardless of the controversies that surrounded him of late, anyone who’s been reading this site since the beginning knows I have a soft spot for Dilbert.

As a telco person, it resonated with me so much (and had so many touch points with my daily life) that I was even accused of tipping Adams off about some of the absurdities I witnessed in the field.

And it stayed eerly accurate for decades, which is why I’m linking to this post, which I think pretty much captures the essence of Dilbert and its creator, with all its ups and downs, controversies, and humor.

And, of course, I’d like to share one of my favorite Dilbert strips, which I think completely nailed our future:

I've been using this one since I worked on NetMeeting over ISDN, and it's aged pretty well

Jan 14^th 2026 · 4 min read · #ai #llm #mcp #skill #skills

Notes on SKILL.md vs MCP

Like everyone else, I’ve been looking at SKILL.md files and tried converting some of my MCP tooling into that format. While it’s an interesting approach, I’ve found that it doesn’t quite work for me as well as MCP does, which is… intriguing.

Jan 13^th 2026 · 2 min read · #apple #apps #creativity #music #video

Apple introduces Apple Creator Studio ➹

Apple is bundling Final Cut Pro, Logic Pro, Pixelmator Pro, Motion, Compressor, and MainStage into a new subscription suite (with the obligatory vague promise of AI features) and revamping Pages, Numbers, and Keynote with more content, which I find interesting in many respects…

First off, I’ll state the obvious: this is a jab at Adobe’s Creative Cloud, which has dominated the professional creative software market for years, with the side effect that it pretty much dried up the low-end prosumer space.

By offering a comprehensive suite of “professional-grade” applications under one subscription, Apple is positioning itself as a viable alternative not just for creatives who may have been hesitant to invest in Adobe’s ecosystem, but also for those looking for more affordable options.

But… how viable is it, really? I have my doubts, especially given that I recently tried Final Cut Pro and found it lacking in several areas compared to freemium competitors like DaVinci Resolve. And I have been using Logic Pro for years. It’s a solid DAW, but it faces stiff competition from Ableton Live and an increasing number of free or low-cost alternatives. But that’s my personal experience; I wonder how this will play out for the broader market, where there’s stuff like Affinity Suite, which has recently surfaced after the Canva acquisition as a free alternative to Pixelmator Pro (with paid add-ons).

Apple’s move is interesting because of its breadth and ambition–it’s great value for money for consumers, and does offer a lot of tools that can be used professionally. However, I think it also confirms one of my hunches, i.e., that (statistically) nobody was paying for the iPad app subscriptions.

And I do have to wonder how many people they have developing and maintaining all these apps–there have been many glitches and issues with Final Cut Pro and Logic Pro over the years that make me think they are not exactly top priority for Apple.

Update: Gruber’s round-up of reactions to the hideous new icons is well worth reading. I just took the whole thing in stride since it’s pretty obvious thwt Apple just doesn’t care about good UI design anymore, but this amazing zinger from Heliographe Studio made me laugh out loud:

Jan 12^th 2026 · 3 min read · #agents #ai #china #coding #llms #opencode #proxy #security

When OpenCode decides to use a Chinese proxy

So here’s my LLM cautionary tale for 2026: I’ve been testing toadbox, my very simple, quite basic coding agent sandbox, with various LLMs.

Jan 11^th 2026 · 1 min read · #design #hci #macos #madness #tahoe #ui #usability #ux #windows

Mis-resizing windows in macOS Tahoe ➹

There’s a special kind of UI regression that doesn’t look like a regression until you try to use it, and the Liquid Glass Tsunami just keeps on giving.

The huge rounded corners are turning a basic motor skill into a hand-eye coordination puzzle, and this piece goes into exquisite detail on that, and demonstrates how Apple completely botched window resizing.

Spoiler: the resize hotspot is still a 19×19px target, but with the new corner radius “about 75%” of that target ends up outside the visible window. So you do what any reasonable person does and aim inside the corner (where the window actually is), and nothing happens.

The best part (in a dry, slightly tragic way) is the conclusion: the “most reliable way” to resize is to grab outside the corner, which is exactly the kind of invisible affordance that makes people feel like they’re going slightly mad.

It’s also a neat reminder that Fitts’s Law doesn’t care about your design language, and that hit-testing should follow what users perceive as the object boundary, not whatever geometry is easiest to keep from the previous release.

Oh, and that whoever did Tahoe’s UX design is borderline incompetent.

Worth reading because it’s not just a rant, it’s a small, well-illustrated teardown of how a cosmetic change can quietly break muscle memory and cause endless attrition and frustration.

The annotated images (green “expected” area, blue dot, and the “accepted target area” sitting in empty space) make the point better than any amount of hand-waving, and we need more of this to make it obvious that Apple needs to reverse course on the whole thing.

Jan 10^th 2026 · 1 min read · #arena #film #lisbon #meo #orchestra #photo #photography #starwars

Lisbon Film Orchestra

Great start to the show — A little while ago, in a concert hall not that far away…

Jan 10^th 2026 · 1 min read · #ai #culture #markdown #web #writing

How Markdown Took Over the World ➹

Anil Dash’s essay on how Markdown conquered everything is a good reminder that most “standards” don’t win because they’re perfect — they win because they’re good enough, easy to use, and easy to remember.

What I liked most is the through-line from early blogging (by which time I was also doing a PHP site generator that handled raw HTML posts) to today’s world, where LLMs are running stupefyingly complex workflows atop a pile of Markdown files.

It’s both empowering and a little unsettling that the same affordances that made writing on the web easier also make it easy to formalize instructions for systems that can do real damage.

I took a long detour through Textile before accepting Markdown had won (and am still paying the price for that, with thousands of Textile posts still to be converted), but the one thing I’ve found amusing over the years is that John Gruber created Markdown as a way to make writing HTML easier for humans.

One person can make a difference, and I’m willing to bet that when (ok, if) we ever become a Kardashev type 3 civilization we’ll still be using Markdown to write our interstellar missives.

Jan 9^th 2026 · 5 min read · #azure #cloud #cloudflare #compose #docker #homelab #infra #proxmox #sqlite #tailscale

How I Manage My Personal Infrastructure in 2026

As regular readers would know, I’ve been on the homelab bandwagon for a while now. The motivation for that was manifold, starting with the pandemic and a need to have a bit more stuff literally under my thumb.

Archives • 3D Site Map

go-te and webterm

Go is great for AI-assisted porting

Test-driven porting is the way to go

Polishing The Grindstone

The Fun Bits

The Madness

The Frontier

Engineering Skills

Media

go-rdp Improvements

go-ooxml from OO to… Hero?

What Seems To Be Working Now

My Backup Backup Plan

The Third Way: Borg Backup

A Minor, Yet Annoying, Additional Problem

`go-te` and `webterm`

`go-rdp` Improvements

`go-ooxml` from OO to… Hero?