gptpro-handoff
Run the research/audit handoff loop between an agentic coding harness and a slow, non-agentic frontier reasoning model (GPT Pro on the ChatGPT web UI, or equivalent) with the codebase pre-loaded as split zip bundles. Author a high-signal prompt, then later take the returned report, verify every finding against the LIVE codebase, and implement what holds up. Use whenever the operator wants to send something to a deep external model, prep a prompt or report, scope an issue for deep research, bug-hunting, or optimization analysis, OR when a report comes back and needs checking against the code before anything is implemented. This is the WORKFLOW skill — to build or refresh the zip bundles themselves, use the separate `gptpro` export skill.
avenoxai · 已有静态检查记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add avenoxai/avenoxskills --skill gptpro-handoff技能说明
name: gptpro-handoff
description: >-
Run the research/audit handoff loop between an agentic coding harness and a slow,
non-agentic frontier reasoning model (GPT Pro on the ChatGPT web UI, or equivalent)
with the codebase pre-loaded as split zip bundles. Author a high-signal prompt, then
later take the returned report, verify every finding against the LIVE codebase, and
implement what holds up. Use whenever the operator wants to send something to a deep
external model, prep a prompt or report, scope an issue for deep research, bug-hunting,
or optimization analysis, OR when a report comes back and needs checking against the
code before anything is implemented. This is the WORKFLOW skill — to build or refresh
the zip bundles themselves, use the separate gptpro export skill.
Deep-model handoff loop
A slow, non-agentic frontier reasoning model is a different tool from your coding agent, and it needs a different workflow. This skill is that workflow.
Written against GPT Pro on the ChatGPT web UI, with the codebase loaded into a
Project as split zip bundles (produced by the gptpro export skill). It
transfers to any deep model you reach through a chat UI rather than a harness.
The defining fact: the model is non-agentic — no shell, no live filesystem, bounded context. It reasons over a static snapshot.
That drives the entire discipline: it proposes, you verify, then you implement. Its report is the strongest kind of input, but it is read against a snapshot that may lag the live tree, and it cannot run a test. Nothing ships unchecked. In practice the large majority of findings hold up — the job is to catch the ones that don't before they cost you.
What this model is (and how it behaves)
Internalize the model before writing for it. Its constraints and its personality both shape the prompt.
- No harness, no live repo. It runs in the chat provider's own container: no shell, no tools, no filesystem. It sees only the bundled snapshot you upload. On the harness axis it is strictly disadvantaged; its reasoning depth is what makes up for that. You give up "can run a test" to buy "can out-think the problem."
- Slow, deep, one-shot. A single answer can take ~50–60 minutes. You do not iterate cheaply. The prompt must be complete and self-contained, because there is no follow-up channel mid-run.
- The prompt is the entire interface. The agent authors it; the operator copies it verbatim into the web UI. No tool call, no back-channel. What you write is exactly and only what the model gets.
- The operator sets the reasoning tier at send time. NEVER put
reasoning-effort instructions in the prompt (no "use xhigh", no
<REASONING>block) — that's a UI control, so any such text is dead weight crowding the real instructions. - Obsessively literal. It follows instructions to the letter and hyper-focuses on exactly what you specify. A superpower for audits, and a trap for research: over-constrain a prompt meant to surface theories and it will tunnel on your seeds and never bring you the ideas you couldn't think of yourself.
Calibrate the leash to the intent
Because the model is so literal, prompt tightness is a dial you set deliberately:
- Audit / verification → tight leash. When the job is "check THIS against the code," constrain hard: VERIFIED/HYPOTHESIS labeling, confirm-or-refute each seeded hypothesis, fixed output format, DO-NOT roadmap. The rigid structure is what makes verification fast and the report triageable.
- Research / theory / exploration → loose leash. When the job is "tell us what we're missing," do the opposite: state the problem and the constraints, then explicitly grant freedom to reason independently, challenge your framing, and surface directions you didn't ask about. Seeds are a floor, not a fence — say so ("our hypotheses are a starting point; go beyond them, and tell us where we're wrong"). Leash a research prompt like an audit and you waste the one thing this model is best at.
- Blended (most real prompts) → label the halves. Mark which objectives are "verify tightly" and which are "run free."
Keep the invariants hard even on a loose leash. Free on ideas, fixed on constraints.
The loop
1. SCOPE — pin one well-framed problem with the operator (not "review everything").
2. AUTHOR — write the prompt together; save to gptpro/issue-NN-<slug>.md.
3. FRESHEN — if code changed materially since the last export, re-run `gptpro`.
4. HAND OFF — operator pastes the prompt into the web UI.
5. RECEIVE — operator brings the report back; save to gptpro/issue-NN-<slug>.report.md.
6. VERIFY — re-check every finding against the LIVE codebase (this is the gate).
7. IMPLEMENT — apply what holds up; record what didn't and why.
Steps 1–3 are one session's work. Steps 5–7 usually happen in a later session, when the report lands.
1–2. Scope and author
A good payload is one hard problem, deeply framed — not a grab-bag. Pin three things with the operator first:
- The decision — what the model should produce (a critique? a chosen design? a prioritized fix list? a teardown of an approach you doubt?).
- The frame — the minimal context that makes it answerable: constraints, what's already decided and won't be relitigated, invariants it must respect.
- Focus + anti-focus — the surfaces and files to attend to, and what's explicitly out of scope so it doesn't wander.
Then write in the house style — see references/prompt-style.md for the XML structure, the VERIFIED-vs-HYPOTHESIS rule, and a ready skeleton. Non-negotiables:
- Ground it in your code. Give the real architecture and file anchors. Seed your hypotheses, but tag each "confirm, refute, or extend against the actual code" so it verifies rather than parrots.
- Set the leash to the intent (above).
- **S