Stephen Cresswell ships Yadda 3 after a one-day Claude-assisted rebuild

Why it matters

Cresswell's release shows how maintainers can use coding agents safely: separate implementation from tests, stage mechanical changes, and treat human attention as the scarce resource.

Stephen Cresswell published Yadda 3.0.0 on August 15th after using Claude Code to modernize the JavaScript testing library in roughly one day, then followed it with version 3.1.0 and support for executable specifications written as GitHub-flavored Markdown.

The releases give Cresswell a concrete case for a larger argument about AI software development: reliable coding agents need constraints they cannot rewrite, and the emerging challenge for engineers is coordinating several capable agents without losing control of the work.

Cresswell says Claude Code, running Opus 4.8, wrote most of Yadda's modernization with few interventions from him. That account has not been independently audited, though the public repository documents the scale and sequence of the changes. The Yadda 3.0 tracking issue, opened on August 13th, divided the work into phases covering obsolete integrations, development tooling, formatting, source modernization, API exploration, examples, continuous integration, documentation and TypeScript definitions.

Cresswell kept mechanical formatting separate from behavioral changes. He also avoided letting Claude change production code and its corresponding tests in the same step. An agent allowed to edit both can make a broken implementation appear correct by changing the tests around it. Yadda's existing test suite instead acted as an external definition of acceptable behavior.

That distinction is the useful part of the release. Agent-generated code is easy to produce. Evidence that the code still does what users expect remains harder.

A maintainer returns to a 2012 codebase

Cresswell has maintained Yadda since 2012, according to the repository documentation. His GitHub profile also points to years of Node.js infrastructure work across amqplib, the Rascal RabbitMQ client, the Systemic dependency-injection framework and the Marv database migration tool. His Stack Overflow profile lists him as Head of Engineering at Haven and shows a long-running focus on BDD, JavaScript and Node.js.

Yadda maps ordinary-language specifications to executable JavaScript functions. It occupies similar territory to CucumberJS, while allowing developers to write specifications without forcing every step into Cucumber's Given, When and Then structure. Yadda plugs into test runners such as node:test, Mocha and Jasmine rather than shipping a runner of its own.

The modernization removed browser bundling and integrations for tools including CasperJS, PhantomJS, Bower and Component. Yadda 3 now requires Node.js 20 or newer, moves its own tests to node:test, adopts Biome and lefthook, updates the source to ES6 syntax, adds Playwright and Puppeteer examples, and includes TypeScript definitions.

Those changes clean out years of JavaScript history without turning Yadda into a new product. The repository describes a package with zero runtime dependencies, just over 2,000 lines of source code and about 200 tests. GitHub showed roughly 410 stars at publication. Those figures indicate a mature, compact open-source library rather than a commercial testing platform with a disclosed customer base or revenue model.

The release sequence also moved faster than Cresswell's original post title suggests. GitHub's tags page lists both versions 3.0.0 and 3.1.0 on August 15th, while the current package file identifies 3.1.0. The later release added Markdown feature files, allowing specifications to render alongside project documentation while remaining executable.

Tests become instructions for agents

Cresswell has long argued that behavior-driven development gives teams a shared vocabulary. A product manager can read a sentence describing an application decision more easily than a programmatic test built from fixtures, mocks and assertions. Developers then connect that sentence to code, giving the prose a way to prove whether the software behaves as described.

AI changes the cost calculation behind that practice. Writing and maintaining specifications has traditionally demanded extra effort before a team sees the benefits. Cresswell argues that agents can turn meeting transcripts, discussions and requirements into draft specifications, leaving people to judge the language and intended behavior.

Once approved, those specifications can guide implementation, review and testing agents. Continuous integration can execute them against the software. The same artifact carries human-readable intent and machine-checkable behavior, reducing the freedom an agent has to interpret an ambiguous wiki page or stale requirement.

Yadda 3.1's Markdown support fits that thesis. Specifications can sit near GitHub discussions, project documentation and source code in a format that humans and coding agents can parse. The executable steps provide the grounding that ordinary documentation lacks.

This does not establish that BDD will become the standard interface for agent-written software. Teams still have to choose useful abstractions, prevent duplicate or procedural steps, and review whether generated specifications capture the actual product decision. A badly stated requirement can be executed faithfully and remain wrong.

Cresswell's method addresses a narrower and immediate problem: keep the agent's implementation work separate from the evidence used to judge it. That principle applies beyond Yadda. Coding agents need independent tests, staged changes and review boundaries if their output is going to earn trust.

The human moves up the stack

After running several Claude Code sessions in parallel, Cresswell found that his own attention became the limiting resource. He could comfortably track three tasks, sometimes four or five, before losing context about decisions, reviews and blocked work.

"The bottleneck is the human coordinating the work," Cresswell wrote in his release essay.

That observation explains why a small BDD library matters beyond its user base. Cresswell used one agent to compress a long modernization into a day, with the tests acting as guardrails. His next constraint was supervising parallel work. The engineering job shifts toward defining contracts, separating changes, preserving context and deciding what evidence is strong enough to merge.

Yadda is Cresswell's attempt to make one of those contracts readable by people and executable by machines. The package remains a specialized JavaScript testing tool. The development method behind its release is the bigger contribution: agents move quickly when a maintainer gives them a sequence, a narrow scope and a standard of correctness they cannot quietly edit away.