Work

I run an AI consulting firm and I build things with my hands. This page holds the work I can show, and every claim on it is checkable: the code runs, the links are live, and the numbers come from scripts you can download and rerun.

Client systems ship under NDA, so they are not listed here. The patterns from that work are public in the essays.

alexander@aros:~$ ls work/
~/work/01-aros.md

alexander@aros:~/work$ cat 01-aros.md

--- lines_handwritten: 5,872 npm_dependencies: 0 windows: 9 skills_tracked: 56 stack: JavaScript, CSS, HTML, Node.js, Azure App Service, Playwright, Pillow ---

#AROS, the portfolio that is its own proof

The site you are on is the flagship project. Instead of a page that claims frontend skill, it is a desktop operating system built from scratch in vanilla HTML, CSS, and JavaScript. Anyone can view source and check the claim.

##The build

A window manager with focus, z-order, drag, tile, and cascade. A boot sequence that plays once and gets out of your way. A terminal that answers more than 25 commands, including stacktop, a live skills monitor rendering 56 technologies with tier badges, load bars, and a grep filter. A ⌘K command palette. A release-notes system that greets returning visitors with what shipped since their last visit. There is no framework and no build step: package.json lists zero dependencies, and the whole thing is served by a 58-line Node static server on Azure App Service with its own MIME map, cache policy, and www-to-apex redirects.

##The part that fought back

The desktop has a browser window showing the real ryshe.com homepage. Naive full-page screenshots ghost fixed elements and break 100vh layouts, so the capture pipeline drives headless Chrome through real scroll positions, grabs overlapping viewport segments, and stitches them with Pillow while cropping the sticky header out of every segment after the first. Small problem, real engineering.

~/work/02-tools.md

alexander@aros:~/work$ cat 02-tools.md

--- tools: 5 open_source_repos: 5 tests_across_set: 43 server_calls: 0 stack: Vanilla JS, zero-dependency ESM, node:test, GitHub Actions ---

#The LLM Tools Suite

Five free, no-signup tools for people shipping LLM systems, with a bar for what earns a spot: each one does something you would not paste into a chatbot, either because the data is sensitive and never leaves your tab, or because it leans on data I maintain and measure by hand.

##What they do

The Bill Analyzer reads your real Anthropic or OpenAI usage export entirely in the browser and shows spend by model and day, your cache hit rate, and what caching and routing are worth. The Cache Linter takes two consecutive request payloads and finds the exact character where your cache prefix breaks and the monthly cost of the miss. The Price Tracker keeps hand-verified rates with a dated event log and an RSS feed that fires only when a price moves. The Benchmark Lab puts the 800-question chunking dataset behind an interactive view and runs your own corpus through the same chunkers. The Sample Size Calculator does the eval power math, paired designs and judge-noise attenuation included.

##The engineering bit

Each tool's engine is a zero-dependency ES module with a CLI, open source under github.com/AlexRyan92: 43 tests across the set, pinned to hand-verified reference numbers, with CI on Node 20 and 22. The cache linter's CLI exits nonzero on a cache-busting payload, so it slots into a pipeline. Shared pricing lives in one dataset file that the tracker, the analyzers, and the model reference page render, so a price change is one edit.

~/work/03-benchmark.md

alexander@aros:~/work$ cat 03-benchmark.md

--- questions: 800 strategies: 3 index_tokens: 161,426 (identical across strategies) recursive_vs_fixed: +9.6 recall@1 stack: Python, sentence-transformers, all-MiniLM-L6-v2, SQuAD v1.1 ---

#The chunking benchmark: folklore, measured

Most chunking advice is vibes. I measured it: three splitting strategies on 20 SQuAD articles and 800 real questions, embedded with all-MiniLM-L6-v2, scored as answer recall at k, on a laptop CPU. The script is published so anyone can rerun the whole thing.

##Headline numbers, no overlap

Strategyrecall@1recall@5Index tokens
Fixed-size61.1%87.4%161,426
Sentence66.9%88.9%161,426
Recursive70.8%89.6%161,426

##The surprise

Overlap helps recall but overshoots badly at span granularity: asking for 30 tokens of overlap produced 17.5% duplication on fixed chunks, 44.6% on sentence chunks, and 78.3% on recursive chunks, because overlap gets rounded up to whole sentences and paragraphs. And by k=5 the three strategies nearly converge, which means rerank depth can rescue a bad splitter.

~/work/04-content-engine.md

alexander@aros:~/work$ cat 04-content-engine.md

--- essays: 23 (all cluster-mapped) series_on_deadline: 2 original_datasets: 1 auto_generated: 0 stack: Technical SEO, schema.org, Pillow, RSS ---

#The content engine

Twenty-three essays in, nothing here publishes when inspiration strikes. The writing runs like an engineered system: topics chosen from real search demand, recurring series with deadlines, and a pipeline where an essay ships with its card, schema, feed entry, and release note in one motion.

##The system

Every essay starts from a question engineers actually search for, then gets mapped to a cluster so the pieces reinforce each other instead of competing. Two series run on deadlines: Failure Modes, one production failure mode a month on first Tuesdays, and a quarterly data report built on an original benchmark. One shared manifest file drives the homepage cards, the essay index, next-essay navigation, and the About window's count, so publishing is a single ritual instead of five chances to forget something. Each essay ships with a script-generated social card, FAQ schema where it earns one, an RSS entry, and a line in the release notes.

##The rule

It is written for engineers who can smell filler: no auto-generated posts, no keyword mush. And when an essay makes a quantitative claim, the script that produced the number gets published next to it.

~/work/05-ship-loop.md

alexander@aros:~/work$ cat 05-ship-loop.md

--- ai_coauthored_commits: all but the first agent_pushes: 0 (a hook refuses them) deploys_hash_stamped: 100% benchmark_scripts: 1 published stack: Claude Code, git hooks, Azure CLI ---

#The ship loop: AI-assisted, human-gated

This site ships almost daily, with an AI agent doing much of the labor and a set of hard guardrails deciding what it is allowed to do. That loop is what I help clients build at Ryshe, and here it runs in production on my own property.

##The guardrails

The agent writes code, runs builds, and deploys, but it cannot push to the repository: a hook refuses the command, so a human runs every push. Fabricated numbers are banned, which is why the chunking data on this page came from a benchmark I ran rather than a plausible-sounding guess, with the script published alongside the report. Every deploy is stamped with its git hash, which the site footer reads live from /version.txt, and every meaningful change lands in the release notes.

##Why it is on this page

Every commit behind this site except the very first carries an AI co-author trailer, and every one of them was reviewed before it landed. The interesting engineering is not the prompt. It is the system around the model: what it may touch, what requires a human, and how claims get verified before they go live. That is the same discipline I bring to client AI adoption.

~/work/06-ryshe.md

alexander@aros:~/work$ cat 06-ryshe.md

--- linked_domains: 2 publishing_pipeline: 1 (webhook-driven) manual_rebuilds: 0 delivery: 100% static stack: Astro, Azure Static Web Apps, Azure DNS, Python, TypeScript ---

#Ryshe, the company and its platform

Ryshe is my AI and cloud consulting firm. It exists to bridge the gap between AI promises and IT reality: strategy, retrieval systems, evaluation pipelines, MLOps, and cloud architecture, delivered with honest engineering. I run it, and I also built its platform end to end.

##The platform

ryshe.com is an Astro static build on Azure Static Web Apps, with DNS on Azure. Publishing is webhook-driven: when content lands, the site rebuilds itself, so nobody at Ryshe runs a deploy by hand. The architecture is deliberately split across two properties: ryshe.com speaks to buyers, this site speaks to engineers, and structured data links the two so search engines understand they share an author.

##The practice

Client systems ship under NDA. What I can show is the thinking: the essays here document the patterns from that work, from evaluation pipelines to observability for silent degradation, and the tools are the utilities I kept rebuilding on engagements, made public.

alexander@aros:~/work$

The full technology list lives in the Tech Stack window on the desktop, or type projects in its terminal. For what shipped recently, see the release notes.