Inanna Malick inanna-malick

Am I spending my neuroplasticity wisely?

I’ve been setting up structured journal entries recently - quick morning notes, weekly and quarterly retrospectives, etc. As part of this I’ve been curating a list of questions to help self-assess how I’m doing at any given time.

Some of these questions are simple bio-maintenance checklist entries: how’s my diet? Am I getting enough sleep? Are my cholesterol and triglyceride levels normal? Have I been getting enough vitamin D? Have I been doing resistance exercise recently? Cardio?

Then come some less concrete questions: have I been keeping myself intellectually engaged? Have I been engaging in some regular form of artistic creation? When’s the last time I did something nontrivial just for the fun of it? Aside from work stuff, when’s the last time I finished a project? Speaking of work, how are things there? Attempts to answer that question could fill multiple blog posts, so for now I’m going to focus on a specific angle pointed out by

inanna@inanna-x1-carbon:~/dev/phf_bug_demonstrator$ rustup default 1.40.0
info: using existing install for '1.40.0-x86_64-unknown-linux-gnu'
info: default toolchain set to '1.40.0-x86_64-unknown-linux-gnu'

  1.40.0-x86_64-unknown-linux-gnu unchanged - rustc 1.40.0 (73528e339 2019-12-16)

inanna@inanna-x1-carbon:~/dev/phf_bug_demonstrator$ cargo build
   Compiling phf_bug_demonstrator v0.1.0 (/home/inanna/dev/phf_bug_demonstrator)
    Finished dev [unoptimized + debuginfo] target(s) in 0.14s

VIBES-RFC-001: LLM Ergonomics

VALIDATION_SCOPE = "Tested with: GPT-4.5, Claude 4 Opus, Gemini 2.5 Pro, DeepSeek V2"

1. Introduction

VIBES provides a structured framework for evaluating and improving the ergonomics of tools and expression languages designed for LLM use. As LLM-driven development becomes mainstream, the economic impact of poor tool ergonomics compounds exponentially through failed attempts and workarounds.

Core Insight: LLMs and humans need fundamentally different tools. Just as we don't expect humans to write assembly code or CPUs to parse English, we shouldn't force LLMs to use human-optimized interfaces. The most effective approach is building purpose-specific tools for each type of user.

LLMs as UX Testers

You built a developer tool that does something really cool. You use it every day. The learning curve is steep, but in the course of developing this tool, you have become intimately familiar with the interface, so it's intuitive to you. This is a post about turning that tool into something that can find broad utility among developers, not just N=1 utility for you.

Many of the things that make tools good and useful for humans also make tools that are good and useful for LLMs. It's that Venn diagram intersection that I want to focus on, because that's where LLMs can help you improve your command line tool's UX.

The Problem

Every tool has a complexity budget. Users will only devote so much time to understanding what a tool does and how before they give up. You want to use that budget on your innovative new features, not on arbitrary or idiosyncratic syntax choices.

	# If you come from bash you might have to change your $PATH.
	# export PATH=$HOME/bin:/usr/local/bin:$PATH

	# Path to your oh-my-zsh installation.
	export ZSH=/home/pk/.oh-my-zsh

	#needs to be before theme
	POWERLEVEL9K_MODE='awesome-fontconfig'

	# git clone https://github.com/bhilburn/powerlevel9k.git ~/.oh-my-zsh/custom/themes/powerlevel9k

	URxvt.scrollBar: false
	urxvt*termName: rxvt
	urxvt*font: xft:uushi:pixelsize=16
	urxvt*boldFont:
	urxvt*background: #000000
	urxvt*foreground: #666699
	urxvt*cursorColor: #6699CC
	urxvt*colorBD: #CCCCFF

	!Visiblue


	//stack-safe anamorphism (unfolding change). Builds a tree layer by layer.
	pub fn ana<X>(f: impl Fn(X) -> Tree<X>, seed: X) -> FixTree {
	let mut instructions: Vec<Option<X>> = vec![]; // depth first, Some == add child w/ seed, None == back a level
	let mut path_to_root: Vec<&mut Vec<Box<FixTree>>> = vec![]; // pointer to children of focused node
	// ^ this breaks it, requires multiple borrows... drop this in a gist (or use refcel, rain says to do so)

	let root = f(seed);
	match root {
	Tree::Leaf(n) => FixTree(Tree::Leaf(n)),

	#!/usr/bin/env run-cargo-script
	//! requires `cargo install cargo-script`
	//!
	//! ```cargo
	//! [dependencies]
	//! guppy = "0.6.2"
	//! structopt = "0.3.21"
	//! serde_json = "1.0"
	//! serde = "1.0"
	//! toml = "0.5"

	pub fn generate_layer(x: Box<ExprAST>) -> Expr<Box<ExprAST>> {
	match *x {
	ExprAST::Add(a, b) => Expr::Add(a, b),
	ExprAST::Sub(a, b) => Expr::Sub(a, b),
	ExprAST::Mul(a, b) => Expr::Mul(a, b),
	ExprAST::LiteralInt(x) => Expr::LiteralInt(x),
	}
	}

	pub fn eval_layer(node: Expr<i64>) -> i64 {