This is the first in a series of posts where I walk through my agentic coding setup. In this episode I give a high-level overview of my stack — the tools, how they fit together, and why I’ve landed on this particular combination.

Links

• My Nix configuration — Nix configuration for the Lima VM and my other hosts
• Lima — Dev VM creation
• Secret proxy — The secret proxy I use to inject secrets into the VM
• Sprites — A hosted sandbox option
• Jujutsu — Alternative VCS compatible with Git
• Pi — A wonderful agentic coding harness

YouTube Kids is a major disappointment. Despite a recent refresh the app is buggy and devoid of basic features:

• Videos from subscribed channels doesn’t appear in the app. Viewing the same channel on YouTube shows significantly more videos.
• There’s no way to navigate to subscribed channels and view all of the videos. You can only browse via an algorithmically generated feed.
• Our account is configured to only allow parent-approved content. However, the search feature often returns no results with no explanation why.
• My partner and I are members of the same Family account however she sees different child accounts in her view than I do in mine. We seem to have created a split-brain family account that I can’t figure out how to resolve.

I spent some time over the holiday break figuring out a self-hosted alternative to YouTube Kids that has addressed all of my problems and left me with a more feature-rich alternative. The kids have branded it DadaTube.

On the difference in developing for Rust vs OCaml:

I love Rust. It’s so fast. It’s so beautiful. But you have to do all these types, all these clones, all these lifetimes and it can be really distracting.

When you’re doing something like web development where it’s mostly IO bound, where you’re waiting on the database, where you’re waiting on the HTTP request, where you’re doing all this waiting there is really no point to carry the burden of having to write all these types. Instead you’re in a situation where you’re developing something that you want people to use.

I’m hunting for my perfect web application language (sure to be a future post). So I’ve been exploring OCaml. I prefer Nix for configuring development environments. It keeps things self-contained and increases the chances that I won’t have painful setup issues when I revisit projects months or years later.

I created a flake.nix that configured OCaml and used ocaml-overlay to add Dream to my development environment:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

{
  description = "Expiments in ocaml";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
    flake-parts.url = "github:hercules-ci/flake-parts";
    ocaml-overlay = {
      url = "github:nix-ocaml/nix-overlays";
      inputs.nixpkgs.follows = "nixpkgs";
    };
  };

  outputs = inputs@{ self, nixpkgs, flake-parts, ocaml-overlay, ... }:
    flake-parts.lib.mkFlake { inherit inputs; } {
      systems = [ "aarch64-darwin" "x86_64-linux" "aarch64-linux" ];

      perSystem = { pkgs, system, inputs', ... }: {
        _module.args.pkgs = import inputs.nixpkgs {
          inherit system;
          config.allowUnfree = true;
          overlays = [
            ocaml-overlay.overlays.default
          ];
        };

        packages = { };
        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
            ocaml
            ocamlPackages.dune_3
            ocamlPackages.findlib
            ocamlPackages.ocamlformat
            ocamlPackages.ocaml-lsp
            ocamlPackages.utop

            ocamlPackages.dream
            ocamlPackages.dream-html
          ];
        };
      };
    };
}

This got me up and running until I wanted to use the live reload functionality described in the published documentation. Unfortunately, this feature is only present on main not the 1.0.0.0-alpha5 release present in OPAM and ocaml-overlay.