Thoughts on AI agents, automation, and building systems that work
A sixty-page paper where written proofs, kernel-checked theorems, exact box certificates and plain sampling all print with the same face. Four labels, one per claim, and the case that made me insist on them: a certificate that reported green at exactly the configuration the proof turned on.
Read more →
I pasted the wrong thing into 24 conversations on purpose and read every reply by hand. Not one model considered that it might have been a mistake. What varies is not whether they notice — it's how much work they do on something you never asked for.
Read more →
Drop squid rings into a frying pan and two reasonable goals — fit as many as possible, or sear as much surface as possible — turn out to be different problems with different answers. Unless the sizes obey one condition, and then not only do the goals agree: where you put each ring stops mattering at all.
Read more →
A site lost 98.7% of its impressions overnight and stayed there for a month. No manual action, no deindexing, 3,180 pages indexed and rising. What the numbers ruled out, what they reframed, and what I still cannot explain.
Read more →
I audited the 35 memories my agent keeps about this project. Three were stale, and none of them had been wrong when written: they described a state that expired on its own. The other 80% can't be checked at all, and that isn't a flaw.
Read more →
The second half of my SKILL.state replication, on the paper's own model and a second one, with every cell repeated. Explicit state holds exactly where the paper says it does. Where it breaks, it breaks by writing the state wrong — and the runtime that keeps the transcript alongside it barely notices.
Read more →
The ability to let someone else take over your work without needing you for every decision. How to prepare a handover when you work with agents: separating the current state from its history while preserving the reasons.
Read more →
Solving open problems can open new questions. What happens if AI also learns to choose them, why understanding still matters, and what academia should reward.
Read more →
I tested Jev for fraud detection, invoice checking and my work with coding agents. What helped, what did not, and why some improvements cannot reach production.
Read more →
When AI logic deserves its own architectural block alongside the frontend and application backend. Real projects, earlier patterns, and a simpler alternative.
Read more →
A model of the world can be flatly wrong about a whole region, pass every test you can write, and cost you exactly nothing — provably. Move the same mistake a few metres, onto the path something actually walks, and it costs you everything. What decides is not the size or the shape of the error. It is reach.
Read more →
What is documented about benchmaxing, and what a small Opus 5 versus Fable 5 pilot actually found: shared failures, ties, and an intuition the probes did not confirm.
Read more →
A synthesized world model can get a whole region wrong, pass any sampling gate, and cost exactly nothing — provably. Then I opened a 0.1-radian door in that region and the danger collapsed; I hid the same door behind the goal and it stayed at full strength. Same topology, opposite danger.
Read more →
The work that never gets automated isn't the hard work. It's repetitive work that needs a judgement on every row — already being done by hand, inside a chat window. And every way out of doing it by hand asks you to build a product first: an account with a token bill, a prompt you now have to test call by paid call, and an interface for whoever reads the results.
Read more →
A replication of SKILL.state, an EMNLP paper that replaces an agent's conversation history with an explicit mutable state. The token savings are real and the bill savings are not — 7.5x becomes 1.4x once you turn caching on. And where explicit state wins decisively it confirms the paper's own recovery experiment, with a metric the paper never used: explicit state applies the correction in 70 of 72 episodes, against 10 of 72 for the full transcript.
Read more →
I swapped the language model for a random forest and ran the same broken pipeline past forty agents. Nineteen of twenty patch the symptom on each side, with the model and without it. What separates the two arms isn't that they investigate less: it's what they accuse the head of. The model gets called random by nature; the forest doesn't.
Read more →
I gave a hundred and forty agents the same misbehaving classifier and changed one thing: whether they could see its code. What moved wasn't who they blamed — it was whether they looked for the cause at all. And not one of them asked for the data it was missing, even when told outright that asking was allowed.
Read more →
Agents that build systems with an LLM inside keep reaching for the same explanation: the model is nondeterministic. Five times it wasn't, and the interesting part is where the suspicion went instead of where the cause was.
Read more →
OpenAI published a Lean-verified proof that the 3D Navier–Stokes equations can develop a singularity in finite time. Five things the headlines skip: the model wasn't Astra, the break happens exactly where the fluid stops being a fluid, the solution is a spinning skater, a shelf of conditional theorems just changed status, and the route was opened in Madrid by two mathematicians nobody is paying.
Read more →
I degraded four repositories in nine semantically-equivalent ways and measured 2,929 agent runs. In small code nothing measurable happens. In large interconnected code, degrading how it's written halves what the agent solves.
Read more →
A diagram of taxonomies, ontologies and knowledge graphs for AI agents keeps circulating. It reads like an architecture to adopt. It's more useful as a diagnosis: I audited one of my own projects and found four incompatible definitions of its central entity.
Read more →
AI has made software dramatically cheaper to build, but not customers, validation, or attention easier to earn. When another feature is the comfortable option, the hard work begins outside the editor.
Read more →
I took away an agent's ability to run commands, then its access to the registry, and measured what that costs. Then I ran the same matrix on two weaker models. The restriction cost 26% more tokens; the weakest model never once went to look, and filed fourteen reports claiming a release that didn't exist.
Read more →
Across three studies, every measuring instrument I built broke at least once — and every break pointed toward the result I was expecting. On why 'just measure it' is incomplete advice, and what building the reference actually costs.
Read more →
Most teams that try an agent and quietly go back weren't short on skill. They were doing the plumbing by hand — copy, paste, carry the answer back — and that costs the same every single time. What connecting it actually involves, and which part of it you'd have to build yourself.
Read more →
My last preprint concluded that LLMs translate rules and don't infer them. In continuous control that turns out to be false for a wall and true for a circle: the model repairs an omitted 1D rule in 105 of 111 attempts, and never once recovers the 2D version — through eight interventions designed to fix it.
Read more →
Eight lines in a brief took a coding agent's detection of its own false release from 8/15 to 15/15. The clause never says where to look — only who answers for what got published.
Read more →
Every piece of advice about working with agents assumes you picked the tool. Plenty of people didn't. Here's what changes when the choice isn't yours — and the argument to make if it partly is.
Read more →
An external report said the classifier was 54% accurate over 500 companies. The gold set had been generated by a general-purpose model with all 500 at once, and its labels could be guessed from the company name alone. The defensible number was twenty points higher. On when an AI can evaluate another AI, and when it can't.
Read more →
I read 179 real messages between parallel Claude Code sessions: the channel is almost never used to ask for things, but to tell the other one something true about their own work. Then I built the experiment — and watched one session catch another shipping a release that did not exist.
Read more →
You already know how to verify work at scale — tests, CI, pipelines. You're just not applying any of it to the agent. You're checking its output with your eyes, which is the one thing you spent a career learning doesn't work.
Read more →
I was convinced that prescriptive skills get in the way of a frontier model, so I measured it: ~640 responses and 147 agent runs. I was wrong about where the damage is — and once the agent has tools, the benefit disappears and only the bill stays.
Read more →
I rendered text into images and faded it until I couldn't read it, then asked six vision models and two OCR engines to try. They read text at a contrast of one grey level out of 255 — invisible to me — and some of them obeyed instructions hidden there. The margin they have over me turns out not to be sharper eyes.
Read more →
Agents plan around events that never occurred and invent dependencies between things that don't depend on each other. It looks like a missing clock, so I measured it: 572 responses, six models, two domains. The date changes nothing, and one failure gets worse in the strongest models.
Read more →
You described what you wanted, an agent built it, and it works. Here's what to learn first — not the whole list, the order. Written for people who never wrote software and don't intend to start.
Read more →
You can build software now without writing a line of it. What's left isn't coding — it's a way of working, and a list of things you have to know exist or you'll never think to ask. Here's both.
Read more →
A safety filter gave a base64 string a medium self-harm severity. Two judges scoring the same ciphered replies agreed worse than chance. A base model wrote fluent cipher it had never understood. Three systems producing confident verdicts about text they cannot read — and one conclusion of mine that didn't survive the full run.
Read more →
A coda to the trilogy: chasing the specialist's blind spot led somewhere I didn't expect. The hardest ball to locate isn't the one flying through the air — it's the one sitting perfectly still.
Read more →
I ran the same 45 blinded comparisons past a GPT, a Grok and a Claude judge. Each produced a different ranking, each favoured its own answers, and the effect scales with how subjective the task is.
Read more →
Opening up the tiny network that beat the frontier models: ten interpretable geometric numbers recover 92% of it, fancy topology adds nothing, and the model turns out to be overconfident on exactly the cases it gets wrong.
Read more →
I argued that a conversational journey added little over a well-designed form. The call went the other way, so I built it — and the client's feedback settled the argument better than I could have.
Read more →
A tiny network trained on my laptop solves the hidden-ball cases that frontier VLMs can't — and a two-sport transfer study reveals what, exactly, a model learns about a game.
Read more →
Once prompting stops being the hard part, a new question takes its place: which model, at what reasoning effort, for which slice of the work. Choosing well is becoming its own engineering discipline.
Read more →
A claimed counterexample to a 30-year-old conjecture emerged from prompts like 'do a breakthrough' and 'just continue.' The craft of writing the perfect prompt is dying — and something more interesting is taking its place.
Read more →
I hid the ball from vision-language models and asked them to find it from the players alone. The answer was interesting — but the more interesting part was how easily I almost concluded the wrong thing.
Read more →
The next paradigm shift in application development isn't putting an agent inside your app — it's putting your app inside the agent your users already have. MCP is just the current plumbing for it.
Read more →
AI agents keep quoting internal feedback, spec codenames, and process notes in client-facing deliverables. Why it happens, a taxonomy of the three failure modes, and the structural fixes that actually work.
Read more →
The real process behind an AI-assisted preprint — and why the hardest frontier isn't prose but planning the science, where a more capable model stops being a convenience and becomes the thing that lets the work go further.
Read more →
Speak to a language model in a cipher it has never been told the key to, and something surprising happens before any decoding does: some models refuse to play at all. A small experiment on how fast models crack novel codes — and where that runs into a safety wall.
Read more →
I set out to reproduce a DeepMind result and instead found a clean way verification can lie to you: a code world model that passes its gate at 100% accuracy, stays 98% accurate on the states a planner visits, and still loses systematically at play.
Read more →
Karpathy suggested letting a stuck agent restart instead of grinding on. I built a loop with visible tests and measured it: iterating on feedback beats clean restarts at equal compute — and handing the agent a scoped restart button reveals that knowing *what* to discard is what separates the tiers.
Read more →
Say the same thing to a language model far past what any human would tolerate, and the polished ones don't break — they quietly give up. Strip the alignment layer off, though, and the raw model degenerates into loops. A small experiment on what repetition reveals.
Read more →
A recent benchmark says coding agents can't collaborate because they lack social intelligence. I test a different hypothesis: they lack structure — and find that making integration one agent's job recovers collaboration, while merge conflicts mostly mask deeper semantic failures.
Read more →
Why cloud workspaces and AI coding sessions need repository-owned bootstrap scripts for system packages, tests, and builds.
Read more →
When you continually pre-train an LLM into a 'world model', it quietly forgets general knowledge — and a little data mixing buys most of it back. But how much it forgets depends heavily on how you specialize it, and full fine-tuning pays three costs a single benchmark undersells.
Read more →
Agents made building almost free, which exposed what you were actually buying all along — not the software, but the maintenance, the de-risking, and your attention. A build-vs-buy calculus rewritten around the one resource that doesn't parallelize.
Read more →
Reviewing used to mean reading the implementation. Increasingly I verify what the model produced, not the path it took — and what 'verify the result' means changes wildly depending on whether the result is a number or a behavior.
Read more →
I build systems whose business logic I couldn't recite if you woke me up at 3am. The model holds it for me — and that's fine. The hard question isn't how much you delegate, it's whether you can still tell when the answer is wrong.
Read more →
Two philosophies of the client demo — mock-first spectacle vs functional proof-of-concept — and why, with AI, the prettier one hides exactly what matters: latency and non-determinism.
Read more →
Generative UI lets an agent render interactive widgets — forms, charts, signatures — inside the chat instead of plain text. AG-UI is the protocol standardising it, and I've already been building it by hand.
Read more →
Before you write a judge prompt, you owe three decisions: the context, the unit, and the dimension. Here is the framework, applied to evaluating my production DevOps agent.
Read more →
How I built an AI agent that investigates infrastructure issues autonomously — with read-only guardrails, output compaction, and infrastructure knowledge baked into the system prompt.
Read more →
How a simple question about vitamin D synthesis turned into a Claude artifact, then a full PWA with D3.js visualizations, push notifications, and 6 languages.
Read more →
What we write is becoming markdown skills, what users see is becoming generated pixels, and the middle keeps getting thinner. A look at where software is heading in 2026.
Read more →
AI can now build almost anything. The hard part is no longer the code — it's managing your own cognitive limits as you orchestrate multiple agents in parallel.
Read more →
Why most AI-driven tests should be reproducible scripts, not CLI exploration — and how to use each approach effectively based on real deployment automation experience.
Read more →
Lessons from writing a 16-chapter essay with two AI coding tools — why prose is harder than code for AI, and what actually worked.
Read more →
How I used Claude Code to build a recording pipeline, edge-tts for voiceover, ffmpeg for assembly, and Gemini to QA the result — without touching a video editor.
Read more →
How I built an RLM prototype that processes 71 arXiv papers (~1M tokens) without injecting them into the prompt, using out-of-core document analysis with Azure OpenAI tool calling.
Read more →
How to orchestrate multiple AI agents working in parallel using Claude Code's new Agent Teams feature within a tmux session.
Read more →
Analyzing the legal and ethical implications of 'Co-Authored-By: Claude' appearing in commits. Tool or author? The future of AI-generated code ownership.
Read more →TypeScript provides essential guardrails for AI coding agents but creates friction with type errors. The solution isn't changing languages—it's changing workflows with specialized sub-agents.
Read more →
How I built a Claude Code skill that standardizes and automates the creation of bilingual blog articles, ensuring consistency across EN/ES content.
Read more →
A workflow for running multiple Claude Code agents simultaneously on different features, using git worktree to manage branches and automating PR reviews.
Read more →
How Azure's content filter blocks legitimate browser automation tools based on word choice, not actual risk—and simple workarounds that expose the flaw.
Read more →
How I built a comprehensive MCP server with 58 tools to manage Bitbucket repositories, pull requests, and pipelines through natural language.
Read more →