Blog on Metaheuristic - Applied AI partner

Ship the Recipe, Not the Binary

Sat, 22 Aug 2026 00:00:00 +0000

You want a markdown viewer. Not a remarkable one. You want a window that opens a file and renders it the way you like, with your font, without a sidebar you never use. You find one on GitHub: four thousand stars, MIT licensed, a maintainer who answers issues. You download the release DMG, drag it into Applications, and the first time you point it at your notes folder macOS asks whether this app may access Documents. You click Allow, because an app you installed to read documents cannot read documents otherwise.

Spec-Driven Development Is the New Scrum

Fri, 21 Aug 2026 00:00:00 +0000

It is month four. The repository has a constitution.md, a spec.md, a plan.md, and a tasks.md. All four are current, all four were reviewed, and everyone involved did the work honestly. CI is green. The burn-down on tasks.md is a clean staircase and the team shipped more surface area this quarter than in the previous two combined. Then a reconciliation job starts double-counting refunds on retry, and it takes four days to find, because the person who wrote the retry semantics into the spec is not the person who reviewed the generated code, and neither of them is on call. Nothing in the spec is wrong. Nothing in the test suite is red. The system simply does something no one intended and no artifact in the repository disagrees with it.

Legacy Code Is Not the Spec

Mon, 10 Aug 2026 00:00:00 +0000

Nobody designed the system you are maintaining. It accreted. The service is on its third generation of team: the first team picked the database because it was the one they knew, the second team wrapped it in an ORM to survive the first team’s schema, and the third team, yours, inherits both decisions plus the workarounds each layer grew to tolerate the one below it. None of these choices was crazy at the time. Aggregated across ten years and three handoffs, they add up to an architecture no one would choose on purpose, defended by nothing except the cost of replacing it.

Code Review Is the Interview Now

Wed, 05 Aug 2026 00:00:00 +0000

Here is an interview format that tells you more in forty-five minutes than any whiteboard ever did. You hand the candidate a pull request: a few hundred lines, generated by a coding agent, tests included, CI green. The description is confident and well formatted. The code is clean, consistently named, sensibly commented. You ask one question: would you merge this? Then you watch. Some candidates skim for five minutes, find nothing structural to object to, and say it looks good. Others start pulling threads. Why does the retry wrap a POST that isn’t idempotent? Why does the new endpoint check the session but never the tenant? Why does the migration add a non-nullable column to a hot table? Same diff, same clock, completely different engineers.

AI Made Writing Code Cheap. Verifying It Is the New Bottleneck

Sun, 02 Aug 2026 00:00:00 +0000

In July, Jarred Sumner announced he had ported Bun from Zig to Rust in about eleven days, using a fleet of Claude agents running in parallel. The port added over a million lines of Rust and burned roughly $165,000 in tokens at API list prices: 5.9 billion uncached input tokens against a TypeScript test suite acting as the conformance oracle. Whatever you think of the outcome, the economics are the story. A rewrite that would have taken a team years of effort now costs about one senior engineer-year of salary and less than two weeks of wall clock.

Why Haskell Is Losing the LLM Era

Sun, 02 Aug 2026 00:00:00 +0000

In July, Avi Press published a post that made the rounds twice, once on Hacker News and once, more painfully, on the Haskell community forum. After seven years of running Haskell in production, Scarf is migrating to Python. Not because the type system failed them. Not because of hiring, though that never helped. The dominant reason was newer than either: LLM coding agents changed the economics of the language, and Haskell ended up on the wrong side of the trade.

Delta verification: assert the change, not the state

Tue, 14 Jul 2026 00:00:00 +0000

The eval dashboard says your flow-builder agent passed again last night. Twenty runs, twenty green. Then a customer asks why none of their flows exist, you open the staging workspace, and the truth is ugly: the agent’s create call has been returning 401 since an API key rotated two weeks ago. Every one of those green runs proved nothing. The verifier checked flow_count >= 1 at the end of each run, and the workspace it ran in has held a handful of flows since March. The assertion was true before the agent spent a single token.

depwal: a dependency firewall for pip and poetry

Sat, 11 Jul 2026 00:00:00 +0000

The dangerous moment in a Python project is not when you write code. It is when you type pip install. That command reaches out to an index, downloads an archive built by a stranger, and runs their setup.py as your user, with your environment variables, your SSH keys, and your cloud credentials sitting one os.environ away. You have not imported anything yet. You have not read a single line of what you pulled. The code already ran. And here is the part people miss: pip install --dry-run runs it too, because pip has to build the package to learn what it needs.

Elwen: a probe harness that tests what you just shipped

Tue, 07 Jul 2026 00:00:00 +0000

Something quietly broke in the last year. We got very fast at shipping. A new endpoint, an auth change, a data migration, a tweak to a page layout - the kind of change that used to take a day now takes an agent twenty minutes. But the way we check that change still assumes the old speed: write assertions against fixtures, run them, ship, and hope staging matched reality.

The assertions only cover what you already thought of. That was fine when a human wrote every line and knew where the bodies were buried. It is not fine when the model wrote the diff and neither of you has poked the running thing yet.

The abstraction tax: MCP versus a plain CLI

Tue, 07 Jul 2026 00:00:00 +0000

Open a fresh agent session, connect the ten MCP servers your team has standardized on, and watch the token counter before you have typed a single instruction. It is already deep into five figures. The servers loaded every tool they expose - names, descriptions, JSON schemas, enum values, field-level docs - straight into the model’s context, and they did it eagerly, all of them, whether or not this particular task will touch a single one. You are paying rent on capability you are not using. That is the abstraction tax, and once you see it you cannot unsee it: the Model Context Protocol buys you a tidy integration story by charging your context window up front, on every request, forever.

How Claude keeps from calling tools in a cycle

Mon, 06 Jul 2026 00:00:00 +0000

Give a capable model a set of tools and a hard problem, and most of the time it does something impressive. But every so often it gets stuck in the least glamorous failure mode there is: it calls search("q3 revenue"), reads the result, decides it is not quite enough, and calls search("q3 revenue") again. And again. The tool returns the same thing every time, because the world did not change between calls - but the model keeps hoping it will.

The blackboard pattern for multi-agent memory

Sun, 05 Jul 2026 00:00:00 +0000

Put two agents in a room and they need a way to share what they have learned. The tempting design is direct messages: the researcher agent calls the writer agent, which calls the critic agent, which calls back. Within a week you have a tangle where every agent imports every other, and adding a fourth agent means editing the other three.

The Blackboard pattern, invented for the Hearsay-II speech understanding system in the 1970s, solves it by removing the direct connections entirely. Agents never talk to each other. They read from and write to a shared structured memory - the blackboard - and a controller decides who acts next. It is a beautiful fit for multi-agent systems, and it is barely a hundred lines of Python.

State of AI dev - June 2026: the month the demo stopped counting

Tue, 16 Jun 2026 00:00:00 +0000

There’s a sentence that showed up, almost verbatim, in three different client kickoffs this month: “It worked in the demo.” It’s always said as a defense and it always means the same thing - the thing was built, somebody recorded a Loom, and then it met real users, real permissions, and real data volume, and it fell over. June was the month the wider industry stopped pretending the demo was the hard part. A widely-shared piece on the forward-deployed engineer put it plainly: a RAG chatbot over 10 documents “works like magic” in the honeymoon phase, but move it to thousands and “efficiency, accuracy and security collapse under the weight of unmanaged complexity” (iNews24). That collapse is the entire job now. This is what we saw.

The agent loop: ReAct from scratch

Wed, 10 Jun 2026 00:00:00 +0000

Strip away the framework marketing and an LLM agent is embarrassingly small: a loop that asks a model what to do, does it, feeds the result back, and repeats until the model says it is done. The 2022 ReAct paper (Reason + Act) gave this loop its name and its shape. Everything else - tool registries, routers, memory - is scaffolding around this one control-flow skeleton.

In this article we build that skeleton in plain Python. No framework, one small dataclass, and a loop you can read in a single sitting. By the end you will have a working agent and, more importantly, a mental model precise enough that every framework you touch afterward looks like a variation on the same theme.

The rise of skill-matched, momentum-driven code reviews (and the fall of the static review queue)

Fri, 08 May 2026 00:00:00 +0000

For most of the last fifteen years, code review meant the same thing in every shop: a human wrote a pull request, another human picked it up sometime between this afternoon and never, and a third human eventually merged it. The loop was slow because the cost of writing code was high, so a few hours of latency on top didn’t matter.

That assumption has quietly evaporated. The model now writes the diff in seconds. The queue still takes a day. The bottleneck moved.