Skip to main content
skill CX Codex

qgo · ai4xe, copilot — Claude Code skill: what it does, how to install

This Claude Code skill reviews a task plan, hands it to a fresh session, and guides execution through verification. It activates on qgo or an explicit hand-off in a Q discussion.

MIT ★ 136 updated 2026-11-16

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax
Open on GitHub

What qgo does

qgo revisits the discussion and current requirements, then writes a plan with scope and completion criteria. The bcheck skill reviews it independently; work proceeds only after a PASS≥4 result. Next, gclear transfers the task to a clean session.

That session carries out the work, asks rcheck to reconcile the result, makes a scoped local commit, and runs xwrap. It posts the final receipt in chat, including test outcomes, commits, and anything still outstanding. The initiating session stops once the transfer is confirmed.

The current workspace needs the suite’s seven skills: qstart, qgo, bcheck, gclear, rcheck, xwrap, and wish. Session-management tools are required too; cross-session transfer depends on them.

What it helps with

  • resolve open contradictions in a task discussion
  • prepare a plan for independent review
  • hand execution to a clean session
  • reconcile results and record a scoped commit

Example prompts for the agent

  • Run qgo on the task discussed in Q.
  • Hand off the Q discussion task with qgo.

How to install qgo

1Plugin marketplace

/plugin marketplace add AI4XE/Parallax
/plugin install parallax@parallax

This installs the whole parallax plugin with all its skills

2Skills CLI (Vercel)

npx skills add AI4XE/Parallax --skill qgo -a claude-code

3Manually: put the files in place

~/.claude/skills/qgo/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/qgo/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about qgo

How do I install qgo in Claude Code?

Add the marketplace with /plugin marketplace add AI4XE/Parallax, then install the plugin with /plugin install parallax@parallax.

What does qgo do?

It turns a Q discussion into a reviewed plan, transfers execution to a fresh session, and takes the work through verification, a scoped commit, and a chat receipt.

What does qgo need to run?

The current workspace needs qstart, qgo, bcheck, gclear, rcheck, xwrap, and wish, plus session-management tools.

Source text

SKILL.md · MIT
---
name: qgo
description: "Q workflow hand-off execution: re-check the discussion → plan → independent review (bcheck, PASS≥4) → gclear automatic hand-off to a clean session → the hand-off session executes autonomously → rcheck reconciliation → scoped commit → final receipt (solo direct-execution tier). Trigger words: qgo, Q hand-off development."
version: 2.0.1
---

# qgo — Hand-off execution

The user explicitly saying qgo, or an explicit hand-off in the Q discussion, authorizes progress without repeated confirmation. Read the exact discussion anchor for this run and the current requirement; do not guess ownership from "the most recent file". infra (non-version) and hotfix (version) share the backbone below; respect an explicit user instruction to use another flow. This skill ships its own protocol and templates; do not read other hand-off skills or host-private scripts to fill in the logic.

Display language: follow the language of the user's current message (default to English when there is no textual signal). Chat replies are the receipt — the chat message itself is the delivery channel; there is no other channel, so do not send duplicates.

Runtime prerequisites: this suite is installed in the current workspace (the seven skills qstart/qgo/bcheck/gclear/rcheck/xwrap/wish (including wish) under `.github/skills/`, plus the session-management tools). Cross-session hand-off is handled by the gclear skill; this skill does not duplicate its mechanism.

**Core structure of solo direct execution (the only tier)**: this session handles "re-check the discussion → write the plan → independent review"; after passing, gclear automatically hands off to a clean new session; the hand-off session is itself the executor and works straight through to the final receipt. No third session participates, and there is no background process to supervise or reclaim.

## 1. From discussion to reviewed plan

1. Re-check the discussion's complete overview, the user's latest requirements, and unresolved contradictions. Proceed autonomously when there are none; for contradictions that still need user judgment, ask one question at a time with options, a recommendation and a brief reason. Do not re-interrogate settled directions.
2. Lock mode, workspace/Git root, task root, actual version source and sync points, target version, document and commit ownership. Use the overview and the user's latest explicit instruction; never silently change the type by re-inferring. infra does not bump versions artificially; hotfix updates in sync with the project's actual version source.
3. Write the detailed analysis, execution plan and checklist, citing the exact discussion. Create the directory if it does not exist. By default infra uses host `docs/dev/infra/infra-plan-{discussion-timestamp}.md` and hotfix uses `docs/dev/hotfix/v{target-version}-analysis.md`; existing project conventions take precedence. If a same-named document exists, verify ownership first, do not overwrite other tasks, and use a project/task suffix compatible with the original glob if needed. Must include: goals/scope/completion criteria, rationale and plan, real verification, affected modules, pre-test cleanup, risks, **independent rcheck before commit**, hand-off-side xwrap, **reference context** (for a clean session). Put necessary differences in task material; do not copy the whole plan into a template.
4. Invoke the **bcheck skill**, following that skill's independent model, rounds and scoring rules; continue only on **PASS≥4**. Respond to each concern and re-review after fixes. Do not mistake plan review for implementation verification.
5. Weave personalized instructions appended at the call tail or during the process into the plan and hand-off; they stack on the core and do not replace gates. Neither task type introduces pre-splitting or additional gates.

## 2. Automatic hand-off (gclear)

After bcheck passes, invoke the **gclear skill** to complete the cross-session hand-off:

- Hand-off carrier = `docs/dev/handoff/gclear-context.md` (the gclear skill defines the exact format), containing: the exact path of the approved plan, the solo executor role description (role authority = this skill's `templates/solo.md` exact path; the hand-off session reads it first), the refined task context (reviewed plan, anchors, user decisions, current stage, mode/version source, allowed commit scope), and this hand-off's run token.
- Hand-off prompt = one sentence: read the hand-off context file → act as the executor → the first reply must carry `HANDOFF-ACK:<token>` → execute per the plan.
- Verification after delivery, idempotent retries and the escape hatch all follow the gclear skill; this skill does not reimplement them.
- After the hand-off is confirmed, this session gives the user a brief receipt (the new session has taken over, expected artifact anchors), then ends its turn normally. **This session does not continue executing the task afterwards** — execution authority has been fully transferred to the hand-off session.

## 3. Hand-off executor discipline (solo)

The hand-off session acts as the executor per `templates/solo.md`, flow: implementation → real-environment verification → invoke the **rcheck skill** for independent reconciliation (**PASS≥4**; fix and re-review issues) → scoped local commit → invoke the **xwrap skill** to finish todo/wrapup and necessary commits → the final receipt **directly in chat** (task identity, latest requirements, rcheck/wrapup anchors, all actual commits, test conclusions, deviations/not done/outstanding verification).

- The executor only writes task artifacts and hand-off material; **do not archive/delete any chat session** (this flow has no such need; that capability is never used).
- When the user explicitly waives a step (e.g. xwrap), follow the task material and state it truthfully.
- When the task is expected to be heavy or clearly grows mid-way, tell the user honestly and stop at a safe point to ask for help rather than forcing it through.

## 4. Delivery boundary

The final receipt is bounded by the hand-off executor completing xwrap (or an explicit user waiver) and necessary commits; it is not replaced by a business commit or a sentence like "done". The original session (the hand-off initiator) exits the task role once the hand-off is confirmed; later user adjustments go directly to the current execution session, and another gclear round can be run when needed.

© AI4XE · MIT · AI4XE/Parallax

Similar skills

All skills for Agent setup: memory, context, orchestration →

qgo by other authors comes first.

qgo AI4XE This Claude Code skill turns a task discussion into a plan and hands it to an autonomous executor. It starts on qgo or an explicit Q hand-off in the discussion. CX Codex +1 ★ 136repo stars qgo AI4XE This Claude Code skill turns an agreed discussion into a reviewed plan and hands development to an autonomous executor. It starts when the user confirms the direction and says qgo or explicitly hands off the work. CX Codex +1 ★ 136repo stars checkpoint codewithmukesh checkpoint creates a descriptive git commit and a short handoff note without ending the session. Useful right before a risky refactor. CX Codex +1 4,000installs gsd-pause-work open-gsd gsd-pause-work creates a .continue-here.md handoff file when pausing work mid-phase to preserve complete state across sessions. CX Codex +1 582installs maestro-bundle ReinaMacCredy maestro-bundle manages SPEC, NOTES, and VERIFY bundle lifecycles and controls context handoffs across agent sessions in Maestro. CX Codex +1 ★ 238repo stars deliver sno-ai This Claude Code skill carries a released charter through to verified completion. It starts with /deliver or when an agent assigns it the executor role. CX Codex +1 ★ 869repo stars shower LilMGenius The shower Claude Code skill checks whether an artifact makes sense without project context. Run it before a handoff, publication, or merge. CX Codex +1 1,500installs specify ghaida specify turns an approved design into a handoff package for a team or a coding agent: the project's own artifacts plus one entry page. CX Codex +1 3,300installs

From the same set19

The whole set →
parallax-reviewer The parallax-reviewer Claude Code subagent independently checks plans and implementation claims. Its report ends with a GATE:PASS or GATE:FAIL marker and a score. CX Codex +1 ★ 136repo stars parallax The parallax Claude Code rule structures development around discussion, a reviewed plan, and independent checks. Work then moves to a clean session for implementation and reconciliation. CX Codex +1 ★ 136repo stars qstart The qstart Claude Code skill takes a task from requirement intake through research and decision alignment. It waits for an explicit qgo before handing the task off for execution. CX Codex +1 ★ 136repo stars gclear The gclear Claude Code skill carries task context into a fresh session and sends it instructions to continue. It starts after planning or discussion when work needs to move to a new session. CX Codex +1 ★ 136repo stars gclear The gclear Claude Code skill carries working context into a fresh session after clearing the current one. It runs when a task needs to continue in a clean conversation. CX Codex +1 ★ 136repo stars qstart qstart — a Claude Code skill for gathering requirements and working through a development task. It waits for an explicit qgo before handing the agreed plan to execution. CX Codex +1 ★ 136repo stars gclear gclear — a skill for Claude Code hands work into a refreshed model context in the same conversation. It activates when a long discussion needs a compact state and continued execution. CX Codex +1 ★ 136repo stars rcheck rcheck — a skill for Claude Code compares finished work with its plan and implementation summary. It runs after a complex task to check completion and supporting evidence. CX Codex +1 ★ 136repo stars

Project sponsors

Companies that keep this analytics open