Ponderly

An open source Claude Code plugin that holds coding agents to my rules, sends each request down the right route and stops to ask when it should. It's built to lower the author's mental load, and this site is where it was tuned.

project · 2026 · updated 8 Nov 2026
~/dansabin.com — chat Ask about this project

Can you trust a coding agent to follow your team's rules?

Not on its own, for long: rules fade as a session grows. Ponderly is the Claude Code plugin I wrote to build this site. It keeps loading my rules into every agent, sends each request down the right route, and has a second agent review each batch of work while it's still being written. It's open source on GitHub, at version 1.8.0, and I've merged more than 100 pull requests with it.

What changes when the review happens while you're coding?

One afternoon I was tearing down a test environment, and the session found a small bug on the way: the CAPTCHA key's delete step failed when the key was already gone, and left the stack stuck. It offered a one-line fix and a test, and I said yes, so that deletes would come out clean.

The executor wrote it, and 65 tests passed. That's usually where I'd open a pull request. Five minutes later the wave reviewer, reading that batch against the design, came back with a blocker: "CloudFormation refuses to change an export value that another stack imports ... So the api stack update would fail and roll back."

Changing the delete step counts as a change to the key, so on any environment that already held one, the next deploy would make a new key, and the stack that reads it would refuse the change. That only shows up against a live environment. The reviewer said it had worked this out from how CloudFormation behaves, not watched it happen.

The session suggested keeping the one-liner and rebuilding the one environment it affected. I asked to have the other option explained, then picked it: mint the key once and never again. No deploy replaces it.

Building that, the executor stopped once more before writing past the design. Reading the key a new way would have renamed the export, the same trap one level down. The session kept the old name. Twenty-five minutes after the first sign of the bug, every other stack's template was unchanged and the redeploy kept the same key. It went into the pull request as one commit, and nothing in the pull request raised the key again.

Where the CAPTCHA key problem is caught Two paths for the same one-line fix. In the wave, the tests pass, the wave review finds a blocker, the key is made once, and one commit goes into the pull request. Later, the tests pass and the pull request's build is green, then the next deploy of an environment that holds a key is refused and rolls back, making another key. CAUGHT IN THE WAVE One-line fix 65 tests pass Wave review finds a blocker Choose B key made once One commit pull request merges CAUGHT LATER One-line fix 65 tests pass Pull request green build Next deploy export refused Rollback makes another key Where the CAPTCHA key problem is caught Two paths for the same one-line fix. In the wave, the tests pass, the wave review finds a blocker, the key is made once, and one commit goes into the pull request. Later, the tests pass and the pull request's build is green, then the next deploy of an environment that holds a key is refused and rolls back, making another key. CAUGHT IN THE WAVE One-line fix 65 tests pass Wave review finds a blocker Choose B key made once One commit pull request merges CAUGHT LATER One-line fix 65 tests pass Pull request green build Next deploy export refused Rollback makes another key
Two paths for the same one-line fix. In the wave, the tests pass, the wave review finds a blocker, the key is made once, and one commit goes into the pull request. Later, the tests pass and the pull request's build is green, then the next deploy of an environment that holds a key is refused and rolls back, making another key.
Where it's caughtWhat it costs
In the wave, while it's being writtenOne more review round and a slightly bigger change. 25 minutes.
In the pull requestA reviewer spotting an export rule in a green build.
At the next deploy of an environment that holds a keyA failed deploy and a rollback that makes another key and may leak one, then a rebuild of that environment.

How it works

Every request to change code goes through one skill, start-task, which reads the code it touches and picks a route. A contained change goes to one task-executor agent. A bug goes to bugfix, which reproduces it before anyone touches the code. Everything else gets a spec: requirements, a design and a task list, each approved before the next is written. implement-spec builds a spec one wave at a time, with a fresh sub-agent per task, and a wave-reviewer reads each wave against the requirements and the design, grading each problem blocker, should-fix or nit. An executor that finds the design doesn't fit the code stops and asks rather than guessing.

Hooks load the rules into every session and sub-agent, and bring them back as a session gets long. Around that, eleven skills, four agents and six rules, under the MIT license, cover cleanup, pull request review and planning. The goal is the author's mental load: it starts slower with little context, speeds up as context builds and conflicts stay few, and slows back down when one comes up.

Does it work

I watch how long a change takes to reach a pull request that merges cleanly, how widely that time ranges, and what it costs. Inside that, I watch blockers caught per wave, before merge. On this site, the wave reviewer has read 410 waves of work. 138 of them, about one in three, held at least one blocker: 235 blockers in all, about one for every two waves, each found while the code was still being written. A blocker is the reviewer saying a change can't ship as written, at the point where changing it is still cheap.

MeasureOn this site
Waves reviewed410
Waves with at least one blocker138, about 34%
Blockers found before merge235, about 0.57 per wave

The pull requests that follow move quickly. Of the 173 merged on this site, half went from opened to merged in 18 to 34 minutes, the median was 20, and nine in ten took under two and a half hours. Most of that time is the build and its checks.

Those counts include cleanup passes and second reviews of a fixed wave. A blocker is the reviewer's call, and some, like the CAPTCHA one, are inferred rather than observed.

I've merged more than 100 pull requests with the agent now. More time will tell, but that's the context I have for the coding skills, because they aren't benchmarked.

Only the code review skill has outside figures. They're averaged over five batches covering 25 pull requests on one published benchmark:

MeasureAverageRange
Known problems foundabout 59%43% to 70% per batch
Runtime per pull requestabout 11 minutes5 to 22 minutes
Cost per pull requestabout $5$2.24 to $10.62

The runs were on plugin versions 1.4.0 and 1.4.1, on Claude Opus at high effort. Six of the 25 recorded no cost, so $5 may be low. The review skill has changed since, and I haven't rerun it. When I do, I'll update these.

What it costs

A review in the loop costs more turns, and I accept the cost. In the CAPTCHA case it was one more review round, a slightly bigger change and 25 minutes, all before the pull request opened.

I don't yet measure what each pull request costs in tokens. That's the next figure I want beside the time.

It only knows what the requirements and the design say. A wave reviewer can't flag a problem the spec never mentions, and a blocker it infers can be wrong. The decision still comes to me, and what I review changes with the stage of the work.

Where it came from

After I left Amazon I played with Codex and Claude for fun. As my projects got more complex, the results got inconsistent and I was tired of swapping tools, so I rebuilt what I'd learned into one Claude plugin and dogfooded it on this website. The name is a small joke: Ponder is a fun word and quite apt for how we can use AI. Also, back in the old startup days everything ended in "ly" so it stuck.

Getting it

It's on GitHub, and an llms.txt file helps agents find it. It isn't in the official Claude plugin directory, because listing would have meant changing how the hooks keep sub-agents on the same rules, and I've raised that through Anthropic's developer feedback mechanisms.

claude plugin marketplace add sabind/ponderly
claude plugin install ponderly@sabind

What's next

Runbook execution, a three-layer hierarchy (I'm running one today), and Cursor, Codex, MCP and AWS Strands from one canonical source compiled for each destination. The strategy, high level design and low level design skills stay, and I want to give them a sparring partner, so the process supports the authorship and not only the finished look.

More on Ponderly

Three pages go deeper:

How it was built. The rules that changed from using it on this site.

How I work with agents. From CodeWhisperer to a day spent in one main session.

Ask before you build. Why an agent that stops to ask isn't slower, shown by a wrong premise one caught before it wrote a line.

Want the details?

Ask the window anything this page skips.