v0.13.0

Pairing had one last bad ambiguity: approving the direction could still kick off tests, lint, and the verifier before you got another look at the code. v0.13.0 splits that cleanly now:

• shaping shows the bounded diff first
• named validation runs only what you asked for
• finalization owns focused checks and only adds coverage when changed behavior is actually unprotected
• autonomous delivery keeps proportional TDD and the heavier verification gates

Plans got the same treatment. Roadmaps and pair plans now start with a complete At a Glance scan path, every section and work unit gets a local TL;DR, prose sections cap at two paragraphs, and agent-only resume detail stays collapsed. Plan review happens after the first human look and final approval still gates implementation.

The before/after pairing eval moved from 1/4 to 4/4. The stricter roadmap eval initially landed at 5/6, exposed two missing scan-map rows, then passed 6/6 after the template was fixed.

The Pair Plans extension is unchanged at 0.0.3.

Created by Codex Code

v0.12.0

Upgrade if you use the prep-refactoring guidance. The scratch-refactor steps told you to branch, refactor aggressively with no commits, then "discard the branch entirely" via git checkout - && git branch -D scratch-refactoring — and that discards nothing. Nothing was committed, so the edits follow you back to your real branch and then git deletes an empty branch, with both commands exiting 0. You end up with a throwaway rewrite sitting modified on main while the agent reports the branch discarded. Now uses git checkout --force - and tells you to check git status afterward.

The big change: shaping and delivery are separate

Every change used to go through the whole quality loop — Red-Green-Refactor, both reviewer gates, broad suites — before you got to look at a diff. Thats backwards for pairing, so the skills split on interaction boundary now instead of change type:

• interactive shaping makes the requested edit, shows the diff, and stops. No broad checks, no reviewer dispatch, no quietly added tests
• autonomous delivery only kicks in when you explicitly ask to finish, execute a plan, or make it commit-ready
• "go ahead" authorizes the bounded move under discussion, not the rest of the feature

ruby-programming's SKILL.md went from ~350 lines to 68 on the way through.

brainstorm and execute-plan are model-invocable now

Both were slash-only before (disable-model-invocation: true). The ambient skill says to follow execute-plan when a plan exists, and a gated skill cant be reached that way, so the gate is gone. The shaping/delivery boundary is held by negative triggers in the descriptions instead, and a new eval fires an ambiguous "theres a bug, fix it" at it to confirm it still picks shaping.

Codex

.codex-plugin/plugin.json ships now, so codex plugin add ruby-programming@ruby-programming works. The ${SKILL_DIR} variables are gone in favour of relative bundled paths, so both runtimes resolve references the same way.

Also in here

• brainstorm and ruby-review stopped pulling all 672 lines of design-shapes.md up front. They list the ## Shape headings and read only the ones whose triggers match
• ruby-review was carrying its own drifted copy of the verifier prompt. It points at the shared agents/ruby-verifier.md now, and got its scoped gh/git allowlist back
• new eval file for ruby-review, including PR-URL detection — misreading a PR URL as local changes is silent, and you get a confident review of the wrong diff
• 27 eval cases now have recorded fresh-context runs

The pair-plans VS Code extension is unchanged at 0.0.3. The vsix is attached here so the latest release still has it.

Created by Claude Code

v0.11.0

Pair mode: one context block, one question

Fixes the pair skill rambling — thinking out loud mid-work, then stacking two or three decisions across paragraphs and ending with a single trailing question. Adds a cross-cutting Communication protocol governing every user-facing turn:

• Do the work before you speak — no narrating dead ends or the path you took; surface a finding only when it still changes the picture, in a line.
• One turn carries one question — via AskUserQuestion, then stop and wait.
• Several decisions means several turns — ask the highest-leverage one first; its answer usually collapses the rest.

Wired into phases 1/2/4. Micro-tested against the prior version (5 reps each); captured as evals 11 + 12.

Also in this release: a new Pair Plans VS Code / Cursor extension (extensions/pair-plans/) — a sidebar view for the deliberately-uncommitted .pair-plans/ working docs so they stay handy during a session without ending up in your commits.

---

To update: /plugin update ruby-programming then /reload-plugins.

v0.10.1

v0.10.0 introduced the Discovery/Transcription tracks but explained them in three separate places — the calibrating-rigor reference, the ruby-programming Quality Loop intro, and pair's build step. Thats token weight every session pays, and three copies that can drift. This collapses calibrating-rigor.md to a single 13-line source (down from 39) and turns the inline copies into pointers at it.

No behaviour change — and I checked rather than assumed. Both tracks re-verified against the leaner guidance:

• Transcription still batches the build while running the review every phase (eval 10, still green).
• On genuinely open design the skill still goes concrete-first (Shameless Green) and defers the abstraction — the "skip it on Transcription" line didn't over-rotate into skipping it everywhere. Verified two-arm (no-skill baseline vs skill arm, no spoon-feeding): the skill arm writes the one-agency version first, the baseline over-abstracts into a registry off a single example.

Created by Claude Code

v0.10.0

calibrates how much TDD ceremony a build gets to how certain the design is — without ever skipping the review.

long agentic runs were paying full per-change TDD ceremony on transcription work (re-deriving an already-validated design one failing test at a time). a real overnight run burned ~173M tokens, ~94% cache reads, ~92 Rails-booting spec invocations — and the gates returned zero must-fix every pass. the build loop was the waste, not the design.

Two tracks (new references/calibrating-rigor.md):

• Discovery — design emerging at the keyboard: strict per-change Red→Green→Refactor→Simplify→Pre-flight, with Shameless Green.
• Transcription — design already validated (verified prototype, mechanical port, trivial change): write the target shape directly, batch the build, one comprehensive spec, no micro-loop. When unsure, default to Discovery.

Wired through pair (sets the track, passes it to the builder), execute-plan, and ruby-builder.

What does NOT calibrate — the review. We check the code against our best practices every phase regardless of track. The prototype validates the design, not the port, and was never compliance-reviewed, so the verifier + compliance gates run per phase in both tracks. Transcription streamlines the build, not the review. Guarded by eval id 10.

Also: Shameless Green is now explicitly a Discovery tool (it guards against premature abstraction; on a known design it's ceremony), the ${CLAUDE_PLUGIN_ROOT} path fix is finished on ruby-builder, and there's a .gitignore for local .claude/ settings.

Created by Claude Code

v0.9.0

adds a functional-core lens to the design references — the OO/patterns coverage was deep, but there was nothing on actions vs calculations.

• Actions, Calculations, Data — a new design-vocabulary lens, and the test behind "business logic in POROs": a method is core logic only if it's a calculation (no implicit inputs/outputs).
• Shape 13 — a calculation trapped in an action: extract the pure decision, leave a thin I/O shell.
• Shape 14 — repeated scaffolding → a higher-order block, with the block-vs-Decorator call so it doesn't just duplicate the Decorator shape.
• Copy-on-write immutability section in the skill.
• evals 13-16 guard the new shapes. heads up: baseline testing showed a strong model already gets the substance, so these really guard the named framework + false-positive resistance, not the raw answer.

also trimmed SKILL.md (moved the Sources bibliography to the README, compressed a bunch of always-on bullets) and switched the verifier/agent reference paths to ${CLAUDE_PLUGIN_ROOT} so they actually resolve for plugin-cache installs — that one was a real bug, not just tidying.

Created by Claude Code

v0.8.0

Token + wall-clock optimizations for the pair design loop, profiled from a real long session where cache reads were ~75% of the cost.

Headline: phase-per-session is the default rhythm. Each pairing feature lives in .pair-plans/<short-plan-name>/ (roadmap + numbered phase plans), and a handoff check runs before clearing context so nothing that lives only in the transcript is lost on /clear.

Also in this release:

• ruby-builder agent + a decide-first Build gate — optionally offload a phase's build to a subagent so its churn stays off the main thread. The decision happens before reading build guidance, and the builder hands back a summary + diff without ever committing or presenting (its prompt enforces the boundary).
• Parallel verifier + compliance gates — dispatched concurrently instead of serially; saves a gate's wall-clock in the common case.
• Focused-spec discipline + self-tuning large-spec memory — run focused specs inside the loop, full runs only at the verify gate; when a spec file proves large/slow, record a memory so future sessions run it focused from the start.
• Session-hygiene note — disable unused plugins/MCP before a long run.

Every behavior change went through the writing-skills RED-GREEN discipline (evals 4–9), with honest notes on which edits are genuinely additive vs. reliability insurance.

v0.7.0

Adds pre-refactor checks from Feathers' Working Effectively with Legacy Code (and Beck's tidy-first) to the preparatory-refactoring workflow.

• Prep-Refactor Path now forks on how well you can see the structure: clear → locate the seam, messy → tidy first, lost → scratch refactor on a throwaway branch
• Seam taxonomy (object / link / preprocessing) with enabling points
• Scratch-refactor learnings get a home (.pair-plans/scratch-notes.md or the impl plan) so they survive a context clear
• Same fork wired consistently through ruby-programming/SKILL.md, the implementer prompt, pair, brainstorm, and ruby-review
• New tidy-first eval (OR Eugene CSPT). No scratch eval by design — it can't be honestly elicited in isolation; evals.json notes why

v0.6.0

Add preparatory refactoring to Design step. New reference doc, all skills updated.

v0.5.1

Add Simplify step (Step 5) to Quality Loop, unify simplification checks across all skills.