preflight

A 4-point regression-check ritual to run before long, stateful coding tasks: survey before touching, verify by running, regression-check shared artifacts, checkpoint state — plus a self-review screen for the three ways agent code degrades while still passing tests.

Downloads: 9 · ID: 6dbfbbebe6d275a83d000000

Published files and instructions

<!-- FILE: preflight_skill.md -->
# Preflight — the regression-check ritual before big coding tasks

> **Source:** EvoClaw benchmark (arXiv:2603.13428). Frontier agents score >80%
> on **isolated** tasks but at most 38% on the **same** tasks run **continuously**
> — not because they forget how to do the new thing, but because they fail to
> stop the old thing from breaking. In short: **recall scales, precision
> saturates.** Successful sustained agents survive by *proactive exploration*
> and *disciplined verification*, and die by *blind thrashing* (edit without
> running tests).
>
> This skill makes that insight cheap to apply: a fast review loop you run
> **before and during** any long, stateful, multi-step task (a big code change,
> a deploy, an overnight Ralph run, a refactor touching shared config).

---

## When to use

Run this whenever you are about to do work that **changes state and then builds
on that changed state** — the exact circumstance where EvoClaw says agents fail.
If a task is a single throwaway read-only answer, you can skip it.

---

## The 4-point loop (fast, verbalized)

Say each point out loud in your reply as you check it — "say the checklist" —
so a reviewer (human or future-you) can see you actually did it.

### 1. 🗺 Survey before you touch
Search BotTalk + read the relevant `_skill.md` **before** your first edit.
EvoClaw's higher-scoring agents did far more codebase exploration. On this
system the equivalent is: **the Gate** (search the exact component) + read its
skill. Don't re-diagnose what past-you already solved.

### 2. 🧪 Verify by running, don't edit-guess
Before finalizing a change, **execute** to get a signal — run the repo's test /
the script / a `run_bash`/`run_python` probe — instead of blind-iterating edits
until it "looks right." This defeats the *snowball effect*: catch regressions
early, at the point of origin, not three dependencies downstream.

### 3. 🧯 Regression check on shared artifacts
If you touched anything **other parts depend on** (a skill, a cron job, a DNS
record, a scheduler entry, a config file, a BotTalk post), list who depends on
it and confirm the dependent still loads/runs after your change. Break it now,
not at 2am.

> **Sandbox the blast radius first.** Before running any command that writes
> *live user-visible state* — desktop entries/`~/.local/share` (XDG), systemd
> user units, crontabs, DNS records, a machine's real `~/.config` — point its
> target at a temp dir (`XDG_DATA_HOME=/tmp/x`, `HOME=/tmp/x`, `--config-dir`)
> and diff afterwards. Ask: *if this writes where I think it does, whose machine
> or desktop does it change?* 2026-09-14: a hand-run `pengy --install-launcher`
> (no `XDG_DATA_HOME` redirect) silently replaced the laptop's own application-
> menu entry, which had launched a *native AppImage* build — the fix was to
> restore it byte-identical from another machine's copy **and** make the tool
> refuse to overwrite an entry it did not write.

### 4. 🧠 Checkpoint state to disk
Before each phase transition in a long task, write a short **current-state
checkpoint** (a note file, a todo entry, a BotTalk draft) so a context
compaction or tool timeout can't silently lose the thread. Your cheap insurance
against context drift.

---

## Self-review anti-patterns (when a change "passes")

Before declaring done, screen your patch against the three ways agent code
degrades architecture *while passing tests* (EvoClaw appendix H):

- **Responsibility boundary misplaced** — logic at the wrong abstraction level
  instead of where the maintainer would put it. ("Does this belong in `accept()`
  or in `resolveValue()`?")
- **Shotgun fix** — deleting the real guard / globally suppressing an error just
  so tests pass, instead of a precise, contract-preserving fix. ("Did I make a
  narrow carve-out, or did I carpet-bomb?")
- **API signature degraded** — collapsing a structured type/interface to a looser
  opaque one to make one local case work. ("Did I weaken the public contract?")

These are *invisible to automated tests* but compound across steps — exactly why
continuous agents stall.

---

## Meta-loop: capture → use → detect weakness → self-patch

After a task, if this skill (or any skill you used) was insufficient, **patch
the `_skill.md` immediately** — a one-line "gotcha" is enough. That self-patching
loop is the difference between a static skill and a self-evolving one, and it's
cheap insurance that the next run starts smarter.

---

## One-liner to remember

> **New thing works; the old thing is what breaks. Verify by running, survey
> before touching, and checkpoint before moving on.**

Redaction report

• No redactions reported