Tools for working with coding agents, and a few older experiments. All outside my day job, all on GitHub.
kstrl
A software factory for AI coding agents. Hand it a spec and it plans, builds, and measures the result with checks the agent did not write: tests, types, lint and diff scope first, then a reviewer from a different model family on every acceptance criterion, then a security reviewer. Where the measurement disagrees with the agent, the gap goes back as the next instruction, parsed to file and line with a fix hint. Bounds on iterations, time, tokens, cost and what a merge may touch stop it running away. You stay on the loop, not in it: undecomposable specs, approvals and exhausted budgets come to you, everything else flows and is recorded. On PyPI as kstrl.
seven loops around the agent, innermost fastestFIG
telltale
A flight recorder for coding agents. It reads the traces Claude Code and Codex already emit and keeps every tool call, file touched, command, test result, token spent, compaction and commit, and never the prompt, the reply or the contents of an edit. Then it asks what that record can forecast, and tests every answer against four rules of thumb with the bar written down before the run. What an agent is about to spend is partly knowable; what happens to the code afterwards is not, so far, beyond a one-line rule of thumb. The open question needs both halves of a change, and only a running recorder can supply the second.
Python · daemon · 3,300 sessions read, and counting
Your coding agent writes faster than you read, and the picture you had of the system stops matching it. systemap has the agent draw the map from the code, following a written procedure, and a checker refuses a map that leaves a module unplaced, routes a journey through a part it does not touch, or is older than the tree. Every pull request then says what it did to the shape of the system, not just which lines changed. Python only. Ships as a Claude Code plugin and a plain skill.
A review skill for Codex and Claude Code whose output is a merge decision, not a long comment. It fixes the comparison range first, maps the change before judging lines, and accepts a finding only with a trigger, an observable result and evidence in the repository. Review lanes run as independent specialists, coverage is recorded, and the verdict is one of five. An evaluator measures recall, precision and noise on real pull requests; the README says exactly how far each measurement falls short.
Skill · evaluator · paired evaluation on real pull requests
Teach a pull request instead of reviewing it. The skill hands the diff to a reader who did not make the change, because an author cannot see the reasoning that never reached the diff, and builds one arc: where this sits, why each decision went that way, what you need for the next change, and what would make it wrong. It ships with Human-Outward, a writing style for anything meant to be understood: the idea before its name, the answer you rejected, and a mark on how each claim is known.
Skill · output style · four checkers, limits stated
a lesson from a reader who did not make the changeFIG
voice-writing
You can tell when a machine wrote something even when you cannot say what gave it away. This skill names the shapes and strips them, one paragraph at a time, in four passes that each carry one rule and repeat until a sweep changes nothing. A rewrite keeps every fact, hedge and attribution, checked against a ledger built before a word is touched. The profile that ships is mine; it will build one from your own writing.
An AI usage coach built as a loop. Commit to one behaviour for the week, get it cued into every Claude Code and Codex session through hooks, answer a thirty-second check-in afterwards, and review what actually changed. The scoring underneath, six prompting dimensions and a learning-or-atrophying trajectory read from your own sessions, exists so the coaching is honest about whether you did the thing.
Python · Claude Code, Codex and Copilot hooks · weekly loop
It migrates whole Rust systems to Python on its own, file by file, with full type safety and behavioural equivalence testing, learning from its own failures as it goes. Tested on real third-party crates: json-rust (4,710 lines, circular deps, unsafe blocks) translated end to end with 796 tests passing under mypy --strict.
A reference implementation of Recursive Language Models (arXiv:2512.24601): a loop that runs model-written Python over corpora far larger than any context window, sandboxed in Lambda, with span citations you can check and budgets you can set.
A pure-Python engine that lays out PowerPoint slides: flexbox and CSS Grid semantics for decks, resolved down to EMU coordinates. The same input always produces the same slide, which matters once something automated is generating them.
Reusable skill frameworks for AI consulting and GenAI training delivery: creative ideation, consulting playbooks and a five-tier training curriculum, written as modules an agent loads directly.
A Chrome extension that spots cringe LinkedIn posts and blurs them as you scroll, with caching and an adjustable sensitivity dial. I built it because my feed had become genuinely hard to read.