An atelier for the way you build.

1. 29 Oct 2026 A climb mod, and Claude Code can dispatch TBaguette's implementer, reviewer and investigator by name

   • New, and separate from the skills: climb, a Claude Code mod in the same marketplace (/plugin install climb --marketplace LeSplooch/tbaguette-skills). Start it with /climb 20 npm test: the mod queues the first iteration, then after every iteration it runs the check itself, so the model's own account of how it did never counts. It logs exit code, score (from a score: N line), check time and turn time to .climb-log.tsv, refuses edit-tool changes to paths you protect, and queues the next iteration until the check passes, the budget runs out, the score stops improving, the check hangs, or you stop it. A prompt you send yourself mid-climb is answered normally and does not count. --in <folder> runs the check, keeps the log and resolves protected paths in another folder. A band above the prompt shows the trail. It is the tool half of designing-verifiable-goals, which now points to it. The mod API is early access, and nothing in the skills depends on the mod.
   • The three delegation roles that Copilot CLI already had are now Claude Code agent types too: tbaguette-atelier:implementer, tbaguette-atelier:reviewer and tbaguette-atelier:investigator, shipped in the plugin's agents/ folder. Each carries its role's standing rules from delegating-tasks-with-review-gates, so a dispatch holds only the task itself instead of the whole pasted template. The reviewer and investigator have no edit or write tool (they keep a shell, so this limits them rather than sealing them). None pins a model: name one per dispatch.
   • delegating-tasks-with-review-gates now says to dispatch those types where the harness lists them, rather than a general-purpose agent.

2. 28 Oct 2026 Before a long run starts, build the check it will climb

   • New skill, designing-verifiable-goals, for the moment a goal is about to be handed to a run that will iterate on its own for hours or days: a loop or goal command, an overnight port, "do not stop until it is twice as fast". What such a run actually pursues is the check it is graded against at each iteration, so the skill has you build that check first. Use the strongest kind that exists: a pinned reference, then measured behaviour, then a model judging, with a person only at checkpoints. Make failures part of what must match, keep a slice of cases the run never sees, put a speed target behind correctness rather than trading against it, and write the bar where you want the run to stop, because it will stop there. When the check is a model judging likeness to a reference, the skill treats that judge as something the run will optimize: the reference you pick decides the result, and the judge counts only once it has rejected a deliberately broken copy. It also covers what goal texts usually leave out: a line per iteration, written by the harness rather than the run, logging time spent waiting against time spent working, and a second session asking on a schedule what is blocking the run.
   • evaluating-llm-output now says what changes when a judge sits inside a loop that iterates until it approves: each of its leanings becomes the direction the output moves, so re-check it against what the loop produced, not against what existed before.
   • fanning-out-independent-work now treats memory and cores as a shared surface, next to ports and temp space. When several workers each run a heavy build or test suite on one machine, their footprints add up, and past the edge the operating system can kill the dispatching session itself along with its background agents. Before dispatching, measure one heavy step's peak memory (/usr/bin/time -v reports it on Linux), multiply it by how many workers will hit it at once, and compare that with available memory. If it does not fit, queue the heavy step and keep the rest parallel, and commit work in progress as soon as it builds. The skill now also triggers when several workers will build or test on one machine.

3. 27 Oct 2026 A change too large for one reviewer is read by several, each on one area

   • handing-off-for-review now covers the change that cannot be split: a hand-merged result of parallel workers. Give each reviewer one area chosen by where the change can fail, a detached copy of the one commit under review so line references stay true while the authors keep working, and the instruction that the authors' reports and passing tests are not evidence. Ask for defects only, each with a failure scenario, and keep the readers apart until every report is in. Verify each claim in the code, then take the fixes in order of independent agreement: two readers naming the same defect in different words is stronger than one reader's severity label, though a lone report still gets verified rather than dropped. Its description: now routes to it.

4. 27 Oct 2026 Verify the upload before you publish the pointer, not after

   • deciding-reversibility now says where the check goes when a release uploads files and then flips one cheap pointer that running clients poll — a manifest, a tag, a DNS record. Fetch each file from its public address, hash the bytes you received and compare with the digest the pointer is about to carry, and make the flip conditional on that comparison; afterwards check only that the pointer is being served. A bad upload then cannot roll out at all, where the same finding after the flip arrives once the first clients have already run it. Its description: now covers the case, and a symptom row and a red flag carry it.

5. 26 Oct 2026 A limit the owner changes mid-run is a ruling, and a pause ends when they say so

   • orchestrating-work-end-to-end now has a row, in its table of envelope changes, for the moment an owner sets, tightens, lifts or replaces a bound on a running job: a pause until told to continue, a cap on parallel agents, a spending ceiling. Each change goes into the Rulings log with its value, who set it, when and what lifts it; older lines stay as written and the new one names what it replaces, so the newest is the whole bound. The run also says which of its work it touches and, if the owner meant it for other sessions too, tells them in the same message. A new paragraph under the table covers the pause that matters most: it is lifted by what it names, not by the clock, so a run that resumes because a quota reset has swapped its own condition for the owner's.

6. 26 Oct 2026 An approved release note is approved wording, not checked facts

   • writing-release-notes now says that approving a note does not check the details in it. An approver usually reads for tone, for what is in and what is left out, and takes every count, name, default and limit on trust from whoever drafted it, so a detail written from memory and then approved has been checked by no one. Re-derive each one from the code, configuration or data it describes, at the latest after the approval and before the note goes out; correct a slip without asking again and say so, and go back to the approver only when a correction changes what the line means. Its description: now covers a note someone approved that is about to be published, and a symptom row carries it.

7. 26 Oct 2026 A retry refused by a check its own first attempt passed

   • designing-for-idempotency now says where the key lookup goes: after authentication and before any precondition on state. A first attempt that succeeded changed the state its own checks read (the balance it debited, the stock it reserved, the name it claimed), so a retry that validates first is refused, and the caller who lost the first response hears insufficient balance about an operation that went through. On a hit the handler answers from the key's record without re-validating. It also warns that a failure path which undoes "the record for this key" deletes the first attempt's success when this attempt is a retry, and says to undo only what this attempt wrote. A symptom row carries it.

8. 26 Oct 2026 A peer handed the same request is crew, even in a checkout of its own

   • orchestrating-work-end-to-end now reads the Crew dial past the checkout. A requester can give one request to two sessions without saying so; each works in a quiet tree of its own and reads solo, the two builds diverge wherever the request left a choice open (the storage shape, the names on the wire), and they first meet at the live target both deploy to. The envelope reference now says to read what peer sessions are working on when the run is routed and again before the first live step, and to settle one owner by message before design, while the other build is still a plan; when peers cannot be listed, to ask the requester. It reads as shared tree, and the dial table, the mid-run table and a failure row carry it.

9. 23 Oct 2026 Files you staged in a shared checkout are the next writer's to commit

   • atomic-commits now covers the other direction of a sweep. Its shared-tree section warned against staging someone else's files; it now says that files you stage and leave between commands are committed by whoever next runs a git commit that names no paths, under their message, however carefully you named your own paths. The rule is to commit with the paths repeated on the commit (git commit -m "<message>" -- <paths>), which also keeps another writer's staged files out of yours, and to leave nothing staged when a command ends. It notes the two cases that form does not reach — a new file, which needs its add in the same command, and a hunk-level split, which would commit the whole file — and how to undo a sweep that has not been pushed. A symptom row carries it.

10. 19 Oct 2026 A dedupe key per route lets a second route re-send what the first already handled

    • designing-for-idempotency now separates the retries of one operation from two operations aimed at one target. Where the rule is "once per target" and two routes can do it — a single reply and a bulk reply command, a webhook and a nightly sweep — a key minted per operation or scoped per route only dedupes each route against itself, so the second one re-sends what the first handled, every key correct and no retention window long enough to help. It says to check the target's own state on every route (reserved atomically), or key on the target in one shared store, and to read every line of a bulk send's dry run until then. The scope rule now says operation type names the effect, never the code path, and the description: and a symptom row carry the new case.

11. 16 Oct 2026 Four quiet failures named: a shell loop that stops early, committed output that drifts, a retention rule that eats the archive, a path rule that waves code through

    • portable-shell-scripting now warns that a command inside a while read loop shares the loop's stdin and can eat the lines not yet read: ssh, cat, an installer's prompt or a nested read is enough, and the loop ends with status 0 having handled one or two lines. It says to give such commands </dev/null or feed the loop from another descriptor, and to test with at least two input lines. The description: now routes this case to the skill.
    • keeping-copies-in-sync now says that generated output stops being safe from drift the moment it is committed: a served site or checked-in client is a second copy again, and commits made with hooks off, merges and hooks that regenerate from unstaged edits all publish it stale. It asks for the check where the output becomes public, on the pushed revision built by its own generator, and not on the working tree. The description: now routes this case to the skill.
    • deciding-reversibility now treats a retention rule as a way a safety net gets cut: a "keep the newest N" or "older than D" job names a folder and a clock, so a deliberate archive sitting beside rolling copies is the oldest file there and is deleted first, silently. It asks you to match the rotating kind of file by pattern, keep what must survive where no rotation reaches, and name the oldest file a rule would take before arming it. The description: now routes this case to the skill.
    • reviewing-code-deeply now covers the path-shaped exemption: a rule that lightens review for "docs only" or "generated" changes by excluding a directory also exempts the hand-written scripts and styles that publishing layouts put in the same directory, so a change to executable code gets classed as prose. It asks you to exclude what the generator writes by its own list of outputs and to test the filter on a change touching both kinds. The description: now routes this case to the skill.

12. 16 Oct 2026 Changing a layer with no test runner now has a shape

    • writing-the-failing-test-first now covers code that sits where no test can run: a UI layer with no component runner, a deploy script, a rendering path only a browser exercises. It asks you to pull each rule out into something a plain test can reach and drive that red-first, to check the remaining wiring some way you can watch, and to say in the report which part was checked by hand. The harness is offered as a choice with its cost rather than added or skipped silently. The description: now routes this case to the skill.
    • checkpointing-long-runs now lists a deliberate pause as a checkpoint seam: before stopping, write down the resume point, where the unfinished work lives, and what is still running or waiting on a person, so a "where are we?" mid-run is answered from the record and not from the last notification.

13. 15 Oct 2026 Pushing a shared branch now means checking whose commits go with it

    • landing-a-finished-branch now says that a push publishes the branch tip, not just your change: on a branch another session also commits to, everything ahead of the remote goes out with it. Before pushing it asks you to list those commits (git log @{u}..HEAD), attribute each, and leave out or hold back anything that is not yours, for example by pushing from a clean worktree. The description: now routes this case to the skill.

14. 14 Oct 2026 A rule over a closed list is now tested by walking the list

    • property-based-testing now says what to do when a property ranges over a small catalogue the code already lists (themes, locales, roles, enum members): iterate that list instead of sampling it, cross it with the other dimension, check the list is not empty, and name the failing member in the report. It also asks for one more case that reconstructs the originally reported input and asserts it measured badly, so the sweep is shown capable of failing. The skill's description: now routes closed-catalogue questions to it.

15. 14 Oct 2026 Correcting a page for a changed behaviour now means searching it for the old one

    • writing-durable-docs now covers the second half of updating a document when behaviour changes. The section you rewrote is right, but the same behaviour is often still described in a table row, an FAQ answer or a store copy, in other words, and the page now contradicts itself. The skill says to search the document and every copy of it for the feature's name and the old behaviour's verbs (not for your new wording), read each hit, and edit it or keep it with a reason. The description: field now routes a page-being-corrected request to it.

16. 14 Oct 2026 A fix checked only by looking now needs a before-build

    • reproducing-bugs now covers the defect whose only check is a look (a visual fault, behaviour on one device): the commit before the fix is the control. Keep it buildable in a throwaway tree, run identical steps on the same device and data against the unfixed build and then the fixed one, and compare the captures. A symptom that vanished alongside an unrelated change of setup would otherwise be credited to the fix.

17. 14 Oct 2026 Defects only a real screen shows now get a guard

    • regression-test-from-bug now says what to do when no test at any layer can render the failure (text clipped by its container, an element pushed off a small screen): verify once on the real target, then pin a conservative proxy for the cause in the content's own test, such as a length or line-count ceiling set from the measurement with margin, and say plainly that it is a proxy.

18. 14 Oct 2026 A trigger from outside meets the state that exists when it arrives

    • modeling-state-machines now covers deep links, push actions, widget taps and scheduled jobs that fire while the thing they act on is still starting up: the handler's first chance to run is a moment inside start-up, not the state the person is looking at. Gate on an explicit ready state where the machine has one; otherwise act on a settled read (unchanged for a short quiet period, within a hard cap that degrades on purpose), built as a small pure function and tested with a changing, a constant and a never-settling sequence.

19. 14 Oct 2026 A capture on someone else's device is output you cannot take back

    • redacting-sensitive-output now covers the agent as the emitter: a screenshot of a surface that aggregates unrelated content (a notification shade, a launcher, an inbox, a tab strip, terminal scrollback) records the owner's private data beside the one item the task wanted, and the model that loads the image has seen it. The rule is to prefer a structural query filtered to the subject, assert the foreground context before capturing, and, if a stray capture happens anyway, delete it at once and say so. The skill's description: routes to it for screenshots and recordings.

20. 14 Oct 2026 Four skills get a rule they were missing

    • formidable's craft floor now covers the widths between phone and desktop (a row that gains an item breaks first at the width where it stops fitting) and controls that grow for emphasis: a transform enlarges the click target too, so it can swallow a neighbour's clicks. Keep the hit target fixed and test at the neighbour's edge.
    • performance-profiling says to measure size on the artifact that ships. A part's share before the optimizer and compressor can be many times its share after them.
    • caching-strategy asks you to cost the miss rate against the capacity the cache protects before settling a TTL, not only to ask how fast the data moves.
    • rate-limiting-and-backpressure warns that removing a retry at one layer does not lower the rate if the layer above re-drives the failure on its own tick.

Older than these, the whole record lives in UPDATES.md.